33 cl::desc(
"Enable adding flow sensitive discriminators"));
37 std::numeric_limits<uint64_t>::max(), std::numeric_limits<uint64_t>::min()};
40 : Variable(DII->getVariable()),
41 Fragment(DII->getExpression()->getFragmentInfo()),
44DILocation::DILocation(
LLVMContext &
C, StorageType Storage,
unsigned Line,
47 :
MDNode(
C, DILocationKind, Storage, MDs) {
49 "Expected a scope and optional inlined-at");
52 assert(Column < (1u << 16) &&
"Expected 16-bit column");
54 SubclassData32 = Line;
55 SubclassData16 = Column;
57 setImplicitCode(ImplicitCode);
62 if (Column >= (1u << 16))
68 Metadata *InlinedAt,
bool ImplicitCode,
69 StorageType Storage,
bool ShouldCreate) {
81 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
99 auto *Merged = Locs[0];
102 if (Merged ==
nullptr)
118 std::pair<unsigned, unsigned>, 4>
123 unsigned Line = LocA->getLine();
124 unsigned Col = LocA->getColumn();
128 auto AdvanceToParentLoc = [&S, &L, &
Line, &Col]() {
132 Col = L->getColumn();
134 L = L->getInlinedAt();
139 if (
auto *LS = dyn_cast<DILocalScope>(S))
140 Locations.try_emplace(std::make_pair(LS, L), std::make_pair(
Line, Col));
141 AdvanceToParentLoc();
145 S = LocB->getScope();
146 L = LocB->getInlinedAt();
147 Line = LocB->getLine();
148 Col = LocB->getColumn();
150 if (
auto *LS = dyn_cast<DILocalScope>(S)) {
151 auto MatchLoc = Locations.find(std::make_pair(LS, L));
152 if (MatchLoc != Locations.end()) {
156 bool SameLine =
Line == MatchLoc->second.first;
157 bool SameCol = Col == MatchLoc->second.second;
159 Col = SameLine && SameCol ? Col : 0;
163 AdvanceToParentLoc();
170 S = LocA->getScope();
176std::optional<unsigned>
178 std::array<unsigned, 3> Components = {BD,
DF, CI};
186 std::accumulate(Components.begin(), Components.end(), RemainingWork);
190 unsigned NextBitInsertionIndex = 0;
191 while (RemainingWork > 0) {
192 unsigned C = Components[
I++];
195 Ret |= (EC << NextBitInsertionIndex);
203 unsigned TBD, TDF, TCI = 0;
205 if (TBD == BD && TDF ==
DF && TCI == CI)
221#define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME)
222#include "llvm/IR/DebugInfoFlags.def"
228#define HANDLE_DI_FLAG(ID, NAME) \
230 return "DIFlag" #NAME;
231#include "llvm/IR/DebugInfoFlags.def"
242 if (
A == FlagPrivate)
244 else if (
A == FlagProtected)
251 if (R == FlagSingleInheritance)
252 SplitFlags.
push_back(FlagSingleInheritance);
253 else if (R == FlagMultipleInheritance)
254 SplitFlags.
push_back(FlagMultipleInheritance);
256 SplitFlags.
push_back(FlagVirtualInheritance);
259 if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) {
260 Flags &= ~FlagIndirectVirtualBase;
261 SplitFlags.
push_back(FlagIndirectVirtualBase);
264#define HANDLE_DI_FLAG(ID, NAME) \
265 if (DIFlags Bit = Flags & Flag##NAME) { \
266 SplitFlags.push_back(Bit); \
269#include "llvm/IR/DebugInfoFlags.def"
274 if (
auto *
T = dyn_cast<DIType>(
this))
275 return T->getScope();
277 if (
auto *SP = dyn_cast<DISubprogram>(
this))
278 return SP->getScope();
280 if (
auto *LB = dyn_cast<DILexicalBlockBase>(
this))
281 return LB->getScope();
283 if (
auto *NS = dyn_cast<DINamespace>(
this))
284 return NS->getScope();
286 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
287 return CB->getScope();
289 if (
auto *M = dyn_cast<DIModule>(
this))
290 return M->getScope();
292 assert((isa<DIFile>(
this) || isa<DICompileUnit>(
this)) &&
293 "Unhandled type of scope.");
298 if (
auto *
T = dyn_cast<DIType>(
this))
300 if (
auto *SP = dyn_cast<DISubprogram>(
this))
301 return SP->getName();
302 if (
auto *NS = dyn_cast<DINamespace>(
this))
303 return NS->getName();
304 if (
auto *CB = dyn_cast<DICommonBlock>(
this))
305 return CB->getName();
306 if (
auto *M = dyn_cast<DIModule>(
this))
308 assert((isa<DILexicalBlockBase>(
this) || isa<DIFile>(
this) ||
309 isa<DICompileUnit>(
this)) &&
310 "Unhandled type of scope.");
324 StorageType Storage,
bool ShouldCreate) {
332 Hash = Key.getHash();
334 assert(ShouldCreate &&
"Expected non-uniqued nodes to always be created");
345void GenericDINode::recalculateHash() {
346 setHash(GenericDINodeInfo::KeyTy::calculateHash(
this));
349#define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
350#define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
351#define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS) \
353 if (Storage == Uniqued) { \
354 if (auto *N = getUniqued(Context.pImpl->CLASS##s, \
355 CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)))) \
360 assert(ShouldCreate && \
361 "Expected non-uniqued nodes to always be created"); \
364#define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS) \
365 return storeImpl(new (std::size(OPS), Storage) \
366 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
367 Storage, Context.pImpl->CLASS##s)
368#define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS) \
369 return storeImpl(new (0u, Storage) \
370 CLASS(Context, Storage, UNWRAP_ARGS(ARGS)), \
371 Storage, Context.pImpl->CLASS##s)
372#define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS) \
373 return storeImpl(new (std::size(OPS), Storage) CLASS(Context, Storage, OPS), \
374 Storage, Context.pImpl->CLASS##s)
375#define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS) \
376 return storeImpl(new (NUM_OPS, Storage) \
377 CLASS(Context, Storage, UNWRAP_ARGS(ARGS), OPS), \
378 Storage, Context.pImpl->CLASS##s)
380DISubrange::DISubrange(
LLVMContext &
C, StorageType Storage,
382 :
DINode(
C, DISubrangeKind, Storage, dwarf::DW_TAG_subrange_type, Ops) {}
384 StorageType Storage,
bool ShouldCreate) {
394 int64_t
Lo, StorageType Storage,
404 StorageType Storage,
bool ShouldCreate) {
415 assert((isa<ConstantAsMetadata>(CB) || isa<DIVariable>(CB) ||
416 isa<DIExpression>(CB)) &&
417 "Count must be signed constant or DIVariable or DIExpression");
419 if (
auto *MD = dyn_cast<ConstantAsMetadata>(CB))
420 return BoundType(cast<ConstantInt>(MD->getValue()));
422 if (
auto *MD = dyn_cast<DIVariable>(CB))
423 return BoundType(MD);
425 if (
auto *MD = dyn_cast<DIExpression>(CB))
426 return BoundType(MD);
436 assert((isa<ConstantAsMetadata>(LB) || isa<DIVariable>(LB) ||
437 isa<DIExpression>(LB)) &&
438 "LowerBound must be signed constant or DIVariable or DIExpression");
440 if (
auto *MD = dyn_cast<ConstantAsMetadata>(LB))
441 return BoundType(cast<ConstantInt>(MD->getValue()));
443 if (
auto *MD = dyn_cast<DIVariable>(LB))
444 return BoundType(MD);
446 if (
auto *MD = dyn_cast<DIExpression>(LB))
447 return BoundType(MD);
457 assert((isa<ConstantAsMetadata>(UB) || isa<DIVariable>(UB) ||
458 isa<DIExpression>(UB)) &&
459 "UpperBound must be signed constant or DIVariable or DIExpression");
461 if (
auto *MD = dyn_cast<ConstantAsMetadata>(UB))
462 return BoundType(cast<ConstantInt>(MD->getValue()));
464 if (
auto *MD = dyn_cast<DIVariable>(UB))
465 return BoundType(MD);
467 if (
auto *MD = dyn_cast<DIExpression>(UB))
468 return BoundType(MD);
478 assert((isa<ConstantAsMetadata>(ST) || isa<DIVariable>(ST) ||
479 isa<DIExpression>(ST)) &&
480 "Stride must be signed constant or DIVariable or DIExpression");
482 if (
auto *MD = dyn_cast<ConstantAsMetadata>(ST))
483 return BoundType(cast<ConstantInt>(MD->getValue()));
485 if (
auto *MD = dyn_cast<DIVariable>(ST))
486 return BoundType(MD);
488 if (
auto *MD = dyn_cast<DIExpression>(ST))
489 return BoundType(MD);
493DIGenericSubrange::DIGenericSubrange(
LLVMContext &
C, StorageType Storage,
495 :
DINode(
C, DIGenericSubrangeKind, Storage, dwarf::DW_TAG_generic_subrange,
504 Metadata *Ops[] = {CountNode, LB, UB, Stride};
513 assert((isa<DIVariable>(CB) || isa<DIExpression>(CB)) &&
514 "Count must be signed constant or DIVariable or DIExpression");
516 if (
auto *MD = dyn_cast<DIVariable>(CB))
519 if (
auto *MD = dyn_cast<DIExpression>(CB))
530 assert((isa<DIVariable>(LB) || isa<DIExpression>(LB)) &&
531 "LowerBound must be signed constant or DIVariable or DIExpression");
533 if (
auto *MD = dyn_cast<DIVariable>(LB))
536 if (
auto *MD = dyn_cast<DIExpression>(LB))
547 assert((isa<DIVariable>(UB) || isa<DIExpression>(UB)) &&
548 "UpperBound must be signed constant or DIVariable or DIExpression");
550 if (
auto *MD = dyn_cast<DIVariable>(UB))
553 if (
auto *MD = dyn_cast<DIExpression>(UB))
564 assert((isa<DIVariable>(ST) || isa<DIExpression>(ST)) &&
565 "Stride must be signed constant or DIVariable or DIExpression");
567 if (
auto *MD = dyn_cast<DIVariable>(ST))
570 if (
auto *MD = dyn_cast<DIExpression>(ST))
576DIEnumerator::DIEnumerator(
LLVMContext &
C, StorageType Storage,
579 :
DINode(
C, DIEnumeratorKind, Storage, dwarf::DW_TAG_enumerator, Ops),
585 StorageType Storage,
bool ShouldCreate) {
594 uint32_t AlignInBits,
unsigned Encoding,
595 DIFlags Flags, StorageType Storage,
607 case dwarf::DW_ATE_signed:
608 case dwarf::DW_ATE_signed_char:
610 case dwarf::DW_ATE_unsigned:
611 case dwarf::DW_ATE_unsigned_char:
623 unsigned Encoding, StorageType Storage,
634DIType *DIDerivedType::getClassType()
const {
636 return cast_or_null<DIType>(getExtraData());
640 if (
auto *CM = cast_or_null<ConstantAsMetadata>(getExtraData()))
641 if (
auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
642 return static_cast<uint32_t>(CI->getZExtValue());
647 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
648 return C->getValue();
654 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
655 return C->getValue();
660 if (
auto *
C = cast_or_null<ConstantAsMetadata>(getExtraData()))
661 return C->getValue();
670 std::optional<unsigned> DWARFAddressSpace, DIFlags Flags,
672 StorageType Storage,
bool ShouldCreate) {
681 DWARFAddressSpace,
Flags),
732 if (CT->getTag() !=
Tag)
737 if (!CT->isForwardDecl() || (
Flags & DINode::FlagFwdDecl))
747 assert((std::end(Ops) - std::begin(Ops)) == (
int)CT->getNumOperands() &&
748 "Mismatched number of operands");
749 for (
unsigned I = 0,
E = CT->getNumOperands();
I !=
E; ++
I)
750 if (Ops[
I] != CT->getOperand(
I))
751 CT->setOperand(
I, Ops[
I]);
759 DIFlags Flags,
Metadata *Elements,
unsigned RuntimeLang,
774 if (CT->getTag() !=
Tag)
787DISubroutineType::DISubroutineType(
LLVMContext &
C, StorageType Storage,
788 DIFlags Flags, uint8_t
CC,
790 :
DIType(
C, DISubroutineTypeKind, Storage, dwarf::DW_TAG_subroutine_type, 0,
791 0, 0, 0, Flags, Ops),
804 std::optional<ChecksumInfo<MDString *>> CS,
MDString *Src,
806 :
DIScope(
C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
807 Checksum(CS),
Source(Src) {}
817StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) {
825std::optional<DIFile::ChecksumKind>
837 MDString *Source, StorageType Storage,
848DICompileUnit::DICompileUnit(
LLVMContext &
C, StorageType Storage,
850 unsigned RuntimeVersion,
unsigned EmissionKind,
851 uint64_t DWOId,
bool SplitDebugInlining,
852 bool DebugInfoForProfiling,
unsigned NameTableKind,
854 :
DIScope(
C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
857 SplitDebugInlining(SplitDebugInlining),
858 DebugInfoForProfiling(DebugInfoForProfiling),
866 unsigned RuntimeVersion,
MDString *SplitDebugFilename,
869 uint64_t DWOId,
bool SplitDebugInlining,
bool DebugInfoForProfiling,
870 unsigned NameTableKind,
bool RangesBaseAddress,
MDString *SysRoot,
871 MDString *SDK, StorageType Storage,
bool ShouldCreate) {
890 RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
891 DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
896std::optional<DICompileUnit::DebugEmissionKind>
906std::optional<DICompileUnit::DebugNameTableKind>
922 return "LineTablesOnly";
924 return "DebugDirectivesOnly";
940DISubprogram::DISubprogram(
LLVMContext &
C, StorageType Storage,
unsigned Line,
941 unsigned ScopeLine,
unsigned VirtualIndex,
942 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
944 :
DILocalScope(
C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
945 Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
946 ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
951 unsigned Virtuality,
bool IsMainSubprogram) {
953 static_assert(int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) &&
954 int(SPFlagPureVirtual) ==
955 int(dwarf::DW_VIRTUALITY_pure_virtual),
956 "Virtuality constant mismatch");
959 (IsLocalToUnit ? SPFlagLocalToUnit : SPFlagZero) |
960 (IsDefinition ? SPFlagDefinition : SPFlagZero) |
961 (IsOptimized ? SPFlagOptimized : SPFlagZero) |
962 (IsMainSubprogram ? SPFlagMainSubprogram : SPFlagZero));
966 if (
auto *
Block = dyn_cast<DILexicalBlockBase>(
this))
967 return Block->getScope()->getSubprogram();
968 return const_cast<DISubprogram *
>(cast<DISubprogram>(
this));
972 if (
auto *File = dyn_cast<DILexicalBlockFile>(
this))
973 return File->getScope()->getNonLexicalBlockFileScope();
981 DIScope *CachedResult =
nullptr;
983 for (
DIScope *Scope = &RootScope; !isa<DISubprogram>(Scope);
984 Scope = Scope->getScope()) {
985 if (
auto It = Cache.
find(Scope); It != Cache.
end()) {
986 CachedResult = cast<DIScope>(It->second);
994 DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP;
996 TempMDNode ClonedScope = ScopeToUpdate->
clone();
997 cast<DILexicalBlockBase>(*ClonedScope).replaceScope(UpdatedScope);
1000 Cache[ScopeToUpdate] = UpdatedScope;
1003 return cast<DILocalScope>(UpdatedScope);
1008#define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
1009#include "llvm/IR/DebugInfoFlags.def"
1018#define HANDLE_DISP_FLAG(ID, NAME) \
1019 case SPFlag##NAME: \
1020 return "DISPFlag" #NAME;
1021#include "llvm/IR/DebugInfoFlags.def"
1032#define HANDLE_DISP_FLAG(ID, NAME) \
1033 if (DISPFlags Bit = Flags & SPFlag##NAME) { \
1034 SplitFlags.push_back(Bit); \
1037#include "llvm/IR/DebugInfoFlags.def"
1044 unsigned ScopeLine,
Metadata *ContainingType,
unsigned VirtualIndex,
1045 int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
Metadata *Unit,
1048 StorageType Storage,
bool ShouldCreate) {
1079 (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,
1083bool DISubprogram::describes(
const Function *
F)
const {
1084 assert(
F &&
"Invalid function");
1085 return F->getSubprogram() ==
this;
1094 unsigned Column, StorageType Storage,
1095 bool ShouldCreate) {
1107 unsigned Discriminator,
1108 StorageType Storage,
1109 bool ShouldCreate) {
1116DINamespace::DINamespace(
LLVMContext &Context, StorageType Storage,
1118 :
DIScope(
Context, DINamespaceKind, Storage, dwarf::DW_TAG_namespace, Ops),
1119 ExportSymbols(ExportSymbols) {}
1122 StorageType Storage,
bool ShouldCreate) {
1130DICommonBlock::DICommonBlock(
LLVMContext &Context, StorageType Storage,
1132 :
DIScope(
Context, DICommonBlockKind, Storage, dwarf::DW_TAG_common_block,
1138 StorageType Storage,
bool ShouldCreate) {
1146DIModule::DIModule(
LLVMContext &Context, StorageType Storage,
unsigned LineNo,
1148 :
DIScope(
Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops),
1149 LineNo(LineNo), IsDecl(IsDecl) {}
1154 unsigned LineNo,
bool IsDecl, StorageType Storage,
1155 bool ShouldCreate) {
1163DITemplateTypeParameter::DITemplateTypeParameter(
LLVMContext &Context,
1164 StorageType Storage,
1168 dwarf::DW_TAG_template_type_parameter, IsDefault,
1174 StorageType Storage,
bool ShouldCreate) {
1183 bool isDefault,
Metadata *
Value, StorageType Storage,
bool ShouldCreate) {
1195 Metadata *StaticDataMemberDeclaration,
1198 bool ShouldCreate) {
1221 unsigned Arg, DIFlags Flags,
uint32_t AlignInBits,
1223 bool ShouldCreate) {
1225 assert(Arg <= UINT16_MAX &&
"Expected argument number to fit in 16-bits");
1238 :
DINode(
C,
ID, Storage, dwarf::DW_TAG_variable, Ops), Line(Line),
1239 AlignInBits(AlignInBits) {}
1245 if (
auto *
T = dyn_cast<DIType>(RawType))
1249 if (
auto *DT = dyn_cast<DIDerivedType>(RawType)) {
1251 RawType = DT->getRawBaseType();
1260 return std::nullopt;
1263DILabel::DILabel(
LLVMContext &
C, StorageType Storage,
unsigned Line,
1265 :
DINode(
C, DILabelKind, Storage, dwarf::DW_TAG_label, Ops), Line(Line) {}
1267 Metadata *File,
unsigned Line, StorageType Storage,
1268 bool ShouldCreate) {
1278 StorageType Storage,
bool ShouldCreate) {
1293 bool ShouldCreate) {
1302 if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)
1308 case dwarf::DW_OP_bregx:
1310 case dwarf::DW_OP_constu:
1311 case dwarf::DW_OP_consts:
1312 case dwarf::DW_OP_deref_size:
1313 case dwarf::DW_OP_plus_uconst:
1317 case dwarf::DW_OP_regx:
1327 if (
I->get() +
I->getSize() >
E->get())
1331 if ((Op >= dwarf::DW_OP_reg0 && Op <= dwarf::DW_OP_reg31) ||
1332 (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31))
1341 return I->get() +
I->getSize() ==
E->get();
1342 case dwarf::DW_OP_stack_value: {
1344 if (
I->get() +
I->getSize() ==
E->get())
1351 case dwarf::DW_OP_swap: {
1372 return I->get() == FirstOp->get() &&
I->getArg(0) == 1;
1378 case dwarf::DW_OP_constu:
1379 case dwarf::DW_OP_plus_uconst:
1380 case dwarf::DW_OP_plus:
1381 case dwarf::DW_OP_minus:
1382 case dwarf::DW_OP_mul:
1383 case dwarf::DW_OP_div:
1384 case dwarf::DW_OP_mod:
1385 case dwarf::DW_OP_or:
1386 case dwarf::DW_OP_and:
1387 case dwarf::DW_OP_xor:
1388 case dwarf::DW_OP_shl:
1389 case dwarf::DW_OP_shr:
1390 case dwarf::DW_OP_shra:
1391 case dwarf::DW_OP_deref:
1392 case dwarf::DW_OP_deref_size:
1393 case dwarf::DW_OP_xderef:
1394 case dwarf::DW_OP_lit0:
1395 case dwarf::DW_OP_not:
1396 case dwarf::DW_OP_dup:
1397 case dwarf::DW_OP_regx:
1398 case dwarf::DW_OP_bregx:
1399 case dwarf::DW_OP_push_object_address:
1400 case dwarf::DW_OP_over:
1401 case dwarf::DW_OP_consts:
1415 for (
const auto &It :
expr_ops()) {
1416 switch (It.getOp()) {
1419 case dwarf::DW_OP_stack_value:
1437 for (
const auto &It :
expr_ops()) {
1438 switch (It.getOp()) {
1458 auto ExprOpBegin =
expr_ops().begin();
1463 return !std::any_of(ExprOpBegin, ExprOpEnd, [](
auto Op) {
1481 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1491std::optional<const DIExpression *>
1495 return std::nullopt;
1518 return ExprOp.getOp() == dwarf::DW_OP_LLVM_arg;
1531 if (Op.getOp() == dwarf::DW_OP_stack_value ||
1536 Op.appendToVector(Ops);
1545 bool SecondIndirect) {
1551 return FirstOps == SecondOps;
1554std::optional<DIExpression::FragmentInfo>
1556 for (
auto I = Start;
I != End; ++
I)
1561 return std::nullopt;
1567 Ops.
push_back(dwarf::DW_OP_plus_uconst);
1585 if (
getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
1590 if (
getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
1591 if (Elements[2] == dwarf::DW_OP_plus) {
1595 if (Elements[2] == dwarf::DW_OP_minus) {
1608 SeenOps.
insert(ExprOp.getArg(0));
1616 unsigned &AddrClass) {
1619 const unsigned PatternSize = 4;
1620 if (Expr->Elements.size() >= PatternSize &&
1621 Expr->Elements[PatternSize - 4] == dwarf::DW_OP_constu &&
1622 Expr->Elements[PatternSize - 2] == dwarf::DW_OP_swap &&
1623 Expr->Elements[PatternSize - 1] == dwarf::DW_OP_xderef) {
1624 AddrClass = Expr->Elements[PatternSize - 3];
1626 if (Expr->Elements.size() == PatternSize)
1630 Expr->Elements.size() - PatternSize));
1654 assert(Expr &&
"Can't add ops to this expression");
1658 [](
auto Op) { return Op.getOp() == dwarf::DW_OP_LLVM_arg; })) {
1660 "Location Index must be 0 for a non-variadic expression.");
1669 if (Op.getOp() == dwarf::DW_OP_stack_value)
1672 NewOps.
push_back(dwarf::DW_OP_stack_value);
1676 Op.appendToVector(NewOps);
1681 NewOps.
push_back(dwarf::DW_OP_stack_value);
1688 assert(Expr &&
"Can't replace args in this expression");
1694 Op.appendToVector(NewOps);
1698 uint64_t Arg = Op.getArg(0) == OldArg ? NewArg : Op.getArg(0);
1711 assert(Expr &&
"Can't prepend ops to this expression");
1727 if (Op.getOp() == dwarf::DW_OP_stack_value)
1730 Ops.
push_back(dwarf::DW_OP_stack_value);
1734 Op.appendToVector(Ops);
1737 Ops.
push_back(dwarf::DW_OP_stack_value);
1743 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1749 if (Op.getOp() == dwarf::DW_OP_stack_value ||
1756 Op.appendToVector(NewOps);
1761 assert(result->isValid() &&
"concatenated expression is not valid");
1767 assert(Expr && !Ops.
empty() &&
"Can't append ops to this expression");
1770 return Op == dwarf::DW_OP_stack_value ||
1773 "Can't append this op");
1780 unsigned DropUntilStackValue = FI ? 3 : 0;
1783 bool NeedsDeref = (Expr->
getNumElements() > DropUntilStackValue) &&
1784 (ExprOpsBeforeFragment.
back() != dwarf::DW_OP_stack_value);
1785 bool NeedsStackValue = NeedsDeref || ExprOpsBeforeFragment.
empty();
1793 if (NeedsStackValue)
1794 NewOps.
push_back(dwarf::DW_OP_stack_value);
1799 const DIExpression *Expr,
unsigned OffsetInBits,
unsigned SizeInBits) {
1803 bool CanSplitValue =
true;
1807 switch (Op.getOp()) {
1810 case dwarf::DW_OP_shr:
1811 case dwarf::DW_OP_shra:
1812 case dwarf::DW_OP_shl:
1813 case dwarf::DW_OP_plus:
1814 case dwarf::DW_OP_plus_uconst:
1815 case dwarf::DW_OP_minus:
1821 CanSplitValue =
false;
1823 case dwarf::DW_OP_deref:
1824 case dwarf::DW_OP_deref_size:
1825 case dwarf::DW_OP_deref_type:
1826 case dwarf::DW_OP_xderef:
1827 case dwarf::DW_OP_xderef_size:
1828 case dwarf::DW_OP_xderef_type:
1831 CanSplitValue =
true;
1833 case dwarf::DW_OP_stack_value:
1836 return std::nullopt;
1840 uint64_t FragmentOffsetInBits = Op.getArg(0);
1841 uint64_t FragmentSizeInBits = Op.getArg(1);
1842 (void)FragmentSizeInBits;
1843 assert((OffsetInBits + SizeInBits <= FragmentSizeInBits) &&
1844 "new fragment outside of original fragment");
1845 OffsetInBits += FragmentOffsetInBits;
1849 Op.appendToVector(Ops);
1853 assert(Expr &&
"Unknown DIExpression");
1860std::pair<DIExpression *, const ConstantInt *>
1868 bool Changed =
false;
1870 switch (Op.getOp()) {
1883 if (Op.getArg(1) == dwarf::DW_ATE_signed)
1886 assert(Op.getArg(1) == dwarf::DW_ATE_unsigned &&
"Unexpected operand");
1891 Op.appendToVector(Ops);
1903 Result = std::max(Result, ExprOp.getArg(0) + 1);
1905 "Expression is missing one or more location operands.");
1909std::optional<DIExpression::SignedOrUnsignedConstant>
1922 return std::nullopt;
1930 return std::nullopt;
1945 unsigned FromSize,
unsigned ToSize,
1953 bool ShouldCreate) {
1959 unsigned Line,
unsigned Attributes,
1961 :
DINode(
C, DIObjCPropertyKind,
Storage, dwarf::DW_TAG_APPLE_property, Ops),
1967 Metadata *
Type, StorageType Storage,
bool ShouldCreate) {
1981 StorageType Storage,
1982 bool ShouldCreate) {
1992 bool ShouldCreate) {
2001 Metadata *Elements, StorageType Storage,
2002 bool ShouldCreate) {
2010 StorageType Storage,
bool ShouldCreate) {
2017 assert((!New || isa<ValueAsMetadata>(New)) &&
2018 "DIArgList must be passed a ValueAsMetadata");
2028 if (&VM == OldVMPtr) {
2036 if (uniquify() !=
this)
2041void DIArgList::track() {
2046void DIArgList::untrack() {
2051void DIArgList::dropAllReferences() {
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
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
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 SmallSet class.
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
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.
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 Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
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)
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 * 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.
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 MDString * Name
unsigned Metadata Metadata Metadata * File
unsigned Metadata * Scope
Metadata MDString Metadata * File
DILexicalBlockBase(LLVMContext &C, unsigned ID, StorageType Storage, ArrayRef< Metadata * > Ops)
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 const DILocation * getMergedLocations(ArrayRef< const 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.
unsigned unsigned DILocalScope DILocation * InlinedAt
static const DILocation * getMergedLocation(const DILocation *LocA, const DILocation *LocB)
When two instructions are combined into a single instruction we also need to combine the original loc...
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
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)
This is the common base class for debug info intrinsics for variables.
DebugVariable(const DbgVariableIntrinsic *DII)
iterator find(const_arg_type_t< KeyT > Val)
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
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)
void storeDistinctInContext()
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...
Implements a dense probed hash-table based set with some number of buckets stored inline.
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)
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
LLVM Value Representation.
std::pair< iterator, bool > insert(const ValueT &V)
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)
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
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.
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Holds the characteristics of one fragment of a larger variable.
A single checksum, represented by a Kind and a Value (a string).