34 cl::desc(
"Enable adding flow sensitive discriminators"));
42 std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()};
45 : Variable(DII->getVariable()),
46 Fragment(DII->getExpression()->getFragmentInfo()),
50 : Variable(DVR->getVariable()),
51 Fragment(DVR->getExpression()->getFragmentInfo()),
58DILocation::DILocation(
LLVMContext &
C, StorageType Storage,
unsigned Line,
61 :
MDNode(
C, DILocationKind, Storage, MDs) {
63 "Expected a scope and optional inlined-at");
66 assert(Column < (1u << 16) &&
"Expected 16-bit column");
68 SubclassData32 = Line;
69 SubclassData16 = Column;
71 setImplicitCode(ImplicitCode);
76 if (Column >= (1u << 16))
82 Metadata *InlinedAt,
bool ImplicitCode,
83 StorageType Storage,
bool ShouldCreate) {
95 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
110 if (Locs.
size() == 1)
112 auto *Merged = Locs[0];
115 if (Merged ==
nullptr)
140 for (
auto [L,
I] = std::make_pair(LocA, 0U); L; L = L->getInlinedAt(),
I++) {
144 assert(Res.second &&
"Multiple <SP, InlinedAt> pairs in a location chain?");
148 LocVec::reverse_iterator ARIt = ALocs.rend();
149 LocVec::reverse_iterator BRIt = BLocs.rend();
155 for (
auto [L,
I] = std::make_pair(LocB, 0U); L; L = L->getInlinedAt(),
I++) {
158 if (ARIt != ALocs.rend())
162 auto IT = ALookup.
find({L->getScope()->getSubprogram(), L->getInlinedAt()});
163 if (
IT == ALookup.
end())
167 ARIt = LocVec::reverse_iterator(ALocs.begin() +
IT->second + 1);
168 BRIt = LocVec::reverse_iterator(BLocs.begin() +
I + 1);
187 if (L1->getScope()->getSubprogram() != L2->getScope()->getSubprogram())
193 for (;
S1;
S1 =
S1->getScope()) {
195 if (isa<DISubprogram>(
S1))
199 for (; S2; S2 = S2->getScope()) {
200 if (Scopes.count(S2))
202 if (isa<DISubprogram>(S2))
209 auto Scope = GetNearestCommonScope(L1->getScope(), L2->getScope());
210 assert(
Scope &&
"No common scope in the same subprogram?");
212 bool SameLine = L1->getLine() == L2->getLine();
213 bool SameCol = L1->getColumn() == L2->getColumn();
214 unsigned Line = SameLine ? L1->getLine() : 0;
215 unsigned Col = SameLine && SameCol ? L1->getColumn() : 0;
220 DILocation *Result = ARIt != ALocs.rend() ? (*ARIt)->getInlinedAt() :
nullptr;
224 for (; ARIt != ALocs.rend() && BRIt != BLocs.rend(); ++ARIt, ++BRIt) {
225 DILocation *Tmp = MergeLocPair(*ARIt, *BRIt, Result);
247std::optional<unsigned>
249 std::array<unsigned, 3> Components = {BD,
DF, CI};
257 std::accumulate(Components.begin(), Components.end(), RemainingWork);
261 unsigned NextBitInsertionIndex = 0;
262 while (RemainingWork > 0) {
263 unsigned C = Components[
I++];
266 Ret |= (EC << NextBitInsertionIndex);
274 unsigned TBD, TDF, TCI = 0;
276 if (TBD == BD && TDF ==
DF && TCI == CI)
292#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
293#include "llvm/IR/DebugInfoFlags.def"
299#define HANDLE_DI_FLAG(ID, NAME) \
301 return "DIFlag" #NAME;
302#include "llvm/IR/DebugInfoFlags.def"
313 if (
A == FlagPrivate)
315 else if (
A == FlagProtected)
322 if (R == FlagSingleInheritance)
323 SplitFlags.
push_back(FlagSingleInheritance);
324 else if (R == FlagMultipleInheritance)
325 SplitFlags.
push_back(FlagMultipleInheritance);
327 SplitFlags.
push_back(FlagVirtualInheritance);
330 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
331 Flags &= ~FlagIndirectVirtualBase;
332 SplitFlags.
push_back(FlagIndirectVirtualBase);
335#define HANDLE_DI_FLAG(ID, NAME) \
336 if (DIFlags Bit = Flags & Flag##NAME) { \
337 SplitFlags.push_back(Bit); \
340#include "llvm/IR/DebugInfoFlags.def"
345 if (
auto *
T = dyn_cast<DIType>(
this))
346 return T->getScope();
348 if (
auto *SP = dyn_cast<DISubprogram>(
this))
349 return SP->getScope();
351 if (
auto *LB = dyn_cast<DILexicalBlockBase>(
this))
352 return LB->getScope();
354 if (
auto *NS = dyn_cast<DINamespace>(
this))
355 return NS->getScope();
357 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
358 return CB->getScope();
360 if (
auto *M = dyn_cast<DIModule>(
this))
361 return M->getScope();
363 assert((isa<DIFile>(
this) || isa<DICompileUnit>(
this)) &&
364 "Unhandled type of scope.");
369 if (
auto *
T = dyn_cast<DIType>(
this))
371 if (
auto *SP = dyn_cast<DISubprogram>(
this))
372 return SP->getName();
373 if (
auto *NS = dyn_cast<DINamespace>(
this))
374 return NS->getName();
375 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
376 return CB->getName();
377 if (
auto *M = dyn_cast<DIModule>(
this))
379 assert((isa<DILexicalBlockBase>(
this) || isa<DIFile>(
this) ||
380 isa<DICompileUnit>(
this)) &&
381 "Unhandled type of scope.");
395 StorageType Storage,
bool ShouldCreate) {
403 Hash = Key.getHash();
405 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
416void GenericDINode::recalculateHash() {
417 setHash(GenericDINodeInfo::KeyTy::calculateHash(
this));
420#define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
421#define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
422#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \
424 if (Storage == Uniqued) { \
425 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
426 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \
431 assert(ShouldCreate && \
432 "Expected non-uniqued nodes to always be created"); \
435#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \
436 return storeImpl(new (std::size(OPS), Storage) \
437 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
438 Storage, Context.pImpl->CLASS##s)
439#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \
440 return storeImpl(new (0u, Storage) \
441 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \
442 Storage, Context.pImpl->CLASS##s)
443#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \
444 return storeImpl(new (std::size(OPS), Storage) CLASS(Context, Storage, OPS), \
445 Storage, Context.pImpl->CLASS##s)
446#define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \
447 return storeImpl(new (NUM_OPS, Storage) \
448 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
449 Storage, Context.pImpl->CLASS##s)
451DISubrange::DISubrange(
LLVMContext &
C, StorageType Storage,
453 :
DINode(
C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops) {}
455 StorageType Storage,
bool ShouldCreate) {
465 int64_t
Lo, StorageType Storage,
475 StorageType Storage,
bool ShouldCreate) {
486 assert((isa<ConstantAsMetadata>(CB) || isa<DIVariable>(CB) ||
487 isa<DIExpression>(CB)) &&
488 "Count must be signed constant or DIVariable or DIExpression");
490 if (
auto *MD = dyn_cast<ConstantAsMetadata>(CB))
491 return BoundType(cast<ConstantInt>(MD->getValue()));
493 if (
auto *MD = dyn_cast<DIVariable>(CB))
494 return BoundType(MD);
496 if (
auto *MD = dyn_cast<DIExpression>(CB))
497 return BoundType(MD);
507 assert((isa<ConstantAsMetadata>(LB) || isa<DIVariable>(LB) ||
508 isa<DIExpression>(LB)) &&
509 "LowerBound must be signed constant or DIVariable or DIExpression");
511 if (
auto *MD = dyn_cast<ConstantAsMetadata>(LB))
512 return BoundType(cast<ConstantInt>(MD->getValue()));
514 if (
auto *MD = dyn_cast<DIVariable>(LB))
515 return BoundType(MD);
517 if (
auto *MD = dyn_cast<DIExpression>(LB))
518 return BoundType(MD);
528 assert((isa<ConstantAsMetadata>(UB) || isa<DIVariable>(UB) ||
529 isa<DIExpression>(UB)) &&
530 "UpperBound must be signed constant or DIVariable or DIExpression");
532 if (
auto *MD = dyn_cast<ConstantAsMetadata>(UB))
533 return BoundType(cast<ConstantInt>(MD->getValue()));
535 if (
auto *MD = dyn_cast<DIVariable>(UB))
536 return BoundType(MD);
538 if (
auto *MD = dyn_cast<DIExpression>(UB))
539 return BoundType(MD);
549 assert((isa<ConstantAsMetadata>(ST) || isa<DIVariable>(ST) ||
550 isa<DIExpression>(ST)) &&
551 "Stride must be signed constant or DIVariable or DIExpression");
553 if (
auto *MD = dyn_cast<ConstantAsMetadata>(ST))
554 return BoundType(cast<ConstantInt>(MD->getValue()));
556 if (
auto *MD = dyn_cast<DIVariable>(ST))
557 return BoundType(MD);
559 if (
auto *MD = dyn_cast<DIExpression>(ST))
560 return BoundType(MD);
564DIGenericSubrange::DIGenericSubrange(
LLVMContext &
C, StorageType Storage,
566 :
DINode(
C, DIGenericSubrangeKind, Storage, dwarf::DW_TAG_generic_subrange,
575 Metadata *Ops[] = {CountNode, LB, UB, Stride};
584 assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) &&
585 "Count must be signed constant or DIVariable or DIExpression");
587 if (
auto *MD = dyn_cast<DIVariable>(CB))
590 if (
auto *MD = dyn_cast<DIExpression>(CB))
601 assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) &&
602 "LowerBound must be signed constant or DIVariable or DIExpression");
604 if (
auto *MD = dyn_cast<DIVariable>(LB))
607 if (
auto *MD = dyn_cast<DIExpression>(LB))
618 assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) &&
619 "UpperBound must be signed constant or DIVariable or DIExpression");
621 if (
auto *MD = dyn_cast<DIVariable>(UB))
624 if (
auto *MD = dyn_cast<DIExpression>(UB))
635 assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) &&
636 "Stride must be signed constant or DIVariable or DIExpression");
638 if (
auto *MD = dyn_cast<DIVariable>(ST))
641 if (
auto *MD = dyn_cast<DIExpression>(ST))
647DIEnumerator::DIEnumerator(
LLVMContext &
C, StorageType Storage,
650 :
DINode(
C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
656 StorageType Storage,
bool ShouldCreate) {
665 uint32_t AlignInBits,
unsigned Encoding,
666 DIFlags Flags, StorageType Storage,
678 case dwarf::DW_ATE_signed:
679 case dwarf::DW_ATE_signed_char:
681 case dwarf::DW_ATE_unsigned:
682 case dwarf::DW_ATE_unsigned_char:
694 unsigned Encoding, StorageType Storage,
711 if (
auto *CM = cast_or_null<ConstantAsMetadata>(
getExtraData()))
712 if (
auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
713 return static_cast<uint32_t>(CI->getZExtValue());
718 if (
auto *
C = cast_or_null<ConstantAsMetadata>(
getExtraData()))
719 return C->getValue();
725 getTag() == dwarf::DW_TAG_variable) &&
727 if (
auto *
C = cast_or_null<ConstantAsMetadata>(
getExtraData()))
728 return C->getValue();
733 if (
auto *
C = cast_or_null<ConstantAsMetadata>(
getExtraData()))
734 return C->getValue();
742 std::optional<unsigned> DWARFAddressSpace,
743 std::optional<PtrAuthData> PtrAuthData, DIFlags Flags,
Metadata *ExtraData,
753 DWARFAddressSpace, PtrAuthData,
Flags),
757std::optional<DIDerivedType::PtrAuthData>
758DIDerivedType::getPtrAuthData()
const {
759 return getTag() == dwarf::DW_TAG_LLVM_ptrauth_type
811 if (CT->getTag() !=
Tag)
816 if (!CT->isForwardDecl() || (
Flags & DINode::FlagFwdDecl))
826 assert((std::end(Ops) - std::begin(Ops)) == (
int)CT->getNumOperands() &&
827 "Mismatched number of operands");
828 for (
unsigned I = 0, E = CT->getNumOperands();
I != E; ++
I)
829 if (Ops[
I] != CT->getOperand(
I))
830 CT->setOperand(
I, Ops[
I]);
838 DIFlags Flags,
Metadata *Elements,
unsigned RuntimeLang,
853 if (CT->getTag() !=
Tag)
866DISubroutineType::DISubroutineType(
LLVMContext &
C, StorageType Storage,
867 DIFlags Flags, uint8_t
CC,
869 :
DIType(
C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type, 0,
870 0, 0, 0, Flags, Ops),
883 std::optional<ChecksumInfo<MDString *>> CS,
MDString *Src,
885 :
DIScope(
C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
886 Checksum(CS),
Source(Src) {}
896StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
904std::optional<DIFile::ChecksumKind>
916 MDString *Source, StorageType Storage,
927DICompileUnit::DICompileUnit(
LLVMContext &
C, StorageType Storage,
929 unsigned RuntimeVersion,
unsigned EmissionKind,
930 uint64_t DWOId,
bool SplitDebugInlining,
931 bool DebugInfoForProfiling,
unsigned NameTableKind,
933 :
DIScope(
C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
936 IsOptimized(IsOptimized), SplitDebugInlining(SplitDebugInlining),
937 DebugInfoForProfiling(DebugInfoForProfiling),
938 RangesBaseAddress(RangesBaseAddress) {
945 unsigned RuntimeVersion,
MDString *SplitDebugFilename,
948 uint64_t DWOId,
bool SplitDebugInlining,
bool DebugInfoForProfiling,
949 unsigned NameTableKind,
bool RangesBaseAddress,
MDString *SysRoot,
950 MDString *SDK, StorageType Storage,
bool ShouldCreate) {
969 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
970 DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
975std::optional<DICompileUnit::DebugEmissionKind>
985std::optional<DICompileUnit::DebugNameTableKind>
1002 return "LineTablesOnly";
1004 return "DebugDirectivesOnly";
1022DISubprogram::DISubprogram(
LLVMContext &
C, StorageType Storage,
unsigned Line,
1023 unsigned ScopeLine,
unsigned VirtualIndex,
1024 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
1026 :
DILocalScope(
C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
1027 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
1028 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
1033 unsigned Virtuality,
bool IsMainSubprogram) {
1035 static_assert(int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) &&
1036 int(SPFlagPureVirtual) ==
1037 int(dwarf::DW_VIRTUALITY_pure_virtual),
1038 "Virtuality constant mismatch");
1041 (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) |
1042 (IsDefinition ? SPFlagDefinition : SPFlagZero) |
1043 (IsOptimized ? SPFlagOptimized : SPFlagZero) |
1044 (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero));
1048 if (
auto *
Block = dyn_cast<DILexicalBlockBase>(
this))
1049 return Block->getScope()->getSubprogram();
1050 return const_cast<DISubprogram *
>(cast<DISubprogram>(
this));
1054 if (
auto *File = dyn_cast<DILexicalBlockFile>(
this))
1055 return File->getScope()->getNonLexicalBlockFileScope();
1063 DIScope *CachedResult =
nullptr;
1065 for (
DIScope *Scope = &RootScope; !isa<DISubprogram>(Scope);
1066 Scope = Scope->getScope()) {
1067 if (
auto It = Cache.
find(Scope); It != Cache.
end()) {
1068 CachedResult = cast<DIScope>(It->second);
1076 DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP;
1078 TempMDNode ClonedScope = ScopeToUpdate->
clone();
1079 cast<DILexicalBlockBase>(*ClonedScope).replaceScope(UpdatedScope);
1082 Cache[ScopeToUpdate] = UpdatedScope;
1085 return cast<DILocalScope>(UpdatedScope);
1090#define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
1091#include "llvm/IR/DebugInfoFlags.def"
1100#define HANDLE_DISP_FLAG(ID, NAME) \
1101 case SPFlag##NAME: \
1102 return "DISPFlag" #NAME;
1103#include "llvm/IR/DebugInfoFlags.def"
1114#define HANDLE_DISP_FLAG(ID, NAME) \
1115 if (DISPFlags Bit = Flags & SPFlag##NAME) { \
1116 SplitFlags.push_back(Bit); \
1119#include "llvm/IR/DebugInfoFlags.def"
1126 unsigned ScopeLine,
Metadata *ContainingType,
unsigned VirtualIndex,
1127 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
Metadata *Unit,
1130 StorageType Storage,
bool ShouldCreate) {
1161 (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,
1165bool DISubprogram::describes(
const Function *
F)
const {
1166 assert(
F &&
"Invalid function");
1167 return F->getSubprogram() ==
this;
1176 unsigned Column, StorageType Storage,
1177 bool ShouldCreate) {
1189 unsigned Discriminator,
1190 StorageType Storage,
1191 bool ShouldCreate) {
1198DINamespace::DINamespace(
LLVMContext &Context, StorageType Storage,
1200 :
DIScope(
Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, Ops) {
1205 StorageType Storage,
bool ShouldCreate) {
1213DICommonBlock::DICommonBlock(
LLVMContext &Context, StorageType Storage,
1215 :
DIScope(
Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block,
1222 StorageType Storage,
bool ShouldCreate) {
1230DIModule::DIModule(
LLVMContext &Context, StorageType Storage,
unsigned LineNo,
1232 :
DIScope(
Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {
1240 unsigned LineNo,
bool IsDecl, StorageType Storage,
1241 bool ShouldCreate) {
1249DITemplateTypeParameter::DITemplateTypeParameter(
LLVMContext &Context,
1250 StorageType Storage,
1254 dwarf::DW_TAG_template_type_parameter, IsDefault,
1260 StorageType Storage,
bool ShouldCreate) {
1269 bool isDefault,
Metadata *
Value, StorageType Storage,
bool ShouldCreate) {
1281 Metadata *StaticDataMemberDeclaration,
1284 bool ShouldCreate) {
1307 unsigned Arg, DIFlags Flags,
uint32_t AlignInBits,
1309 bool ShouldCreate) {
1311 assert(Arg <= UINT16_MAX &&
"Expected argument number to fit in 16-bits");
1324 :
DINode(
C,
ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line) {
1332 if (
auto *
T = dyn_cast<DIType>(RawType))
1336 if (
auto *DT = dyn_cast<DIDerivedType>(RawType)) {
1338 RawType = DT->getRawBaseType();
1347 return std::nullopt;
1350DILabel::DILabel(
LLVMContext &
C, StorageType Storage,
unsigned Line,
1352 :
DINode(
C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops) {
1356 Metadata *File,
unsigned Line, StorageType Storage,
1357 bool ShouldCreate) {
1367 StorageType Storage,
bool ShouldCreate) {
1373 return singleLocElts->size() > 0 &&
1380 return singleLocElts->size() > 0 &&
1381 (*singleLocElts)[0] == dwarf::DW_OP_deref;
1386 return singleLocElts->size() == 1 &&
1387 (*singleLocElts)[0] == dwarf::DW_OP_deref;
1392 bool ShouldCreate) {
1401 if (
Op >= dwarf::DW_OP_breg0 &&
Op <= dwarf::DW_OP_breg31)
1407 case dwarf::DW_OP_bregx:
1409 case dwarf::DW_OP_constu:
1410 case dwarf::DW_OP_consts:
1411 case dwarf::DW_OP_deref_size:
1412 case dwarf::DW_OP_plus_uconst:
1416 case dwarf::DW_OP_regx:
1426 if (
I->get() +
I->getSize() > E->get())
1430 if ((
Op >= dwarf::DW_OP_reg0 &&
Op <= dwarf::DW_OP_reg31) ||
1431 (
Op >= dwarf::DW_OP_breg0 &&
Op <= dwarf::DW_OP_breg31))
1440 return I->get() +
I->getSize() == E->get();
1441 case dwarf::DW_OP_stack_value: {
1443 if (
I->get() +
I->getSize() == E->get())
1450 case dwarf::DW_OP_swap: {
1471 return I->get() == FirstOp->get() &&
I->getArg(0) == 1;
1477 case dwarf::DW_OP_constu:
1478 case dwarf::DW_OP_plus_uconst:
1479 case dwarf::DW_OP_plus:
1480 case dwarf::DW_OP_minus:
1481 case dwarf::DW_OP_mul:
1482 case dwarf::DW_OP_div:
1483 case dwarf::DW_OP_mod:
1484 case dwarf::DW_OP_or:
1485 case dwarf::DW_OP_and:
1486 case dwarf::DW_OP_xor:
1487 case dwarf::DW_OP_shl:
1488 case dwarf::DW_OP_shr:
1489 case dwarf::DW_OP_shra:
1490 case dwarf::DW_OP_deref:
1491 case dwarf::DW_OP_deref_size:
1492 case dwarf::DW_OP_xderef:
1493 case dwarf::DW_OP_lit0:
1494 case dwarf::DW_OP_not:
1495 case dwarf::DW_OP_dup:
1496 case dwarf::DW_OP_regx:
1497 case dwarf::DW_OP_bregx:
1498 case dwarf::DW_OP_push_object_address:
1499 case dwarf::DW_OP_over:
1500 case dwarf::DW_OP_consts:
1501 case dwarf::DW_OP_eq:
1502 case dwarf::DW_OP_ne:
1503 case dwarf::DW_OP_gt:
1504 case dwarf::DW_OP_ge:
1505 case dwarf::DW_OP_lt:
1506 case dwarf::DW_OP_le:
1520 for (
const auto &It :
expr_ops()) {
1521 switch (It.getOp()) {
1524 case dwarf::DW_OP_stack_value:
1541 for (
const auto &It :
expr_ops()) {
1542 switch (It.getOp()) {
1562 auto ExprOpBegin =
expr_ops().begin();
1565 if (ExprOpBegin->getArg(0) != 0)
1570 return !std::any_of(ExprOpBegin, ExprOpEnd, [](
auto Op) {
1575std::optional<ArrayRef<uint64_t>>
1579 return std::nullopt;
1605 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1615std::optional<const DIExpression *>
1618 return std::nullopt;
1623 return std::nullopt;
1632 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1645 if (
Op.getOp() == dwarf::DW_OP_stack_value ||
1650 Op.appendToVector(Ops);
1659 bool SecondIndirect) {
1665 return FirstOps == SecondOps;
1668std::optional<DIExpression::FragmentInfo>
1670 for (
auto I = Start;
I !=
End; ++
I)
1675 return std::nullopt;
1681 Ops.
push_back(dwarf::DW_OP_plus_uconst);
1695 if (!SingleLocEltsOpt)
1697 auto SingleLocElts = *SingleLocEltsOpt;
1699 if (SingleLocElts.size() == 0) {
1704 if (SingleLocElts.size() == 2 &&
1705 SingleLocElts[0] == dwarf::DW_OP_plus_uconst) {
1706 Offset = SingleLocElts[1];
1710 if (SingleLocElts.size() == 3 && SingleLocElts[0] == dwarf::DW_OP_constu) {
1711 if (SingleLocElts[2] == dwarf::DW_OP_plus) {
1712 Offset = SingleLocElts[1];
1715 if (SingleLocElts[2] == dwarf::DW_OP_minus) {
1716 Offset = -SingleLocElts[1];
1728 SeenOps.
insert(ExprOp.getArg(0));
1736 unsigned &AddrClass) {
1740 if (!SingleLocEltsOpt)
1742 auto SingleLocElts = *SingleLocEltsOpt;
1744 const unsigned PatternSize = 4;
1745 if (SingleLocElts.size() >= PatternSize &&
1746 SingleLocElts[PatternSize - 4] == dwarf::DW_OP_constu &&
1747 SingleLocElts[PatternSize - 2] == dwarf::DW_OP_swap &&
1748 SingleLocElts[PatternSize - 1] == dwarf::DW_OP_xderef) {
1749 AddrClass = SingleLocElts[PatternSize - 3];
1751 if (SingleLocElts.size() == PatternSize)
1755 ArrayRef(&*SingleLocElts.begin(), SingleLocElts.size() - PatternSize));
1779 assert(Expr &&
"Can't add ops to this expression");
1783 [](
auto Op) { return Op.getOp() == dwarf::DW_OP_LLVM_arg; })) {
1785 "Location Index must be 0 for a non-variadic expression.");
1794 if (
Op.getOp() == dwarf::DW_OP_stack_value)
1797 NewOps.
push_back(dwarf::DW_OP_stack_value);
1801 Op.appendToVector(NewOps);
1806 NewOps.
push_back(dwarf::DW_OP_stack_value);
1813 assert(Expr &&
"Can't replace args in this expression");
1819 Op.appendToVector(NewOps);
1823 uint64_t Arg =
Op.getArg(0) == OldArg ? NewArg :
Op.getArg(0);
1836 assert(Expr &&
"Can't prepend ops to this expression");
1852 if (
Op.getOp() == dwarf::DW_OP_stack_value)
1855 Ops.
push_back(dwarf::DW_OP_stack_value);
1859 Op.appendToVector(Ops);
1862 Ops.
push_back(dwarf::DW_OP_stack_value);
1868 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1874 if (
Op.getOp() == dwarf::DW_OP_stack_value ||
1881 Op.appendToVector(NewOps);
1886 assert(result->isValid() &&
"concatenated expression is not valid");
1892 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1896 return Op.getOp() == dwarf::DW_OP_stack_value ||
1897 Op.getOp() == dwarf::DW_OP_LLVM_fragment;
1899 "Can't append this op");
1906 unsigned DropUntilStackValue = FI ? 3 : 0;
1909 bool NeedsDeref = (Expr->
getNumElements() > DropUntilStackValue) &&
1910 (ExprOpsBeforeFragment.
back() != dwarf::DW_OP_stack_value);
1911 bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.
empty();
1919 if (NeedsStackValue)
1920 NewOps.
push_back(dwarf::DW_OP_stack_value);
1925 const DIExpression *Expr,
unsigned OffsetInBits,
unsigned SizeInBits) {
1929 bool CanSplitValue =
true;
1933 switch (
Op.getOp()) {
1936 case dwarf::DW_OP_shr:
1937 case dwarf::DW_OP_shra:
1938 case dwarf::DW_OP_shl:
1939 case dwarf::DW_OP_plus:
1940 case dwarf::DW_OP_plus_uconst:
1941 case dwarf::DW_OP_minus:
1947 CanSplitValue =
false;
1949 case dwarf::DW_OP_deref:
1950 case dwarf::DW_OP_deref_size:
1951 case dwarf::DW_OP_deref_type:
1952 case dwarf::DW_OP_xderef:
1953 case dwarf::DW_OP_xderef_size:
1954 case dwarf::DW_OP_xderef_type:
1957 CanSplitValue =
true;
1959 case dwarf::DW_OP_stack_value:
1962 return std::nullopt;
1966 uint64_t FragmentOffsetInBits =
Op.getArg(0);
1968 (void)FragmentSizeInBits;
1969 assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&
1970 "new fragment outside of original fragment");
1971 OffsetInBits += FragmentOffsetInBits;
1975 Op.appendToVector(Ops);
1979 assert(Expr &&
"Unknown DIExpression");
1986std::pair<DIExpression *, const ConstantInt *>
1994 bool Changed =
false;
1996 switch (
Op.getOp()) {
2009 if (
Op.getArg(1) == dwarf::DW_ATE_signed)
2012 assert(
Op.getArg(1) == dwarf::DW_ATE_unsigned &&
"Unexpected operand");
2017 Op.appendToVector(Ops);
2029 Result = std::max(Result, ExprOp.getArg(0) + 1);
2031 "Expression is missing one or more location operands.");
2035std::optional<DIExpression::SignedOrUnsignedConstant>
2048 return std::nullopt;
2056 return std::nullopt;
2071 unsigned FromSize,
unsigned ToSize,
2079 bool ShouldCreate) {
2085 unsigned Line,
unsigned Attributes,
2087 :
DINode(
C, DIObjCPropertyKind,
Storage, dwarf::DW_TAG_APPLE_property, Ops),
2093 Metadata *
Type, StorageType Storage,
bool ShouldCreate) {
2107 StorageType Storage,
2108 bool ShouldCreate) {
2118 bool ShouldCreate) {
2127 Metadata *Elements, StorageType Storage,
2128 bool ShouldCreate) {
2146 assert((!New || isa<ValueAsMetadata>(New)) &&
2147 "DIArgList must be passed a ValueAsMetadata");
2154 if (&VM == OldVMPtr) {
2166 if (ExistingArgList) {
2176void DIArgList::track() {
2181void DIArgList::untrack() {
2186void DIArgList::dropAllReferences(
bool Untrack) {
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Analysis containing CSE Info
static DISubprogram * getSubprogram(bool IsDistinct, Ts &&...Args)
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static RegisterPass< DebugifyFunctionPass > DF("debugify-function", "Attach debug info to a function")
static unsigned encodingBits(unsigned C)
static unsigned encodeComponent(unsigned C)
static unsigned getNextComponentInDiscriminator(unsigned D)
Returns the next component stored in discriminator.
static unsigned getUnsignedFromPrefixEncoding(unsigned U)
Reverse transformation as getPrefixEncodingFromUnsigned.
This file contains constants used for implementing Dwarf debug support.
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallPtrSet class.
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
support::ulittle16_t & Lo
Class for arbitrary precision integers.
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
APInt sextOrTrunc(unsigned width) const
Sign extend or truncate to width.
Annotations lets you mark points and ranges inside source code, for tests:
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
const T & back() const
back - Get the last element.
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
size_t size() const
size - Get the array size.
ArrayRef< T > drop_back(size_t N=1) const
Drop the last N elements of the array.
bool empty() const
empty - Check if the array is empty.
This is the shared class of boolean and integer constants.
static ConstantInt * getSigned(IntegerType *Ty, int64_t V)
Return a ConstantInt with the specified value for the specified type.
const APInt & getValue() const
Return the constant as an APInt value reference.
This is an important base class in LLVM.
List of ValueAsMetadata, to be used as an argument to a dbg.value intrinsic.
void handleChangedOperand(void *Ref, Metadata *New)
static DIArgList * get(LLVMContext &Context, ArrayRef< ValueAsMetadata * > Args)
Basic type, like 'int' or 'float'.
unsigned StringRef uint64_t FlagZero unsigned StringRef uint64_t uint32_t unsigned DIFlags Flags
unsigned StringRef uint64_t SizeInBits
std::optional< Signedness > getSignedness() const
Return the signedness of this type, or std::nullopt if this type is neither signed nor unsigned.
unsigned getEncoding() const
unsigned StringRef uint64_t FlagZero unsigned StringRef uint64_t uint32_t AlignInBits
Metadata Metadata MDString Metadata unsigned LineNo
Metadata Metadata MDString * Name
Metadata Metadata MDString Metadata * File
static const char * nameTableKindString(DebugNameTableKind PK)
static const char * emissionKindString(DebugEmissionKind EK)
DebugEmissionKind getEmissionKind() const
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata * Macros
unsigned Metadata MDString bool MDString * Flags
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata * EnumTypes
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata * RetainedTypes
DebugNameTableKind getNameTableKind() const
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata * GlobalVariables
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata uint64_t bool bool unsigned bool MDString MDString * SDK
unsigned Metadata MDString * Producer
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata Metadata uint64_t bool bool unsigned bool MDString * SysRoot
unsigned Metadata MDString bool MDString unsigned MDString * SplitDebugFilename
unsigned Metadata MDString bool MDString unsigned MDString unsigned Metadata Metadata Metadata Metadata * ImportedEntities
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t AlignInBits
unsigned MDString Metadata unsigned Line
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata * Elements
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata * TemplateParams
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata Metadata Metadata Metadata * Rank
static DICompositeType * getODRTypeIfExists(LLVMContext &Context, MDString &Identifier)
static DICompositeType * buildODRType(LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator, Metadata *DataLocation, Metadata *Associated, Metadata *Allocated, Metadata *Rank, Metadata *Annotations)
Build a DICompositeType with the given ODR identifier.
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t OffsetInBits
unsigned MDString Metadata unsigned Metadata * Scope
unsigned MDString Metadata * File
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata Metadata Metadata * Allocated
unsigned MDString Metadata unsigned Metadata Metadata * BaseType
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Flags
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata * Discriminator
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata * DataLocation
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString * Identifier
unsigned MDString Metadata unsigned Metadata Metadata uint64_t SizeInBits
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata Metadata MDString Metadata Metadata Metadata * Associated
unsigned MDString Metadata unsigned Metadata Metadata uint64_t uint32_t uint64_t DIFlags Metadata unsigned Metadata * VTableHolder
unsigned StringRef DIFile unsigned DIScope DIType * BaseType
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t uint64_t std::optional< unsigned > std::optional< PtrAuthData > DIFlags Metadata * ExtraData
unsigned StringRef DIFile unsigned DIScope DIType uint64_t SizeInBits
Metadata * getExtraData() const
Get extra data associated with this derived type.
unsigned StringRef DIFile * File
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t uint64_t OffsetInBits
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t AlignInBits
unsigned StringRef DIFile unsigned DIScope * Scope
DIType * getClassType() const
Get casted version of extra data.
Constant * getConstant() const
Constant * getStorageOffsetInBits() const
Constant * getDiscriminantValue() const
uint32_t getVBPtrOffset() const
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t uint64_t std::optional< unsigned > std::optional< PtrAuthData > DIFlags Flags
unsigned StringRef DIFile unsigned Line
int64_t bool MDString * Name
unsigned getSize() const
Return the size of the operand.
uint64_t getOp() const
Get the operand code.
An iterator for expression operands.
element_iterator elements_end() const
bool isEntryValue() const
Check if the expression consists of exactly one entry value operand.
iterator_range< expr_op_iterator > expr_ops() const
static DIExpression * append(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Append the opcodes Ops to DIExpr.
std::array< uint64_t, 6 > ExtOps
unsigned getNumElements() const
static ExtOps getExtOps(unsigned FromSize, unsigned ToSize, bool Signed)
Returns the ops for a zero- or sign-extension in a DIExpression.
expr_op_iterator expr_op_begin() const
Visit the elements via ExprOperand wrappers.
bool extractIfOffset(int64_t &Offset) const
If this is a constant offset, extract it.
static void appendOffset(SmallVectorImpl< uint64_t > &Ops, int64_t Offset)
Append Ops with operations to apply the Offset.
bool startsWithDeref() const
Return whether the first element a DW_OP_deref.
static bool isEqualExpression(const DIExpression *FirstExpr, bool FirstIndirect, const DIExpression *SecondExpr, bool SecondIndirect)
Determines whether two debug values should produce equivalent DWARF expressions, using their DIExpres...
expr_op_iterator expr_op_end() const
bool isImplicit() const
Return whether this is an implicit location description.
element_iterator elements_begin() const
bool hasAllLocationOps(unsigned N) const
Returns true iff this DIExpression contains at least one instance of DW_OP_LLVM_arg,...
std::optional< FragmentInfo > getFragmentInfo() const
Retrieve the details of this fragment expression.
static DIExpression * appendOpsToArg(const DIExpression *Expr, ArrayRef< uint64_t > Ops, unsigned ArgNo, bool StackValue=false)
Create a copy of Expr by appending the given list of Ops to each instance of the operand DW_OP_LLVM_a...
bool isComplex() const
Return whether the location is computed on the expression stack, meaning it cannot be a simple regist...
static std::optional< FragmentInfo > getFragmentInfo(expr_op_iterator Start, expr_op_iterator End)
Retrieve the details of this fragment expression.
static std::optional< const DIExpression * > convertToNonVariadicExpression(const DIExpression *Expr)
If Expr is a valid single-location expression, i.e.
std::pair< DIExpression *, const ConstantInt * > constantFold(const ConstantInt *CI)
Try to shorten an expression with an initial constant operand.
bool isDeref() const
Return whether there is exactly one operator and it is a DW_OP_deref;.
static const DIExpression * convertToVariadicExpression(const DIExpression *Expr)
If Expr is a non-variadic expression (i.e.
uint64_t getNumLocationOperands() const
Return the number of unique location operands referred to (via DW_OP_LLVM_arg) in this expression; th...
ArrayRef< uint64_t > getElements() const
static DIExpression * replaceArg(const DIExpression *Expr, uint64_t OldArg, uint64_t NewArg)
Create a copy of Expr with each instance of DW_OP_LLVM_arg, \p OldArg replaced with DW_OP_LLVM_arg,...
static void canonicalizeExpressionOps(SmallVectorImpl< uint64_t > &Ops, const DIExpression *Expr, bool IsIndirect)
Inserts the elements of Expr into Ops modified to a canonical form, which uses DW_OP_LLVM_arg (i....
uint64_t getElement(unsigned I) const
static std::optional< DIExpression * > createFragmentExpression(const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits)
Create a DIExpression to describe one part of an aggregate variable that is fragmented across multipl...
static const DIExpression * convertToUndefExpression(const DIExpression *Expr)
Removes all elements from Expr that do not apply to an undef debug value, which includes every operat...
static DIExpression * prepend(const DIExpression *Expr, uint8_t Flags, int64_t Offset=0)
Prepend DIExpr with a deref and offset operation and optionally turn it into a stack value or/and an ...
static DIExpression * appendToStack(const DIExpression *Expr, ArrayRef< uint64_t > Ops)
Convert DIExpr into a stack value if it isn't one already by appending DW_OP_deref if needed,...
static DIExpression * appendExt(const DIExpression *Expr, unsigned FromSize, unsigned ToSize, bool Signed)
Append a zero- or sign-extension to Expr.
std::optional< ArrayRef< uint64_t > > getSingleLocationExpressionElements() const
Returns a reference to the elements contained in this expression, skipping past the leading DW_OP_LLV...
bool isSingleLocationExpression() const
Return whether the evaluated expression makes use of a single location at the start of the expression...
std::optional< SignedOrUnsignedConstant > isConstant() const
Determine whether this represents a constant value, if so.
static const DIExpression * extractAddressClass(const DIExpression *Expr, unsigned &AddrClass)
Checks if the last 4 elements of the expression are DW_OP_constu <DWARF Address Space> DW_OP_swap DW_...
static DIExpression * prependOpcodes(const DIExpression *Expr, SmallVectorImpl< uint64_t > &Ops, bool StackValue=false, bool EntryValue=false)
Prepend DIExpr with the given opcodes and optionally turn it into a stack value.
MDString MDString * Directory
static std::optional< ChecksumKind > getChecksumKind(StringRef CSKindStr)
MDString MDString std::optional< ChecksumInfo< MDString * > > CS
Metadata * getRawLowerBound() const
Metadata * getRawCountNode() const
Metadata * getRawStride() const
BoundType getLowerBound() const
Metadata * getRawUpperBound() const
BoundType getCount() const
BoundType getUpperBound() const
PointerUnion< DIVariable *, DIExpression * > BoundType
BoundType getStride() const
A pair of DIGlobalVariable and DIExpression.
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata Metadata * TemplateParams
Metadata MDString MDString Metadata unsigned Line
Metadata MDString MDString Metadata unsigned Metadata * Type
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata * StaticDataMemberDeclaration
Metadata MDString MDString * LinkageName
Metadata MDString MDString Metadata * File
Metadata MDString MDString Metadata unsigned Metadata bool bool Metadata Metadata uint32_t AlignInBits
An imported module (C++ using directive or similar).
unsigned Metadata Metadata * Entity
unsigned Metadata Metadata Metadata unsigned Line
unsigned Metadata Metadata Metadata unsigned MDString * Name
unsigned Metadata Metadata Metadata * File
unsigned Metadata * Scope
Metadata MDString Metadata unsigned Line
Metadata MDString Metadata * File
DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage, ArrayRef< Metadata * > Ops)
Metadata Metadata unsigned Discriminator
Metadata Metadata unsigned Line
DISubprogram * getSubprogram() const
Get the subprogram for this scope.
DILocalScope * getNonLexicalBlockFileScope() const
Get the first non DILexicalBlockFile scope of this scope.
static DILocalScope * cloneScopeForSubprogram(DILocalScope &RootScope, DISubprogram &NewSP, LLVMContext &Ctx, DenseMap< const MDNode *, MDNode * > &Cache)
Traverses the scope chain rooted at RootScope until it hits a Subprogram, recreating the chain with "...
Metadata MDString Metadata unsigned Metadata * Type
Metadata MDString Metadata * File
Metadata MDString Metadata unsigned Line
Metadata MDString Metadata unsigned Metadata unsigned DIFlags uint32_t AlignInBits
unsigned unsigned DILocalScope * Scope
static DILocation * getMergedLocations(ArrayRef< DILocation * > Locs)
Try to combine the vector of locations passed as input in a single one.
static std::optional< unsigned > encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI)
Raw encoding of the discriminator.
unsigned unsigned DILocalScope DILocation bool ImplicitCode
static void decodeDiscriminator(unsigned D, unsigned &BD, unsigned &DF, unsigned &CI)
Raw decoder for values in an encoded discriminator D.
static DILocation * getMergedLocation(DILocation *LocA, DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
unsigned unsigned DILocalScope DILocation * InlinedAt
unsigned unsigned Metadata * File
unsigned unsigned Metadata Metadata * Elements
unsigned unsigned MDString * Name
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
Metadata Metadata * Scope
Metadata Metadata MDString * Name
Metadata Metadata MDString MDString MDString MDString * APINotesFile
Metadata Metadata MDString MDString MDString * IncludePath
Metadata Metadata MDString MDString * ConfigurationMacros
Metadata Metadata MDString MDString MDString MDString unsigned LineNo
Metadata MDString bool ExportSymbols
Tagged DWARF-like metadata node.
dwarf::Tag getTag() const
static DIFlags getFlag(StringRef Flag)
static DIFlags splitFlags(DIFlags Flags, SmallVectorImpl< DIFlags > &SplitFlags)
Split up a flags bitfield.
static StringRef getFlagString(DIFlags Flag)
MDString Metadata unsigned MDString * GetterName
MDString Metadata unsigned MDString MDString * SetterName
Base class for scope-like contexts.
StringRef getName() const
DIScope * getScope() const
String type, Fortran CHARACTER(n)
unsigned MDString Metadata Metadata Metadata uint64_t SizeInBits
unsigned MDString Metadata Metadata Metadata uint64_t uint32_t AlignInBits
unsigned MDString Metadata Metadata Metadata * StringLocationExp
unsigned MDString Metadata Metadata * StringLengthExp
unsigned MDString Metadata * StringLength
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata * Unit
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata Metadata * Annotations
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata * ContainingType
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata * TemplateParams
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata * Declaration
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata Metadata MDString * TargetFuncName
static DISPFlags toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized, unsigned Virtuality=SPFlagNonvirtual, bool IsMainSubprogram=false)
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata Metadata * ThrownTypes
static DISPFlags getFlag(StringRef Flag)
Metadata MDString MDString Metadata * File
static DISPFlags splitFlags(DISPFlags Flags, SmallVectorImpl< DISPFlags > &SplitFlags)
Split up a flags bitfield for easier printing.
Metadata MDString MDString * LinkageName
static StringRef getFlagString(DISPFlags Flag)
Metadata MDString MDString Metadata unsigned Metadata * Type
Metadata MDString MDString Metadata unsigned Metadata unsigned Metadata unsigned int DIFlags DISPFlags Metadata Metadata Metadata Metadata * RetainedNodes
DISPFlags
Debug info subprogram flags.
BoundType getUpperBound() const
BoundType getStride() const
BoundType getLowerBound() const
BoundType getCount() const
Type array for a subprogram.
DIFlags uint8_t Metadata * TypeArray
Base class for template parameters.
unsigned MDString Metadata * Type
bool isStaticMember() const
uint32_t getAlignInBits() const
std::optional< uint64_t > getSizeInBits() const
Determines the size of the variable's type.
Metadata * getRawType() const
DIVariable(LLVMContext &C, unsigned ID, StorageType Storage, signed Line, ArrayRef< Metadata * > Ops, uint32_t AlignInBits=0)
This class represents an Operation in the Expression.
This is the common base class for debug info intrinsics for variables.
Record of a variable value-assignment, aka a non instruction representation of the dbg....
DebugVariableAggregate(const DbgVariableIntrinsic *DVI)
Identifies a unique instance of a variable.
DebugVariable(const DbgVariableIntrinsic *DII)
iterator find(const_arg_type_t< KeyT > Val)
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&... Args)
Class representing an expression and its matching format.
Generic tagged DWARF-like metadata node.
dwarf::Tag getTag() const
unsigned MDString * Header
unsigned MDString ArrayRef< Metadata * > DwarfOps
DenseSet< DIArgList *, DIArgListInfo > DIArgLists
std::optional< DenseMap< const MDString *, DICompositeType * > > DITypeMap
This is an important class for using LLVM in a threaded context.
bool isODRUniquingDebugTypes() const
Whether there is a string map for uniquing debug info identifiers across the context.
LLVMContextImpl *const pImpl
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
TempMDNode clone() const
Create a (temporary) clone of this.
static T * storeImpl(T *N, StorageType Storage, StoreT &Store)
LLVMContext & getContext() const
static std::enable_if_t< std::is_base_of< MDNode, T >::value, T * > replaceWithUniqued(std::unique_ptr< T, TempMDNodeDeleter > N)
Replace a temporary node with a uniqued one.
StringRef getString() const
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Implements a dense probed hash-table based set with some number of buckets stored inline.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void reserve(size_type N)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
iterator insert(iterator I, T &&Elt)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
constexpr bool empty() const
empty - Check if the string is empty.
A switch()-like statement whose cases are string literals.
StringSwitch & Case(StringLiteral S, T Value)
The instances of the Type class are immutable: once they are created, they are never changed.
static IntegerType * getInt64Ty(LLVMContext &C)
LLVM Value Representation.
std::pair< iterator, bool > insert(const ValueT &V)
bool contains(const_arg_type_t< ValueT > V) const
Check if the set contains the given element.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
@ C
The default llvm calling convention, compatible with C.
@ DW_OP_LLVM_entry_value
Only used in LLVM metadata.
@ DW_OP_LLVM_implicit_pointer
Only used in LLVM metadata.
@ DW_OP_LLVM_tag_offset
Only used in LLVM metadata.
@ DW_OP_LLVM_fragment
Only used in LLVM metadata.
@ DW_OP_LLVM_arg
Only used in LLVM metadata.
@ DW_OP_LLVM_convert
Only used in LLVM metadata.
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
static T * getUniqued(DenseSet< T *, InfoT > &Store, const typename InfoT::KeyTy &Key)
cl::opt< bool > EnableFSDiscriminator
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
auto reverse(ContainerTy &&C)
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
@ Ref
The access may reference the value stored in memory.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
Implement std::hash so that hash_code can be used in STL containers.
Holds the characteristics of one fragment of a larger variable.
A single checksum, represented by a Kind and a Value (a string).