39#define DEBUG_TYPE "dwarfdebug"
45void DIEDwarfExpression::emitOp(uint8_t
Op,
const char* Comment) {
46 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1,
Op);
49void DIEDwarfExpression::emitSigned(int64_t
Value) {
50 CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata,
Value);
54 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata,
Value);
57void DIEDwarfExpression::emitData1(uint8_t
Value) {
58 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1,
Value);
61void DIEDwarfExpression::emitBaseTypeRef(
uint64_t Idx) {
62 CU.addBaseTypeRef(getActiveDIE(),
Idx);
65void DIEDwarfExpression::enableTemporaryBuffer() {
66 assert(!IsBuffering &&
"Already buffering?");
70void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering =
false; }
72unsigned DIEDwarfExpression::getTemporaryBufferSize() {
76void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.
takeValues(TmpDIE); }
80 return MachineReg ==
TRI.getFrameRegister(*AP.
MF);
86 :
DIEUnit(UnitTag), UniqueID(UniqueID), CUNode(Node), Asm(
A), DD(DW),
92 :
DwarfUnit(dwarf::DW_TAG_type_unit,
CU.getCUNode(),
A, DW, DWU, UniqueID),
93 CU(
CU), SplitLineTable(SplitLineTable) {}
102int64_t DwarfUnit::getDefaultLowerBound()
const {
108 case dwarf::DW_LANG_C:
109 case dwarf::DW_LANG_C89:
110 case dwarf::DW_LANG_C_plus_plus:
113 case dwarf::DW_LANG_Fortran77:
114 case dwarf::DW_LANG_Fortran90:
118 case dwarf::DW_LANG_C99:
119 case dwarf::DW_LANG_ObjC:
120 case dwarf::DW_LANG_ObjC_plus_plus:
125 case dwarf::DW_LANG_Fortran95:
131 case dwarf::DW_LANG_D:
132 case dwarf::DW_LANG_Java:
133 case dwarf::DW_LANG_Python:
134 case dwarf::DW_LANG_UPC:
139 case dwarf::DW_LANG_Ada83:
140 case dwarf::DW_LANG_Ada95:
141 case dwarf::DW_LANG_Cobol74:
142 case dwarf::DW_LANG_Cobol85:
143 case dwarf::DW_LANG_Modula2:
144 case dwarf::DW_LANG_Pascal83:
145 case dwarf::DW_LANG_PLI:
151 case dwarf::DW_LANG_BLISS:
152 case dwarf::DW_LANG_C11:
153 case dwarf::DW_LANG_C_plus_plus_03:
154 case dwarf::DW_LANG_C_plus_plus_11:
155 case dwarf::DW_LANG_C_plus_plus_14:
156 case dwarf::DW_LANG_Dylan:
157 case dwarf::DW_LANG_Go:
158 case dwarf::DW_LANG_Haskell:
159 case dwarf::DW_LANG_OCaml:
160 case dwarf::DW_LANG_OpenCL:
161 case dwarf::DW_LANG_RenderScript:
162 case dwarf::DW_LANG_Rust:
163 case dwarf::DW_LANG_Swift:
168 case dwarf::DW_LANG_Fortran03:
169 case dwarf::DW_LANG_Fortran08:
170 case dwarf::DW_LANG_Julia:
171 case dwarf::DW_LANG_Modula3:
191 return (isa<DIType>(
D) ||
192 (isa<DISubprogram>(
D) && !cast<DISubprogram>(
D)->isDefinition())) &&
225 assert(
Form != dwarf::DW_FORM_implicit_const &&
226 "DW_FORM_implicit_const is used only for signed integers");
236 std::optional<dwarf::Form>
Form, int64_t
Integer) {
259 isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
261 auto StringPoolEntry =
268 IxForm = dwarf::DW_FORM_strx1;
270 if (
Index > 0xffffff)
271 IxForm = dwarf::DW_FORM_strx4;
272 else if (
Index > 0xffff)
273 IxForm = dwarf::DW_FORM_strx3;
274 else if (
Index > 0xff)
275 IxForm = dwarf::DW_FORM_strx2;
294unsigned DwarfTypeUnit::getOrCreateSourceID(
const DIFile *File) {
297 if (!UsedLineTable) {
298 UsedLineTable =
true;
302 return SplitLineTable->
getFile(
308 bool UseAddrOffsetFormOrExpressions =
312 if (Label->isInSection() && UseAddrOffsetFormOrExpressions)
318 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addrx);
321 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
326 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_const4u);
328 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
343 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
362 addFlag(Die, dwarf::DW_AT_declaration);
364 addAttribute(Die, dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
371 const DIEUnit *EntryCU = Entry.getEntry().getUnit();
380 EntryCU ==
CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
414 addUInt(Die, dwarf::DW_AT_decl_file, std::nullopt, FileID);
415 addUInt(Die, dwarf::DW_AT_decl_line, std::nullopt, Line);
471 addUInt(Die, dwarf::DW_AT_const_value,
472 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
481 if (CIBitWidth <= 64) {
496 for (
int i = 0; i < NumBytes; i++) {
499 c = Ptr64[i / 8] >> (8 * (i & 7));
501 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
512 : dwarf::DW_AT_MIPS_linkage_name,
518 for (
const auto *Element : TParams) {
519 if (
auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
520 constructTemplateTypeParameterDIE(Buffer, TTP);
521 else if (
auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
522 constructTemplateValueParameterDIE(Buffer, TVP);
528 for (
const auto *Ty : ThrownTypes) {
536 addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
539 addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
542 addUInt(Die, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
549 if (
auto *
T = dyn_cast<DIType>(
Context))
551 if (
auto *NS = dyn_cast<DINamespace>(
Context))
553 if (
auto *SP = dyn_cast<DISubprogram>(
Context))
555 if (
auto *M = dyn_cast<DIModule>(
Context))
572 updateAcceleratorTables(
Context, Ty, TyDIE);
581 updateAcceleratorTables(
Context, Ty, TyDIE);
583 if (
auto *
BT = dyn_cast<DIBasicType>(Ty))
585 else if (
auto *ST = dyn_cast<DIStringType>(Ty))
587 else if (
auto *STy = dyn_cast<DISubroutineType>(Ty))
589 else if (
auto *CTy = dyn_cast<DICompositeType>(Ty)) {
591 (Ty->
getRawName() || CTy->getRawIdentifier())) {
593 if (
MDString *TypeId = CTy->getRawIdentifier())
596 finishNonUnitTypeDIE(TyDIE, CTy);
611 auto *Ty = cast<DIType>(TyNode);
623 auto *
Context = Ty->getScope();
634void DwarfUnit::updateAcceleratorTables(
const DIScope *Context,
637 bool IsImplementation =
false;
638 if (
auto *CT = dyn_cast<DICompositeType>(Ty)) {
641 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
647 if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
648 isa<DINamespace>(Context) || isa<DICommonBlock>(Context))
655 assert(Ty &&
"Trying to add a type that doesn't exist?");
669 while (!isa<DICompileUnit>(
Context)) {
683 if (
Name.empty() && isa<DINamespace>(Ctx))
684 Name =
"(anonymous namespace)";
701 if (BTy->
getTag() == dwarf::DW_TAG_unspecified_type)
704 if (BTy->
getTag() != dwarf::DW_TAG_string_type)
705 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
709 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt,
Size);
712 addUInt(Buffer, dwarf::DW_AT_endianity, std::nullopt, dwarf::DW_END_big);
714 addUInt(Buffer, dwarf::DW_AT_endianity, std::nullopt, dwarf::DW_END_little);
725 if (
auto *VarDIE =
getDIE(Var))
726 addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
733 DwarfExpr.setMemoryLocationKind();
734 DwarfExpr.addExpression(Expr);
735 addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
738 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt,
Size);
746 DwarfExpr.setMemoryLocationKind();
747 DwarfExpr.addExpression(Expr);
748 addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
753 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
765 const DIType *FromTy = DTy->getBaseType();
779 if (AlignInBytes > 0)
780 addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
785 if (
Size &&
Tag != dwarf::DW_TAG_pointer_type
786 &&
Tag != dwarf::DW_TAG_ptr_to_member_type
787 &&
Tag != dwarf::DW_TAG_reference_type
788 &&
Tag != dwarf::DW_TAG_rvalue_reference_type)
789 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt,
Size);
791 if (
Tag == dwarf::DW_TAG_ptr_to_member_type)
804 if (DTy->getDWARFAddressSpace())
805 addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
806 *DTy->getDWARFAddressSpace());
809 if (
Tag == dwarf::DW_TAG_template_alias)
812 if (
auto PtrAuthData = DTy->getPtrAuthData()) {
813 addUInt(Buffer, dwarf::DW_AT_LLVM_ptrauth_key, dwarf::DW_FORM_data1,
815 if (PtrAuthData->isAddressDiscriminated())
816 addFlag(Buffer, dwarf::DW_AT_LLVM_ptrauth_address_discriminated);
817 addUInt(Buffer, dwarf::DW_AT_LLVM_ptrauth_extra_discriminator,
818 dwarf::DW_FORM_data2, PtrAuthData->extraDiscriminator());
819 if (PtrAuthData->isaPointer())
820 addFlag(Buffer, dwarf::DW_AT_LLVM_ptrauth_isa_pointer);
821 if (PtrAuthData->authenticatesNullValues())
822 addFlag(Buffer, dwarf::DW_AT_LLVM_ptrauth_authenticates_null_values);
827 for (
unsigned i = 1,
N = Args.size(); i <
N; ++i) {
828 const DIType *Ty = Args[i];
830 assert(i ==
N-1 &&
"Unspecified parameter must be the last argument");
836 addFlag(Arg, dwarf::DW_AT_artificial);
843 auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
845 if (
auto RTy = Elements[0])
848 bool isPrototyped =
true;
849 if (Elements.size() == 2 && !Elements[1])
850 isPrototyped =
false;
857 addFlag(Buffer, dwarf::DW_AT_prototyped);
860 if (CTy->
getCC() && CTy->
getCC() != dwarf::DW_CC_normal)
861 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
865 addFlag(Buffer, dwarf::DW_AT_reference);
868 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
876 const MDNode *MD = cast<MDNode>(Annotation);
881 addString(AnnotationDie, dwarf::DW_AT_name,
Name->getString());
882 if (
const auto *
Data = dyn_cast<MDString>(
Value))
883 addString(AnnotationDie, dwarf::DW_AT_const_value,
Data->getString());
884 else if (
const auto *
Data = dyn_cast<ConstantAsMetadata>(
Value))
888 assert(
false &&
"Unsupported annotation value type");
900 case dwarf::DW_TAG_array_type:
901 constructArrayTypeDIE(Buffer, CTy);
903 case dwarf::DW_TAG_enumeration_type:
904 constructEnumTypeDIE(Buffer, CTy);
906 case dwarf::DW_TAG_variant_part:
907 case dwarf::DW_TAG_structure_type:
908 case dwarf::DW_TAG_union_type:
909 case dwarf::DW_TAG_class_type:
910 case dwarf::DW_TAG_namelist: {
913 if (
Tag == dwarf::DW_TAG_variant_part) {
920 DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
921 addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
926 if (
Tag == dwarf::DW_TAG_class_type ||
927 Tag == dwarf::DW_TAG_structure_type ||
Tag == dwarf::DW_TAG_union_type)
932 for (
const auto *Element : Elements) {
935 if (
auto *SP = dyn_cast<DISubprogram>(Element))
937 else if (
auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
938 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
940 addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
941 }
else if (DDTy->isStaticMember()) {
943 }
else if (
Tag == dwarf::DW_TAG_variant_part) {
948 dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
950 addUInt(Variant, dwarf::DW_AT_discr_value, std::nullopt,
953 addSInt(Variant, dwarf::DW_AT_discr_value, std::nullopt,
956 constructMemberDIE(Variant, DDTy);
958 constructMemberDIE(Buffer, DDTy);
960 }
else if (
auto *Property = dyn_cast<DIObjCProperty>(Element)) {
962 StringRef PropertyName = Property->getName();
963 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
964 if (Property->getType())
965 addType(ElemDie, Property->getType());
967 StringRef GetterName = Property->getGetterName();
968 if (!GetterName.
empty())
969 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
970 StringRef SetterName = Property->getSetterName();
971 if (!SetterName.
empty())
972 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
973 if (
unsigned PropertyAttributes = Property->getAttributes())
974 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, std::nullopt,
976 }
else if (
auto *Composite = dyn_cast<DICompositeType>(Element)) {
977 if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
981 }
else if (
Tag == dwarf::DW_TAG_namelist) {
982 auto *Var = dyn_cast<DINode>(Element);
983 auto *VarDIE =
getDIE(Var);
986 addDIEEntry(ItemDie, dwarf::DW_AT_namelist_item, *VarDIE);
992 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
995 addFlag(Buffer, dwarf::DW_AT_export_symbols);
1006 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1013 CC = dwarf::DW_CC_pass_by_value;
1015 CC = dwarf::DW_CC_pass_by_reference;
1017 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
1032 if (
Tag == dwarf::DW_TAG_enumeration_type ||
1033 Tag == dwarf::DW_TAG_class_type ||
Tag == dwarf::DW_TAG_structure_type ||
1034 Tag == dwarf::DW_TAG_union_type) {
1040 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt,
Size);
1043 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt, 0);
1047 addFlag(Buffer, dwarf::DW_AT_declaration);
1059 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1064 addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1069void DwarfUnit::constructTemplateTypeParameterDIE(
1078 if (TP->
isDefault() && isCompatibleWithVersion(5))
1079 addFlag(ParamDIE, dwarf::DW_AT_default_value);
1082void DwarfUnit::constructTemplateValueParameterDIE(
1088 if (VP->
getTag() == dwarf::DW_TAG_template_value_parameter)
1092 if (VP->
isDefault() && isCompatibleWithVersion(5))
1093 addFlag(ParamDIE, dwarf::DW_AT_default_value);
1095 if (
ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1097 else if (
GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1100 if (!GV->hasDLLImportStorageClass()) {
1107 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1108 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1110 }
else if (VP->
getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1111 assert(isa<MDString>(Val));
1112 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1113 cast<MDString>(Val)->getString());
1114 }
else if (VP->
getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1133 Name =
"(anonymous namespace)";
1137 addFlag(NDie, dwarf::DW_AT_export_symbols);
1150 if (!M->getName().empty()) {
1151 addString(MDie, dwarf::DW_AT_name, M->getName());
1154 if (!M->getConfigurationMacros().empty())
1155 addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1156 M->getConfigurationMacros());
1157 if (!M->getIncludePath().empty())
1158 addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
1159 if (!M->getAPINotesFile().empty())
1160 addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile());
1162 addUInt(MDie, dwarf::DW_AT_decl_file, std::nullopt,
1165 addUInt(MDie, dwarf::DW_AT_decl_line, std::nullopt, M->getLineNo());
1167 addFlag(MDie, dwarf::DW_AT_declaration);
1182 if (
auto *SPDecl = SP->getDeclaration()) {
1196 if (SP->isDefinition())
1205 DIE &SPDie,
bool Minimal) {
1206 DIE *DeclDie =
nullptr;
1208 if (
auto *SPDecl = SP->getDeclaration()) {
1211 DeclArgs = SPDecl->getType()->getTypeArray();
1212 DefinitionArgs = SP->getType()->getTypeArray();
1214 if (DeclArgs.
size() && DefinitionArgs.
size())
1215 if (DefinitionArgs[0] !=
nullptr && DeclArgs[0] != DefinitionArgs[0])
1216 addType(SPDie, DefinitionArgs[0]);
1218 DeclDie =
getDIE(SPDecl);
1219 assert(DeclDie &&
"This DIE should've already been constructed when the "
1220 "definition DIE was created in "
1221 "getOrCreateSubprogramDIE");
1224 DeclLinkageName = SPDecl->getLinkageName();
1227 if (DeclID != DefID)
1228 addUInt(SPDie, dwarf::DW_AT_decl_file, std::nullopt, DefID);
1230 if (SP->getLine() != SPDecl->getLine())
1231 addUInt(SPDie, dwarf::DW_AT_decl_line, std::nullopt, SP->getLine());
1242 "decl has a linkage name and it is different");
1243 if (DeclLinkageName.
empty() &&
1253 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1258 bool SkipSPAttributes) {
1261 bool SkipSPSourceLocation = SkipSPAttributes &&
1263 if (!SkipSPSourceLocation)
1273 if (!SkipSPSourceLocation)
1277 if (SkipSPAttributes)
1283 addFlag(SPDie, dwarf::DW_AT_prototyped);
1285 if (SP->isObjCDirect())
1286 addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct);
1291 Args = SPTy->getTypeArray();
1296 if (
CC &&
CC != dwarf::DW_CC_normal)
1297 addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
CC);
1302 if (
auto Ty = Args[0])
1305 unsigned VK = SP->getVirtuality();
1307 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1308 if (SP->getVirtualIndex() != -1u) {
1310 addUInt(*
Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1311 addUInt(*
Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1317 if (!SP->isDefinition()) {
1318 addFlag(SPDie, dwarf::DW_AT_declaration);
1327 if (SP->isArtificial())
1328 addFlag(SPDie, dwarf::DW_AT_artificial);
1330 if (!SP->isLocalToUnit())
1331 addFlag(SPDie, dwarf::DW_AT_external);
1334 if (SP->isOptimized())
1335 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1338 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag,
isa);
1341 if (SP->isLValueReference())
1342 addFlag(SPDie, dwarf::DW_AT_reference);
1344 if (SP->isRValueReference())
1345 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1347 if (SP->isNoReturn())
1348 addFlag(SPDie, dwarf::DW_AT_noreturn);
1352 if (SP->isExplicit())
1353 addFlag(SPDie, dwarf::DW_AT_explicit);
1355 if (SP->isMainSubprogram())
1356 addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1358 addFlag(SPDie, dwarf::DW_AT_pure);
1359 if (SP->isElemental())
1360 addFlag(SPDie, dwarf::DW_AT_elemental);
1361 if (SP->isRecursive())
1362 addFlag(SPDie, dwarf::DW_AT_recursive);
1364 if (!SP->getTargetFuncName().empty())
1365 addString(SPDie, dwarf::DW_AT_trampoline, SP->getTargetFuncName());
1368 addFlag(SPDie, dwarf::DW_AT_deleted);
1371void DwarfUnit::constructSubrangeDIE(
DIE &Buffer,
const DISubrange *SR,
1374 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1380 int64_t DefaultLowerBound = getDefaultLowerBound();
1383 DISubrange::BoundType Bound) ->
void {
1384 if (
auto *BV = dyn_cast_if_present<DIVariable *>(Bound)) {
1385 if (
auto *VarDIE =
getDIE(BV))
1387 }
else if (
auto *BE = dyn_cast_if_present<DIExpression *>(Bound)) {
1390 DwarfExpr.setMemoryLocationKind();
1391 DwarfExpr.addExpression(BE);
1392 addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
1393 }
else if (
auto *BI = dyn_cast_if_present<ConstantInt *>(Bound)) {
1394 if (Attr == dwarf::DW_AT_count) {
1395 if (BI->getSExtValue() != -1)
1396 addUInt(DW_Subrange, Attr, std::nullopt, BI->getSExtValue());
1397 }
else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1398 BI->getSExtValue() != DefaultLowerBound)
1399 addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
1403 AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->
getLowerBound());
1405 AddBoundTypeEntry(dwarf::DW_AT_count, SR->
getCount());
1407 AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->
getUpperBound());
1409 AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->
getStride());
1412void DwarfUnit::constructGenericSubrangeDIE(
DIE &Buffer,
1415 DIE &DwGenericSubrange =
1417 addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
1419 int64_t DefaultLowerBound = getDefaultLowerBound();
1423 if (
auto *BV = dyn_cast_if_present<DIVariable *>(Bound)) {
1424 if (
auto *VarDIE =
getDIE(BV))
1426 }
else if (
auto *BE = dyn_cast_if_present<DIExpression *>(Bound)) {
1427 if (BE->isConstant() &&
1429 *BE->isConstant()) {
1430 if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1431 static_cast<int64_t
>(BE->getElement(1)) != DefaultLowerBound)
1432 addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
1437 DwarfExpr.setMemoryLocationKind();
1438 DwarfExpr.addExpression(BE);
1439 addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
1444 AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->
getLowerBound());
1445 AddBoundTypeEntry(dwarf::DW_AT_count, GSR->
getCount());
1446 AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->
getUpperBound());
1447 AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->
getStride());
1450DIE *DwarfUnit::getIndexTyDie() {
1470 assert(CTy && CTy->
isVector() &&
"Composite type is not a vector");
1480 assert(Elements.size() == 1 &&
1481 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
1482 "Invalid vector element array, expected one element of type subrange");
1483 const auto Subrange = cast<DISubrange>(Elements[0]);
1484 const auto NumVecElements =
1485 Subrange->getCount()
1486 ? cast<ConstantInt *>(Subrange->getCount())->getSExtValue()
1491 assert(ActualSize >= (NumVecElements * ElementSize) &&
"Invalid vector size");
1492 return ActualSize != (NumVecElements * ElementSize);
1497 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1499 addUInt(Buffer, dwarf::DW_AT_byte_size, std::nullopt,
1504 if (
auto *VarDIE =
getDIE(Var))
1505 addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE);
1509 DwarfExpr.setMemoryLocationKind();
1510 DwarfExpr.addExpression(Expr);
1511 addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
1515 if (
auto *VarDIE =
getDIE(Var))
1516 addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
1520 DwarfExpr.setMemoryLocationKind();
1521 DwarfExpr.addExpression(Expr);
1522 addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
1526 if (
auto *VarDIE =
getDIE(Var))
1527 addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
1531 DwarfExpr.setMemoryLocationKind();
1532 DwarfExpr.addExpression(Expr);
1533 addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
1537 addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
1538 RankConst->getSExtValue());
1539 }
else if (
auto *RankExpr = CTy->
getRankExp()) {
1542 DwarfExpr.setMemoryLocationKind();
1543 DwarfExpr.addExpression(RankExpr);
1544 addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
1553 DIE *IdxTy = getIndexTyDie();
1557 for (
DINode *E : Elements) {
1559 if (
auto *Element = dyn_cast_or_null<DINode>(E)) {
1560 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1561 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1562 else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
1563 constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
1576 addFlag(Buffer, dwarf::DW_AT_enum_class);
1580 bool IndexEnumerators = !
Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
1581 isa<DINamespace>(Context) || isa<DICommonBlock>(Context);
1585 for (
const DINode *E : Elements) {
1586 auto *
Enum = dyn_cast_or_null<DIEnumerator>(E);
1592 if (IndexEnumerators)
1600 DIE &SPDie = *
P.first;
1607 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1619 if (
DIType *Resolved = DT->getBaseType())
1631 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1632 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1633 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1635 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1636 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1637 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1639 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1650 addUInt(MemberDie, dwarf::DW_AT_byte_size, std::nullopt, FieldSize / 8);
1651 addUInt(MemberDie, dwarf::DW_AT_bit_size, std::nullopt,
Size);
1654 (
uint64_t)std::numeric_limits<int64_t>::max());
1660 uint32_t AlignMask = ~(AlignInBits - 1);
1662 uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1664 OffsetInBytes = (Offset - StartBitOffset) / 8;
1667 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1668 uint64_t FieldOffset = (HiMark - FieldSize);
1669 Offset -= FieldOffset;
1673 Offset = FieldSize - (Offset +
Size);
1676 addSInt(MemberDie, dwarf::DW_AT_bit_offset, dwarf::DW_FORM_sdata,
1679 addUInt(MemberDie, dwarf::DW_AT_bit_offset, std::nullopt,
1681 OffsetInBytes = FieldOffset >> 3;
1683 addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, std::nullopt, Offset);
1689 addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1695 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1696 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1697 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1704 addUInt(MemberDie, dwarf::DW_AT_data_member_location,
1705 dwarf::DW_FORM_udata, OffsetInBytes);
1707 addUInt(MemberDie, dwarf::DW_AT_data_member_location, std::nullopt,
1715 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1716 dwarf::DW_VIRTUALITY_virtual);
1722 dwarf::DW_FORM_ref4,
DIEEntry(*PDie));
1725 addFlag(MemberDie, dwarf::DW_AT_artificial);
1738 "Static member should belong to a type.");
1741 return StaticMemberDIE;
1745 const DIType *Ty = DT->getBaseType();
1750 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1751 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1763 addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1766 return &StaticMemberDIE;
1773 isDwoUnit() ?
"debug_info_dwo" :
"debug_info",
"Length of Unit");
1814 : dwarf::DW_UT_type);
1816 Asm->
OutStreamer->emitIntValue(TypeSignature,
sizeof(TypeSignature));
1836bool DwarfTypeUnit::isDwoUnit()
const {
1852const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress()
const {
1869 "DW_AT_rnglists_base requires DWARF version 5 or later");
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
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 bool hasVectorBeenPadded(const DICompositeType *CTy)
Returns true if the vector's size differs from the sum of sizes of elements the user specified.
unsigned const TargetRegisterInfo * TRI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static enum BaseType getBaseType(const Value *Val)
Return the baseType for Val which states whether Val is exclusively derived from constant/null,...
static unsigned getSize(unsigned Kind)
APInt bitcastToAPInt() const
Class for arbitrary precision integers.
uint64_t getZExtValue() const
Get zero extended value.
unsigned getBitWidth() const
Return the number of bits in the APInt.
const uint64_t * getRawData() const
This function returns a pointer to the internal storage of the APInt.
int64_t getSExtValue() const
Get sign extended value.
unsigned getIndex(const MCSymbol *Sym, bool TLS=false)
Returns the index into the address pool with the given label/symbol.
void resetUsedFlag(bool HasBeenUsed=false)
Annotations lets you mark points and ranges inside source code, for tests:
This class is intended to be used as a driving class for all asm writers.
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
MCSymbol * getSymbol(const GlobalValue *GV) const
void emitDwarfSymbolReference(const MCSymbol *Label, bool ForceOffset=false) const
Emit a reference to a symbol for use in dwarf.
void emitDwarfLengthOrOffset(uint64_t Value) const
Emit 32- or 64-bit value depending on the DWARF format.
TargetMachine & TM
Target machine description.
const MCAsmInfo * MAI
Target Asm Printer information.
MachineFunction * MF
The current machine function.
void emitInt8(int Value) const
Emit a byte directive and value.
void emitDwarfUnitLength(uint64_t Length, const Twine &Comment) const
Emit a unit length field.
MCContext & OutContext
This is the context for the output file that we are streaming.
MCSymbol * createTempSymbol(const Twine &Name) const
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
virtual unsigned getISAEncoding()
Get the value for DW_AT_APPLE_isa. Zero if no isa encoding specified.
void emitInt16(int Value) const
Emit a short directive and value.
const DataLayout & getDataLayout() const
Return information about data layout.
dwarf::FormParams getDwarfFormParams() const
Returns information about the byte size of DW_FORM values.
bool doesDwarfUseRelocationsAcrossSections() const
ConstantFP - Floating Point Values [float, double].
const APFloat & getValueAPF() const
This is the shared class of boolean and integer constants.
const APInt & getValue() const
Return the constant as an APInt value reference.
Basic type, like 'int' or 'float'.
unsigned getEncoding() const
bool getDebugInfoForProfiling() const
bool isDebugDirectivesOnly() const
static std::optional< DebugNameTableKind > getNameTableKind(StringRef Str)
DIExpression * getRankExp() const
DIExpression * getAssociatedExp() const
DIVariable * getAllocated() const
DIExpression * getDataLocationExp() const
DIVariable * getAssociated() const
DIDerivedType * getDiscriminator() const
DIVariable * getDataLocation() const
unsigned getRuntimeLang() const
DINodeArray getElements() const
DITemplateParameterArray getTemplateParams() const
DIExpression * getAllocatedExp() const
DIType * getVTableHolder() const
DINodeArray getAnnotations() const
ConstantInt * getRankConst() const
DIType * getBaseType() const
DINodeArray getAnnotations() const
Get annotations associated with this derived type.
DITemplateParameterArray getTemplateParams() const
Get the template parameters from a template alias.
DIObjCProperty * getObjCProperty() const
Constant * getConstant() const
DIEBlock - Represents a block of values.
A simple label difference DIE.
DwarfExpression implementation for singular DW_AT_location.
DIEDwarfExpression(const AsmPrinter &AP, DwarfCompileUnit &CU, DIELoc &DIE)
A pointer to another debug information entry.
A container for inline string values.
static dwarf::Form BestForm(bool IsSigned, uint64_t Int)
Choose the best form for integer.
DIELoc - Represents an expression location.
unsigned computeSize(const dwarf::FormParams &FormParams) const
Calculate the size of the location expression.
dwarf::Form BestForm(unsigned DwarfVersion) const
BestForm - Choose the best form for data.
A container for string pool string values.
Represents a compile or type unit.
MCSection * getSection() const
Return the section that this DIEUnit will be emitted into.
void takeValues(DIEValueList &Other)
Take ownership of the nodes in Other, and append them to the back of the list.
A structured debug information entry.
DIE & addChild(DIE *Child)
Add a child to the DIE.
static DIE * get(BumpPtrAllocator &Alloc, dwarf::Tag Tag)
DIEUnit * getUnit() const
Climb up the parent chain to get the compile unit or type unit that this DIE belongs to.
dwarf::Tag getTag() const
BoundType getLowerBound() const
BoundType getCount() const
BoundType getUpperBound() const
BoundType getStride() const
Represents a module in the programming language, for example, a Clang module, or a Fortran module.
DIScope * getScope() const
StringRef getName() const
bool getExportSymbols() const
Tagged DWARF-like metadata node.
dwarf::Tag getTag() const
Base class for scope-like contexts.
StringRef getName() const
DIScope * getScope() const
String type, Fortran CHARACTER(n)
unsigned getEncoding() const
DIExpression * getStringLengthExp() const
DIVariable * getStringLength() const
DIExpression * getStringLocationExp() const
BoundType getUpperBound() const
BoundType getStride() const
BoundType getLowerBound() const
BoundType getCount() const
Type array for a subprogram.
StringRef getName() const
Metadata * getValue() const
bool isLittleEndian() const
bool isLValueReference() const
bool isObjcClassComplete() const
MDString * getRawName() const
bool isAppleBlockExtension() const
uint64_t getOffsetInBits() const
StringRef getName() const
bool isForwardDecl() const
bool isTypePassByValue() const
uint64_t getSizeInBits() const
uint32_t getAlignInBytes() const
bool isRValueReference() const
bool isArtificial() const
bool getExportSymbols() const
DIScope * getScope() const
bool isTypePassByReference() const
Base class for variables.
This class represents an Operation in the Expression.
bool isLittleEndian() const
Layout endianness...
static bool isUnsignedDIType(const DIType *Ty)
Return true if type encoding is unsigned.
static uint64_t getBaseTypeSize(const DIType *Ty)
If this type is derived from a base type then return base type size.
void addGlobalNameForTypeUnit(StringRef Name, const DIScope *Context)
Add a new global name present in a type unit to this compile unit.
unsigned getOrCreateSourceID(const DIFile *File) override
Look up the source ID for the given file.
void addGlobalTypeUnitType(const DIType *Ty, const DIScope *Context)
Add a new global type present in a type unit to this compile unit.
Collects and handles dwarf debug information.
std::optional< MD5::MD5Result > getMD5AsBytes(const DIFile *File) const
If the File has an MD5 checksum, return it as an MD5Result allocated in the MCContext.
bool useAddrOffsetForm() const
uint16_t getDwarfVersion() const
Returns the Dwarf Version.
void addAccelNamespace(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die)
bool useAllLinkageNames() const
Returns whether we should emit all DW_AT_[MIPS_]linkage_name.
dwarf::Form getDwarfSectionOffsetForm() const
Returns a suitable DWARF form to represent a section offset, i.e.
bool useAppleExtensionAttributes() const
bool useInlineStrings() const
Returns whether to use inline strings.
bool generateTypeUnits() const
Returns whether to generate DWARF v4 type units.
AddressPool & getAddressPool()
bool useSectionsAsReferences() const
Returns whether to use sections as labels rather than temp symbols.
bool shareAcrossDWOCUs() const
const MCSymbol * getSectionLabel(const MCSection *S)
bool useSplitDwarf() const
Returns whether or not to change the current debug info for the split dwarf proposal support.
bool useDWARF2Bitfields() const
Returns whether to use the DWARF2 format for bitfields instyead of the DWARF4 format.
bool useAddrOffsetExpressions() const
void addDwarfTypeUnitType(DwarfCompileUnit &CU, StringRef Identifier, DIE &Die, const DICompositeType *CTy)
Add a DIE to the set of types that we're going to pull into type units.
void addAccelType(const DwarfUnit &Unit, const DICompileUnit::DebugNameTableKind NameTableKind, StringRef Name, const DIE &Die, char Flags)
Base class containing the logic for constructing DWARF expressions independently of whether they are ...
MCSymbol * getStringOffsetsStartSym() const
MCSymbol * getRnglistsTableBaseSym() const
DwarfStringPool & getStringPool()
Returns the string pool.
DenseMap< const DILocalScope *, DIE * > & getAbstractScopeDIEs()
void insertDIE(const MDNode *TypeMD, DIE *Die)
DIE * getDIE(const MDNode *TypeMD)
unsigned getIndex() const
EntryRef getEntry(AsmPrinter &Asm, StringRef Str)
Get a reference to an entry in the string pool.
EntryRef getIndexedEntry(AsmPrinter &Asm, StringRef Str)
Same as getEntry, except that you can use EntryRef::getIndex to obtain a unique ID of this entry (e....
DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU, unsigned UniqueID, MCDwarfDwoLineTable *SplitLineTable=nullptr)
void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context) override
Add a new global type to the compile unit.
DwarfCompileUnit & getCU() override
void emitHeader(bool UseOffsets) override
Emit the header for this unit, not including the initial length field.
void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context) override
Add a new global name to the compile unit.
This dwarf writer support class manages information associated with a source file.
virtual DIE * getOrCreateTypeDIE(const MDNode *TyNode)
Find existing DIE or create new DIE for the given type.
void addThrownTypes(DIE &Die, DINodeArray ThrownTypes)
Add thrown types.
void addStringOffsetsStart()
Add the DW_AT_str_offsets_base attribute to the unit DIE.
void addAnnotation(DIE &Buffer, DINodeArray Annotations)
Add DW_TAG_LLVM_annotation.
std::vector< DIEBlock * > DIEBlocks
A list of all the DIEBlocks in use.
std::vector< DIELoc * > DIELocs
A list of all the DIELocs in use.
uint16_t getLanguage() const
void addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc)
Add block data.
void addTemplateParams(DIE &Buffer, DINodeArray TParams)
Add template parameters in buffer.
virtual DIE * getOrCreateContextDIE(const DIScope *Context)
Get context owner's DIE.
bool useSegmentedStringOffsetsTable() const
bool applySubprogramDefinitionAttributes(const DISubprogram *SP, DIE &SPDie, bool Minimal)
DIELoc * getDIELoc()
Returns a fresh newly allocated DIELoc.
void addAttribute(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, T &&Value)
void addOpAddress(DIELoc &Die, const MCSymbol *Sym)
Add a dwarf op address data and value using the form given and an op of either DW_FORM_addr or DW_FOR...
void addUInt(DIEValueList &Die, dwarf::Attribute Attribute, std::optional< dwarf::Form > Form, uint64_t Integer)
Add an unsigned integer attribute data and value.
void addString(DIE &Die, dwarf::Attribute Attribute, StringRef Str)
Add a string attribute data and value.
void addConstantValue(DIE &Die, const ConstantInt *CI, const DIType *Ty)
Add constant value entry in variable DIE.
DIE * getOrCreateNameSpace(const DINamespace *NS)
void insertDIE(const DINode *Desc, DIE *D)
Insert DIE into the map.
void addAccess(DIE &Die, DINode::DIFlags Flags)
Add the accessibility attribute.
void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
addSectionDelta - Add a label delta attribute data and value.
DIE * createTypeDIE(const DIScope *Context, DIE &ContextDIE, const DIType *Ty)
Creates type DIE with specific context.
DenseMap< DIE *, const DINode * > ContainingTypeMap
This map is used to keep track of subprogram DIEs that need DW_AT_containing_type attribute.
const DICompileUnit * CUNode
MDNode for the compile unit.
virtual unsigned getOrCreateSourceID(const DIFile *File)=0
Look up the source ID for the given file.
void addDIETypeSignature(DIE &Die, uint64_t Signature)
Add a type's DW_AT_signature and set the declaration flag.
virtual void addGlobalType(const DIType *Ty, const DIE &Die, const DIScope *Context)=0
Add a new global type to the compile unit.
virtual DwarfCompileUnit & getCU()=0
DIE * getDIE(const DINode *D) const
Returns the DIE map slot for the specified debug variable.
virtual unsigned getHeaderSize() const
Compute the size of a header for this unit, not including the initial length field.
void constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args)
Construct function argument DIEs.
MCSymbol * LabelBegin
The start of the unit within its section.
void addSInt(DIEValueList &Die, dwarf::Attribute Attribute, std::optional< dwarf::Form > Form, int64_t Integer)
Add an signed integer attribute data and value.
DwarfUnit(dwarf::Tag, const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU, unsigned UniqueID=0)
void addLabelDelta(DIEValueList &Die, dwarf::Attribute Attribute, const MCSymbol *Hi, const MCSymbol *Lo)
Add a label delta attribute data and value.
void addLinkageName(DIE &Die, StringRef LinkageName)
Add a linkage name, if it isn't empty.
std::string getParentContextString(const DIScope *Context) const
Get string containing language specific context for a global name.
void addSourceLine(DIE &Die, unsigned Line, const DIFile *File)
Add location information to specified debug information entry.
void emitCommonHeader(bool UseOffsets, dwarf::UnitType UT)
Emit the common part of the header for this unit.
BumpPtrAllocator DIEValueAllocator
DIE * IndexTyDie
An anonymous type for index type. Owned by DIEUnit.
void addRnglistsBase()
Add the DW_AT_rnglists_base attribute to the unit DIE.
DIE * getOrCreateModule(const DIModule *M)
DIE & createAndAddDIE(dwarf::Tag Tag, DIE &Parent, const DINode *N=nullptr)
Create a DIE with the given Tag, add the DIE to its parent, and call insertDIE if MD is not null.
void addSectionOffset(DIE &Die, dwarf::Attribute Attribute, uint64_t Integer)
Add an offset into a section attribute data and value.
DIE * getOrCreateStaticMemberDIE(const DIDerivedType *DT)
Create new static data member DIE.
void addLabel(DIEValueList &Die, dwarf::Attribute Attribute, dwarf::Form Form, const MCSymbol *Label)
Add a Dwarf label attribute data and value.
void addConstantFPValue(DIE &Die, const ConstantFP *CFP)
Add constant value entry in variable DIE.
void constructContainingTypeDIEs()
Construct DIEs for types that contain vtables.
DIE * getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal=false)
void addSectionLabel(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Label, const MCSymbol *Sec)
Add a Dwarf section label attribute data and value.
bool isShareableAcrossCUs(const DINode *D) const
Check whether the DIE for this MDNode can be shared across CUs.
void addPoolOpAddress(DIEValueList &Die, const MCSymbol *Label)
DenseMap< const MDNode *, DIE * > MDNodeToDieMap
Tracks the mapping of unit level debug information variables to debug information entries.
void constructTypeDIE(DIE &Buffer, const DICompositeType *CTy)
virtual void addGlobalName(StringRef Name, const DIE &Die, const DIScope *Context)=0
Add a new global name to the compile unit.
MCSymbol * EndLabel
Emitted at the end of the CU and used to compute the CU Length field.
void addFlag(DIE &Die, dwarf::Attribute Attribute)
Add a flag that is true to the DIE.
AsmPrinter * Asm
Target of Dwarf emission.
void addType(DIE &Entity, const DIType *Ty, dwarf::Attribute Attribute=dwarf::DW_AT_type)
Add a new type attribute to the specified entity.
void applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie, bool SkipSPAttributes=false)
void addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry)
Add a DIE attribute data and value.
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character '\1',...
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
uint16_t getDwarfVersion() const
unsigned getFile(StringRef Directory, StringRef FileName, std::optional< MD5::MD5Result > Checksum, uint16_t DwarfVersion, std::optional< StringRef > Source)
MCSection * getDwarfStrOffSection() const
MCSection * getDwarfRnglistsSection() const
MCSection * getDwarfAbbrevSection() const
MCSymbol * getBeginSymbol()
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
const MDOperand & getOperand(unsigned I) const
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Wrapper class representing virtual and physical registers.
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.
unsigned DebugStrictDwarf
When set to true, don't use DWARF extensions in later DWARF versions.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
LLVM Value Representation.
UnitType
Constants for unit types in DWARF v5.
bool isCPlusPlus(SourceLanguage S)
TypeKind getArrayIndexTypeEncoding(SourceLanguage S)
@ DW_FLAG_type_implementation
bool isC(SourceLanguage S)
This is an optimization pass for GlobalISel generic memory operations.
auto reverse(ContainerTy &&C)
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Description of the encoding of one expression Op.