34 cl::desc(
"Enable adding flow sensitive discriminators"));
38 std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()};
41 : Variable(DII->getVariable()),
42 Fragment(DII->getExpression()->getFragmentInfo()),
46 : Variable(DPV->getVariable()),
47 Fragment(DPV->getExpression()->getFragmentInfo()),
54DILocation::DILocation(
LLVMContext &
C, StorageType Storage,
unsigned Line,
57 :
MDNode(
C, DILocationKind, Storage, MDs) {
59 "Expected a scope and optional inlined-at");
62 assert(Column < (1u << 16) &&
"Expected 16-bit column");
64 SubclassData32 = Line;
65 SubclassData16 = Column;
67 setImplicitCode(ImplicitCode);
72 if (Column >= (1u << 16))
78 Metadata *InlinedAt,
bool ImplicitCode,
79 StorageType Storage,
bool ShouldCreate) {
91 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
106 if (Locs.
size() == 1)
108 auto *Merged = Locs[0];
111 if (Merged ==
nullptr)
136 for (
auto [L,
I] = std::make_pair(LocA, 0U); L; L = L->getInlinedAt(),
I++) {
140 assert(Res.second &&
"Multiple <SP, InlinedAt> pairs in a location chain?");
144 LocVec::reverse_iterator ARIt = ALocs.rend();
145 LocVec::reverse_iterator BRIt = BLocs.rend();
151 for (
auto [L,
I] = std::make_pair(LocB, 0U); L; L = L->getInlinedAt(),
I++) {
154 if (ARIt != ALocs.rend())
158 auto IT = ALookup.
find({L->getScope()->getSubprogram(), L->getInlinedAt()});
159 if (
IT == ALookup.
end())
163 ARIt = LocVec::reverse_iterator(ALocs.begin() +
IT->second + 1);
164 BRIt = LocVec::reverse_iterator(BLocs.begin() +
I + 1);
183 if (L1->getScope()->getSubprogram() != L2->getScope()->getSubprogram())
189 for (;
S1;
S1 =
S1->getScope()) {
191 if (isa<DISubprogram>(
S1))
195 for (; S2; S2 = S2->getScope()) {
196 if (Scopes.count(S2))
198 if (isa<DISubprogram>(S2))
205 auto Scope = GetNearestCommonScope(L1->getScope(), L2->getScope());
206 assert(
Scope &&
"No common scope in the same subprogram?");
208 bool SameLine = L1->getLine() == L2->getLine();
209 bool SameCol = L1->getColumn() == L2->getColumn();
210 unsigned Line = SameLine ? L1->getLine() : 0;
211 unsigned Col = SameLine && SameCol ? L1->getColumn() : 0;
216 DILocation *Result = ARIt != ALocs.rend() ? (*ARIt)->getInlinedAt() :
nullptr;
220 for (; ARIt != ALocs.rend() && BRIt != BLocs.rend(); ++ARIt, ++BRIt) {
221 DILocation *Tmp = MergeLocPair(*ARIt, *BRIt, Result);
243std::optional<unsigned>
245 std::array<unsigned, 3> Components = {BD,
DF, CI};
253 std::accumulate(Components.begin(), Components.end(), RemainingWork);
257 unsigned NextBitInsertionIndex = 0;
258 while (RemainingWork > 0) {
259 unsigned C = Components[
I++];
262 Ret |= (EC << NextBitInsertionIndex);
270 unsigned TBD, TDF, TCI = 0;
272 if (TBD == BD && TDF ==
DF && TCI == CI)
288#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
289#include "llvm/IR/DebugInfoFlags.def"
295#define HANDLE_DI_FLAG(ID, NAME) \
297 return "DIFlag" #NAME;
298#include "llvm/IR/DebugInfoFlags.def"
309 if (
A == FlagPrivate)
311 else if (
A == FlagProtected)
318 if (R == FlagSingleInheritance)
319 SplitFlags.
push_back(FlagSingleInheritance);
320 else if (R == FlagMultipleInheritance)
321 SplitFlags.
push_back(FlagMultipleInheritance);
323 SplitFlags.
push_back(FlagVirtualInheritance);
326 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
327 Flags &= ~FlagIndirectVirtualBase;
328 SplitFlags.
push_back(FlagIndirectVirtualBase);
331#define HANDLE_DI_FLAG(ID, NAME) \
332 if (DIFlags Bit = Flags & Flag##NAME) { \
333 SplitFlags.push_back(Bit); \
336#include "llvm/IR/DebugInfoFlags.def"
341 if (
auto *
T = dyn_cast<DIType>(
this))
342 return T->getScope();
344 if (
auto *SP = dyn_cast<DISubprogram>(
this))
345 return SP->getScope();
347 if (
auto *LB = dyn_cast<DILexicalBlockBase>(
this))
348 return LB->getScope();
350 if (
auto *NS = dyn_cast<DINamespace>(
this))
351 return NS->getScope();
353 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
354 return CB->getScope();
356 if (
auto *M = dyn_cast<DIModule>(
this))
357 return M->getScope();
359 assert((isa<DIFile>(
this) || isa<DICompileUnit>(
this)) &&
360 "Unhandled type of scope.");
365 if (
auto *
T = dyn_cast<DIType>(
this))
367 if (
auto *SP = dyn_cast<DISubprogram>(
this))
368 return SP->getName();
369 if (
auto *NS = dyn_cast<DINamespace>(
this))
370 return NS->getName();
371 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
372 return CB->getName();
373 if (
auto *M = dyn_cast<DIModule>(
this))
375 assert((isa<DILexicalBlockBase>(
this) || isa<DIFile>(
this) ||
376 isa<DICompileUnit>(
this)) &&
377 "Unhandled type of scope.");
391 StorageType Storage,
bool ShouldCreate) {
399 Hash = Key.getHash();
401 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
412void GenericDINode::recalculateHash() {
413 setHash(GenericDINodeInfo::KeyTy::calculateHash(
this));
416#define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
417#define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
418#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \
420 if (Storage == Uniqued) { \
421 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
422 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \
427 assert(ShouldCreate && \
428 "Expected non-uniqued nodes to always be created"); \
431#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \
432 return storeImpl(new (std::size(OPS), Storage) \
433 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
434 Storage, Context.pImpl->CLASS##s)
435#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \
436 return storeImpl(new (0u, Storage) \
437 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \
438 Storage, Context.pImpl->CLASS##s)
439#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \
440 return storeImpl(new (std::size(OPS), Storage) CLASS(Context, Storage, OPS), \
441 Storage, Context.pImpl->CLASS##s)
442#define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \
443 return storeImpl(new (NUM_OPS, Storage) \
444 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
445 Storage, Context.pImpl->CLASS##s)
447DISubrange::DISubrange(
LLVMContext &
C, StorageType Storage,
449 :
DINode(
C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops) {}
451 StorageType Storage,
bool ShouldCreate) {
461 int64_t
Lo, StorageType Storage,
471 StorageType Storage,
bool ShouldCreate) {
482 assert((isa<ConstantAsMetadata>(CB) || isa<DIVariable>(CB) ||
483 isa<DIExpression>(CB)) &&
484 "Count must be signed constant or DIVariable or DIExpression");
486 if (
auto *MD = dyn_cast<ConstantAsMetadata>(CB))
487 return BoundType(cast<ConstantInt>(MD->getValue()));
489 if (
auto *MD = dyn_cast<DIVariable>(CB))
490 return BoundType(MD);
492 if (
auto *MD = dyn_cast<DIExpression>(CB))
493 return BoundType(MD);
503 assert((isa<ConstantAsMetadata>(LB) || isa<DIVariable>(LB) ||
504 isa<DIExpression>(LB)) &&
505 "LowerBound must be signed constant or DIVariable or DIExpression");
507 if (
auto *MD = dyn_cast<ConstantAsMetadata>(LB))
508 return BoundType(cast<ConstantInt>(MD->getValue()));
510 if (
auto *MD = dyn_cast<DIVariable>(LB))
511 return BoundType(MD);
513 if (
auto *MD = dyn_cast<DIExpression>(LB))
514 return BoundType(MD);
524 assert((isa<ConstantAsMetadata>(UB) || isa<DIVariable>(UB) ||
525 isa<DIExpression>(UB)) &&
526 "UpperBound must be signed constant or DIVariable or DIExpression");
528 if (
auto *MD = dyn_cast<ConstantAsMetadata>(UB))
529 return BoundType(cast<ConstantInt>(MD->getValue()));
531 if (
auto *MD = dyn_cast<DIVariable>(UB))
532 return BoundType(MD);
534 if (
auto *MD = dyn_cast<DIExpression>(UB))
535 return BoundType(MD);
545 assert((isa<ConstantAsMetadata>(ST) || isa<DIVariable>(ST) ||
546 isa<DIExpression>(ST)) &&
547 "Stride must be signed constant or DIVariable or DIExpression");
549 if (
auto *MD = dyn_cast<ConstantAsMetadata>(ST))
550 return BoundType(cast<ConstantInt>(MD->getValue()));
552 if (
auto *MD = dyn_cast<DIVariable>(ST))
553 return BoundType(MD);
555 if (
auto *MD = dyn_cast<DIExpression>(ST))
556 return BoundType(MD);
560DIGenericSubrange::DIGenericSubrange(
LLVMContext &
C, StorageType Storage,
562 :
DINode(
C, DIGenericSubrangeKind, Storage, dwarf::DW_TAG_generic_subrange,
571 Metadata *Ops[] = {CountNode, LB, UB, Stride};
580 assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) &&
581 "Count must be signed constant or DIVariable or DIExpression");
583 if (
auto *MD = dyn_cast<DIVariable>(CB))
586 if (
auto *MD = dyn_cast<DIExpression>(CB))
597 assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) &&
598 "LowerBound must be signed constant or DIVariable or DIExpression");
600 if (
auto *MD = dyn_cast<DIVariable>(LB))
603 if (
auto *MD = dyn_cast<DIExpression>(LB))
614 assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) &&
615 "UpperBound must be signed constant or DIVariable or DIExpression");
617 if (
auto *MD = dyn_cast<DIVariable>(UB))
620 if (
auto *MD = dyn_cast<DIExpression>(UB))
631 assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) &&
632 "Stride must be signed constant or DIVariable or DIExpression");
634 if (
auto *MD = dyn_cast<DIVariable>(ST))
637 if (
auto *MD = dyn_cast<DIExpression>(ST))
643DIEnumerator::DIEnumerator(
LLVMContext &
C, StorageType Storage,
646 :
DINode(
C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
652 StorageType Storage,
bool ShouldCreate) {
661 uint32_t AlignInBits,
unsigned Encoding,
662 DIFlags Flags, StorageType Storage,
674 case dwarf::DW_ATE_signed:
675 case dwarf::DW_ATE_signed_char:
677 case dwarf::DW_ATE_unsigned:
678 case dwarf::DW_ATE_unsigned_char:
690 unsigned Encoding, StorageType Storage,
701DIType *DIDerivedType::getClassType()
const {
703 return cast_or_null<DIType>(getExtraData());
707 if (
auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
708 if (
auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
709 return static_cast<uint32_t>(CI->getZExtValue());
714 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
715 return C->getValue();
721 getTag() == dwarf::DW_TAG_variable) &&
723 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
724 return C->getValue();
729 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
730 return C->getValue();
739 std::optional<unsigned> DWARFAddressSpace, DIFlags Flags,
741 StorageType Storage,
bool ShouldCreate) {
750 DWARFAddressSpace,
Flags),
801 if (CT->getTag() !=
Tag)
806 if (!CT->isForwardDecl() || (
Flags & DINode::FlagFwdDecl))
816 assert((std::end(Ops) - std::begin(Ops)) == (
int)CT->getNumOperands() &&
817 "Mismatched number of operands");
818 for (
unsigned I = 0,
E = CT->getNumOperands();
I !=
E; ++
I)
819 if (Ops[
I] != CT->getOperand(
I))
820 CT->setOperand(
I, Ops[
I]);
828 DIFlags Flags,
Metadata *Elements,
unsigned RuntimeLang,
843 if (CT->getTag() !=
Tag)
856DISubroutineType::DISubroutineType(
LLVMContext &
C, StorageType Storage,
857 DIFlags Flags, uint8_t
CC,
859 :
DIType(
C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type, 0,
860 0, 0, 0, Flags, Ops),
873 std::optional<ChecksumInfo<MDString *>> CS,
MDString *Src,
875 :
DIScope(
C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
876 Checksum(CS),
Source(Src) {}
886StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
894std::optional<DIFile::ChecksumKind>
906 MDString *Source, StorageType Storage,
917DICompileUnit::DICompileUnit(
LLVMContext &
C, StorageType Storage,
919 unsigned RuntimeVersion,
unsigned EmissionKind,
920 uint64_t DWOId,
bool SplitDebugInlining,
921 bool DebugInfoForProfiling,
unsigned NameTableKind,
923 :
DIScope(
C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
926 IsOptimized(IsOptimized), SplitDebugInlining(SplitDebugInlining),
927 DebugInfoForProfiling(DebugInfoForProfiling),
928 RangesBaseAddress(RangesBaseAddress) {
935 unsigned RuntimeVersion,
MDString *SplitDebugFilename,
938 uint64_t DWOId,
bool SplitDebugInlining,
bool DebugInfoForProfiling,
939 unsigned NameTableKind,
bool RangesBaseAddress,
MDString *SysRoot,
940 MDString *SDK, StorageType Storage,
bool ShouldCreate) {
959 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
960 DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
965std::optional<DICompileUnit::DebugEmissionKind>
975std::optional<DICompileUnit::DebugNameTableKind>
992 return "LineTablesOnly";
994 return "DebugDirectivesOnly";
1012DISubprogram::DISubprogram(
LLVMContext &
C, StorageType Storage,
unsigned Line,
1013 unsigned ScopeLine,
unsigned VirtualIndex,
1014 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
1016 :
DILocalScope(
C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
1017 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
1018 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
1023 unsigned Virtuality,
bool IsMainSubprogram) {
1025 static_assert(int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) &&
1026 int(SPFlagPureVirtual) ==
1027 int(dwarf::DW_VIRTUALITY_pure_virtual),
1028 "Virtuality constant mismatch");
1031 (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) |
1032 (IsDefinition ? SPFlagDefinition : SPFlagZero) |
1033 (IsOptimized ? SPFlagOptimized : SPFlagZero) |
1034 (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero));
1038 if (
auto *
Block = dyn_cast<DILexicalBlockBase>(
this))
1039 return Block->getScope()->getSubprogram();
1040 return const_cast<DISubprogram *
>(cast<DISubprogram>(
this));
1044 if (
auto *File = dyn_cast<DILexicalBlockFile>(
this))
1045 return File->getScope()->getNonLexicalBlockFileScope();
1053 DIScope *CachedResult =
nullptr;
1055 for (
DIScope *Scope = &RootScope; !isa<DISubprogram>(Scope);
1056 Scope = Scope->getScope()) {
1057 if (
auto It = Cache.
find(Scope); It != Cache.
end()) {
1058 CachedResult = cast<DIScope>(It->second);
1066 DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP;
1068 TempMDNode ClonedScope = ScopeToUpdate->
clone();
1069 cast<DILexicalBlockBase>(*ClonedScope).replaceScope(UpdatedScope);
1072 Cache[ScopeToUpdate] = UpdatedScope;
1075 return cast<DILocalScope>(UpdatedScope);
1080#define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
1081#include "llvm/IR/DebugInfoFlags.def"
1090#define HANDLE_DISP_FLAG(ID, NAME) \
1091 case SPFlag##NAME: \
1092 return "DISPFlag" #NAME;
1093#include "llvm/IR/DebugInfoFlags.def"
1104#define HANDLE_DISP_FLAG(ID, NAME) \
1105 if (DISPFlags Bit = Flags & SPFlag##NAME) { \
1106 SplitFlags.push_back(Bit); \
1109#include "llvm/IR/DebugInfoFlags.def"
1116 unsigned ScopeLine,
Metadata *ContainingType,
unsigned VirtualIndex,
1117 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
Metadata *Unit,
1120 StorageType Storage,
bool ShouldCreate) {
1151 (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,
1155bool DISubprogram::describes(
const Function *
F)
const {
1156 assert(
F &&
"Invalid function");
1157 return F->getSubprogram() ==
this;
1166 unsigned Column, StorageType Storage,
1167 bool ShouldCreate) {
1179 unsigned Discriminator,
1180 StorageType Storage,
1181 bool ShouldCreate) {
1188DINamespace::DINamespace(
LLVMContext &Context, StorageType Storage,
1190 :
DIScope(
Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, Ops) {
1195 StorageType Storage,
bool ShouldCreate) {
1203DICommonBlock::DICommonBlock(
LLVMContext &Context, StorageType Storage,
1205 :
DIScope(
Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block,
1212 StorageType Storage,
bool ShouldCreate) {
1220DIModule::DIModule(
LLVMContext &Context, StorageType Storage,
unsigned LineNo,
1222 :
DIScope(
Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {
1230 unsigned LineNo,
bool IsDecl, StorageType Storage,
1231 bool ShouldCreate) {
1239DITemplateTypeParameter::DITemplateTypeParameter(
LLVMContext &Context,
1240 StorageType Storage,
1244 dwarf::DW_TAG_template_type_parameter, IsDefault,
1250 StorageType Storage,
bool ShouldCreate) {
1259 bool isDefault,
Metadata *
Value, StorageType Storage,
bool ShouldCreate) {
1271 Metadata *StaticDataMemberDeclaration,
1274 bool ShouldCreate) {
1297 unsigned Arg, DIFlags Flags,
uint32_t AlignInBits,
1299 bool ShouldCreate) {
1301 assert(Arg <= UINT16_MAX &&
"Expected argument number to fit in 16-bits");
1314 :
DINode(
C,
ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line) {
1322 if (
auto *
T = dyn_cast<DIType>(RawType))
1326 if (
auto *DT = dyn_cast<DIDerivedType>(RawType)) {
1328 RawType = DT->getRawBaseType();
1337 return std::nullopt;
1340DILabel::DILabel(
LLVMContext &
C, StorageType Storage,
unsigned Line,
1342 :
DINode(
C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops) {
1346 Metadata *File,
unsigned Line, StorageType Storage,
1347 bool ShouldCreate) {
1357 StorageType Storage,
bool ShouldCreate) {
1363 return singleLocElts->size() > 0 &&
1370 return singleLocElts->size() > 0 &&
1371 (*singleLocElts)[0] == dwarf::DW_OP_deref;
1376 return singleLocElts->size() == 1 &&
1377 (*singleLocElts)[0] == dwarf::DW_OP_deref;
1382 bool ShouldCreate) {
1391 if (
Op >= dwarf::DW_OP_breg0 &&
Op <= dwarf::DW_OP_breg31)
1397 case dwarf::DW_OP_bregx:
1399 case dwarf::DW_OP_constu:
1400 case dwarf::DW_OP_consts:
1401 case dwarf::DW_OP_deref_size:
1402 case dwarf::DW_OP_plus_uconst:
1406 case dwarf::DW_OP_regx:
1416 if (
I->get() +
I->getSize() >
E->get())
1420 if ((
Op >= dwarf::DW_OP_reg0 &&
Op <= dwarf::DW_OP_reg31) ||
1421 (
Op >= dwarf::DW_OP_breg0 &&
Op <= dwarf::DW_OP_breg31))
1430 return I->get() +
I->getSize() ==
E->get();
1431 case dwarf::DW_OP_stack_value: {
1433 if (
I->get() +
I->getSize() ==
E->get())
1440 case dwarf::DW_OP_swap: {
1461 return I->get() == FirstOp->get() &&
I->getArg(0) == 1;
1467 case dwarf::DW_OP_constu:
1468 case dwarf::DW_OP_plus_uconst:
1469 case dwarf::DW_OP_plus:
1470 case dwarf::DW_OP_minus:
1471 case dwarf::DW_OP_mul:
1472 case dwarf::DW_OP_div:
1473 case dwarf::DW_OP_mod:
1474 case dwarf::DW_OP_or:
1475 case dwarf::DW_OP_and:
1476 case dwarf::DW_OP_xor:
1477 case dwarf::DW_OP_shl:
1478 case dwarf::DW_OP_shr:
1479 case dwarf::DW_OP_shra:
1480 case dwarf::DW_OP_deref:
1481 case dwarf::DW_OP_deref_size:
1482 case dwarf::DW_OP_xderef:
1483 case dwarf::DW_OP_lit0:
1484 case dwarf::DW_OP_not:
1485 case dwarf::DW_OP_dup:
1486 case dwarf::DW_OP_regx:
1487 case dwarf::DW_OP_bregx:
1488 case dwarf::DW_OP_push_object_address:
1489 case dwarf::DW_OP_over:
1490 case dwarf::DW_OP_consts:
1491 case dwarf::DW_OP_eq:
1492 case dwarf::DW_OP_ne:
1493 case dwarf::DW_OP_gt:
1494 case dwarf::DW_OP_ge:
1495 case dwarf::DW_OP_lt:
1496 case dwarf::DW_OP_le:
1510 for (
const auto &It :
expr_ops()) {
1511 switch (It.getOp()) {
1514 case dwarf::DW_OP_stack_value:
1531 for (
const auto &It :
expr_ops()) {
1532 switch (It.getOp()) {
1552 auto ExprOpBegin =
expr_ops().begin();
1555 if (ExprOpBegin->getArg(0) != 0)
1560 return !std::any_of(ExprOpBegin, ExprOpEnd, [](
auto Op) {
1565std::optional<ArrayRef<uint64_t>>
1569 return std::nullopt;
1595 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1605std::optional<const DIExpression *>
1608 return std::nullopt;
1613 return std::nullopt;
1622 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1635 if (
Op.getOp() == dwarf::DW_OP_stack_value ||
1640 Op.appendToVector(Ops);
1649 bool SecondIndirect) {
1655 return FirstOps == SecondOps;
1658std::optional<DIExpression::FragmentInfo>
1660 for (
auto I = Start;
I !=
End; ++
I)
1665 return std::nullopt;
1671 Ops.
push_back(dwarf::DW_OP_plus_uconst);
1685 if (!SingleLocEltsOpt)
1687 auto SingleLocElts = *SingleLocEltsOpt;
1689 if (SingleLocElts.size() == 0) {
1694 if (SingleLocElts.size() == 2 &&
1695 SingleLocElts[0] == dwarf::DW_OP_plus_uconst) {
1696 Offset = SingleLocElts[1];
1700 if (SingleLocElts.size() == 3 && SingleLocElts[0] == dwarf::DW_OP_constu) {
1701 if (SingleLocElts[2] == dwarf::DW_OP_plus) {
1702 Offset = SingleLocElts[1];
1705 if (SingleLocElts[2] == dwarf::DW_OP_minus) {
1706 Offset = -SingleLocElts[1];
1718 SeenOps.
insert(ExprOp.getArg(0));
1726 unsigned &AddrClass) {
1730 if (!SingleLocEltsOpt)
1732 auto SingleLocElts = *SingleLocEltsOpt;
1734 const unsigned PatternSize = 4;
1735 if (SingleLocElts.size() >= PatternSize &&
1736 SingleLocElts[PatternSize - 4] == dwarf::DW_OP_constu &&
1737 SingleLocElts[PatternSize - 2] == dwarf::DW_OP_swap &&
1738 SingleLocElts[PatternSize - 1] == dwarf::DW_OP_xderef) {
1739 AddrClass = SingleLocElts[PatternSize - 3];
1741 if (SingleLocElts.size() == PatternSize)
1745 ArrayRef(&*SingleLocElts.begin(), SingleLocElts.size() - PatternSize));
1769 assert(Expr &&
"Can't add ops to this expression");
1773 [](
auto Op) { return Op.getOp() == dwarf::DW_OP_LLVM_arg; })) {
1775 "Location Index must be 0 for a non-variadic expression.");
1784 if (
Op.getOp() == dwarf::DW_OP_stack_value)
1787 NewOps.
push_back(dwarf::DW_OP_stack_value);
1791 Op.appendToVector(NewOps);
1796 NewOps.
push_back(dwarf::DW_OP_stack_value);
1803 assert(Expr &&
"Can't replace args in this expression");
1809 Op.appendToVector(NewOps);
1813 uint64_t Arg =
Op.getArg(0) == OldArg ? NewArg :
Op.getArg(0);
1826 assert(Expr &&
"Can't prepend ops to this expression");
1842 if (
Op.getOp() == dwarf::DW_OP_stack_value)
1845 Ops.
push_back(dwarf::DW_OP_stack_value);
1849 Op.appendToVector(Ops);
1852 Ops.
push_back(dwarf::DW_OP_stack_value);
1858 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1864 if (
Op.getOp() == dwarf::DW_OP_stack_value ||
1871 Op.appendToVector(NewOps);
1876 assert(result->isValid() &&
"concatenated expression is not valid");
1882 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1886 return Op.getOp() == dwarf::DW_OP_stack_value ||
1887 Op.getOp() == dwarf::DW_OP_LLVM_fragment;
1889 "Can't append this op");
1896 unsigned DropUntilStackValue = FI ? 3 : 0;
1899 bool NeedsDeref = (Expr->
getNumElements() > DropUntilStackValue) &&
1900 (ExprOpsBeforeFragment.
back() != dwarf::DW_OP_stack_value);
1901 bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.
empty();
1909 if (NeedsStackValue)
1910 NewOps.
push_back(dwarf::DW_OP_stack_value);
1915 const DIExpression *Expr,
unsigned OffsetInBits,
unsigned SizeInBits) {
1919 bool CanSplitValue =
true;
1923 switch (
Op.getOp()) {
1926 case dwarf::DW_OP_shr:
1927 case dwarf::DW_OP_shra:
1928 case dwarf::DW_OP_shl:
1929 case dwarf::DW_OP_plus:
1930 case dwarf::DW_OP_plus_uconst:
1931 case dwarf::DW_OP_minus:
1937 CanSplitValue =
false;
1939 case dwarf::DW_OP_deref:
1940 case dwarf::DW_OP_deref_size:
1941 case dwarf::DW_OP_deref_type:
1942 case dwarf::DW_OP_xderef:
1943 case dwarf::DW_OP_xderef_size:
1944 case dwarf::DW_OP_xderef_type:
1947 CanSplitValue =
true;
1949 case dwarf::DW_OP_stack_value:
1952 return std::nullopt;
1956 uint64_t FragmentOffsetInBits =
Op.getArg(0);
1958 (void)FragmentSizeInBits;
1959 assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&
1960 "new fragment outside of original fragment");
1961 OffsetInBits += FragmentOffsetInBits;
1965 Op.appendToVector(Ops);
1969 assert(Expr &&
"Unknown DIExpression");
1976std::pair<DIExpression *, const ConstantInt *>
1984 bool Changed =
false;
1986 switch (
Op.getOp()) {
1999 if (
Op.getArg(1) == dwarf::DW_ATE_signed)
2002 assert(
Op.getArg(1) == dwarf::DW_ATE_unsigned &&
"Unexpected operand");
2007 Op.appendToVector(Ops);
2019 Result = std::max(Result, ExprOp.getArg(0) + 1);
2021 "Expression is missing one or more location operands.");
2025std::optional<DIExpression::SignedOrUnsignedConstant>
2038 return std::nullopt;
2046 return std::nullopt;
2061 unsigned FromSize,
unsigned ToSize,
2069 bool ShouldCreate) {
2075 unsigned Line,
unsigned Attributes,
2077 :
DINode(
C, DIObjCPropertyKind,
Storage, dwarf::DW_TAG_APPLE_property, Ops),
2083 Metadata *
Type, StorageType Storage,
bool ShouldCreate) {
2097 StorageType Storage,
2098 bool ShouldCreate) {
2108 bool ShouldCreate) {
2117 Metadata *Elements, StorageType Storage,
2118 bool ShouldCreate) {
2136 assert((!New || isa<ValueAsMetadata>(New)) &&
2137 "DIArgList must be passed a ValueAsMetadata");
2144 if (&VM == OldVMPtr) {
2156 if (ExistingArgList) {
2166void DIArgList::track() {
2171void DIArgList::untrack() {
2176void 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")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
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 SizeInBits
unsigned StringRef DIFile * File
unsigned StringRef DIFile unsigned DIScope DIType uint64_t uint32_t uint64_t std::optional< unsigned > DIFlags Flags
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
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 > DIFlags Metadata * ExtraData
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
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)
Record of a variable value-assignment, aka a non instruction representation of the dbg....
This class represents an Operation in the Expression.
This is the common base class for debug info intrinsics for variables.
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).