40 #define DEBUG_TYPE "dwarfdebug"
46 void DIEDwarfExpression::emitOp(uint8_t
Op,
const char* Comment) {
47 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1,
Op);
50 void DIEDwarfExpression::emitSigned(int64_t
Value) {
51 CU.addSInt(getActiveDIE(), dwarf::DW_FORM_sdata,
Value);
55 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_udata,
Value);
58 void DIEDwarfExpression::emitData1(uint8_t
Value) {
59 CU.addUInt(getActiveDIE(), dwarf::DW_FORM_data1,
Value);
62 void DIEDwarfExpression::emitBaseTypeRef(
uint64_t Idx) {
63 CU.addBaseTypeRef(getActiveDIE(), Idx);
66 void DIEDwarfExpression::enableTemporaryBuffer() {
67 assert(!IsBuffering &&
"Already buffering?");
71 void DIEDwarfExpression::disableTemporaryBuffer() { IsBuffering =
false; }
73 unsigned DIEDwarfExpression::getTemporaryBufferSize() {
77 void DIEDwarfExpression::commitTemporaryBuffer() { OutDIE.
takeValues(TmpDIE); }
86 :
DIEUnit(UnitTag), CUNode(Node),
Asm(A), DD(DW), DU(DWU) {}
91 :
DwarfUnit(dwarf::DW_TAG_type_unit,
CU.getCUNode(), A, DW, DWU),
CU(
CU),
92 SplitLineTable(SplitLineTable) {
102 int64_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");
259 isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
261 auto StringPoolEntry =
268 IxForm = dwarf::DW_FORM_strx1;
269 unsigned Index = StringPoolEntry.getIndex();
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;
294 unsigned 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);
319 addUInt(Die, dwarf::DW_FORM_addrx, Index);
321 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
322 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, 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);
344 addLabel(Die, dwarf::DW_FORM_addr, Sym);
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,
None, FileID);
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));
502 addUInt(*Block, dwarf::DW_FORM_data1,
c);
505 addBlock(Die, dwarf::DW_AT_const_value, Block);
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();
637 bool IsImplementation =
false;
638 if (
auto *CT = dyn_cast<DICompositeType>(Ty)) {
641 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
654 assert(Ty &&
"Trying to add a type that doesn't exist?");
668 while (!isa<DICompileUnit>(
Context)) {
682 if (
Name.empty() && isa<DINamespace>(Ctx))
683 Name =
"(anonymous namespace)";
700 if (BTy->
getTag() == dwarf::DW_TAG_unspecified_type)
703 if (BTy->
getTag() != dwarf::DW_TAG_string_type)
704 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
708 addUInt(Buffer, dwarf::DW_AT_byte_size,
None, Size);
711 addUInt(Buffer, dwarf::DW_AT_endianity,
None, dwarf::DW_END_big);
713 addUInt(Buffer, dwarf::DW_AT_endianity,
None, dwarf::DW_END_little);
724 if (
auto *VarDIE =
getDIE(Var))
725 addDIEEntry(Buffer, dwarf::DW_AT_string_length, *VarDIE);
732 DwarfExpr.setMemoryLocationKind();
733 DwarfExpr.addExpression(Expr);
734 addBlock(Buffer, dwarf::DW_AT_string_length, DwarfExpr.finalize());
737 addUInt(Buffer, dwarf::DW_AT_byte_size,
None, Size);
745 DwarfExpr.setMemoryLocationKind();
746 DwarfExpr.addExpression(Expr);
747 addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
752 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
764 const DIType *FromTy = DTy->getBaseType();
778 if (AlignInBytes > 0)
779 addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
784 if (Size && Tag != dwarf::DW_TAG_pointer_type
785 && Tag != dwarf::DW_TAG_ptr_to_member_type
786 && Tag != dwarf::DW_TAG_reference_type
787 && Tag != dwarf::DW_TAG_rvalue_reference_type)
788 addUInt(Buffer, dwarf::DW_AT_byte_size,
None, Size);
790 if (Tag == dwarf::DW_TAG_ptr_to_member_type)
800 if (DTy->getDWARFAddressSpace())
801 addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
802 DTy->getDWARFAddressSpace().getValue());
806 for (
unsigned i = 1,
N =
Args.size();
i <
N; ++
i) {
809 assert(
i ==
N-1 &&
"Unspecified parameter must be the last argument");
822 auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
824 if (
auto RTy = Elements[0])
827 bool isPrototyped =
true;
828 if (Elements.size() == 2 && !Elements[1])
829 isPrototyped =
false;
839 addFlag(Buffer, dwarf::DW_AT_prototyped);
842 if (CTy->
getCC() && CTy->
getCC() != dwarf::DW_CC_normal)
843 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
847 addFlag(Buffer, dwarf::DW_AT_reference);
850 addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
858 const MDNode *MD = cast<MDNode>(Annotation);
863 addString(AnnotationDie, dwarf::DW_AT_name,
Name->getString());
864 if (
const auto *
Data = dyn_cast<MDString>(
Value))
865 addString(AnnotationDie, dwarf::DW_AT_const_value,
Data->getString());
866 else if (
const auto *
Data = dyn_cast<ConstantAsMetadata>(
Value))
870 assert(
false &&
"Unsupported annotation value type");
882 case dwarf::DW_TAG_array_type:
883 constructArrayTypeDIE(Buffer, CTy);
885 case dwarf::DW_TAG_enumeration_type:
886 constructEnumTypeDIE(Buffer, CTy);
888 case dwarf::DW_TAG_variant_part:
889 case dwarf::DW_TAG_structure_type:
890 case dwarf::DW_TAG_union_type:
891 case dwarf::DW_TAG_class_type:
892 case dwarf::DW_TAG_namelist: {
895 if (Tag == dwarf::DW_TAG_variant_part) {
902 DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
903 addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
908 if (Tag == dwarf::DW_TAG_class_type ||
909 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
914 for (
const auto *Element : Elements) {
917 if (
auto *SP = dyn_cast<DISubprogram>(Element))
919 else if (
auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
920 if (DDTy->getTag() == dwarf::DW_TAG_friend) {
922 addType(ElemDie, DDTy->getBaseType(), dwarf::DW_AT_friend);
923 }
else if (DDTy->isStaticMember()) {
925 }
else if (Tag == dwarf::DW_TAG_variant_part) {
930 dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
932 addUInt(Variant, dwarf::DW_AT_discr_value,
None, CI->getZExtValue());
934 addSInt(Variant, dwarf::DW_AT_discr_value,
None, CI->getSExtValue());
936 constructMemberDIE(Variant, DDTy);
938 constructMemberDIE(Buffer, DDTy);
940 }
else if (
auto *Property = dyn_cast<DIObjCProperty>(Element)) {
942 StringRef PropertyName = Property->getName();
943 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
944 if (Property->getType())
945 addType(ElemDie, Property->getType());
947 StringRef GetterName = Property->getGetterName();
948 if (!GetterName.
empty())
949 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
950 StringRef SetterName = Property->getSetterName();
951 if (!SetterName.
empty())
952 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
953 if (
unsigned PropertyAttributes = Property->getAttributes())
954 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute,
None,
956 }
else if (
auto *Composite = dyn_cast<DICompositeType>(Element)) {
957 if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
961 }
else if (Tag == dwarf::DW_TAG_namelist) {
962 auto *Var = dyn_cast<DINode>(Element);
963 auto *VarDIE =
getDIE(Var);
966 addDIEEntry(ItemDie, dwarf::DW_AT_namelist_item, *VarDIE);
972 addFlag(Buffer, dwarf::DW_AT_APPLE_block);
975 addFlag(Buffer, dwarf::DW_AT_export_symbols);
986 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
993 CC = dwarf::DW_CC_pass_by_value;
995 CC = dwarf::DW_CC_pass_by_reference;
997 addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
1012 if (Tag == dwarf::DW_TAG_enumeration_type ||
1013 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
1014 Tag == dwarf::DW_TAG_union_type) {
1019 (!CTy->
isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
1020 addUInt(Buffer, dwarf::DW_AT_byte_size,
None, Size);
1027 addFlag(Buffer, dwarf::DW_AT_declaration);
1039 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1044 addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1049 void DwarfUnit::constructTemplateTypeParameterDIE(
1059 addFlag(ParamDIE, dwarf::DW_AT_default_value);
1062 void DwarfUnit::constructTemplateValueParameterDIE(
1068 if (VP->
getTag() == dwarf::DW_TAG_template_value_parameter)
1073 addFlag(ParamDIE, dwarf::DW_AT_default_value);
1075 if (
ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1077 else if (
GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1080 if (!GV->hasDLLImportStorageClass()) {
1087 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1088 addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1090 }
else if (VP->
getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1091 assert(isa<MDString>(Val));
1092 addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1093 cast<MDString>(Val)->getString());
1094 }
else if (VP->
getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1113 Name =
"(anonymous namespace)";
1117 addFlag(NDie, dwarf::DW_AT_export_symbols);
1130 if (!
M->getName().empty()) {
1131 addString(MDie, dwarf::DW_AT_name,
M->getName());
1134 if (!
M->getConfigurationMacros().empty())
1135 addString(MDie, dwarf::DW_AT_LLVM_config_macros,
1136 M->getConfigurationMacros());
1137 if (!
M->getIncludePath().empty())
1138 addString(MDie, dwarf::DW_AT_LLVM_include_path,
M->getIncludePath());
1139 if (!
M->getAPINotesFile().empty())
1140 addString(MDie, dwarf::DW_AT_LLVM_apinotes,
M->getAPINotesFile());
1145 addUInt(MDie, dwarf::DW_AT_decl_line,
None,
M->getLineNo());
1147 addFlag(MDie, dwarf::DW_AT_declaration);
1162 if (
auto *SPDecl = SP->getDeclaration()) {
1176 if (SP->isDefinition())
1185 DIE &SPDie,
bool Minimal) {
1186 DIE *DeclDie =
nullptr;
1188 if (
auto *SPDecl = SP->getDeclaration()) {
1191 DeclArgs = SPDecl->getType()->getTypeArray();
1192 DefinitionArgs = SP->getType()->getTypeArray();
1194 if (DeclArgs.
size() && DefinitionArgs.
size())
1195 if (DefinitionArgs[0] !=
nullptr && DeclArgs[0] != DefinitionArgs[0])
1196 addType(SPDie, DefinitionArgs[0]);
1198 DeclDie =
getDIE(SPDecl);
1199 assert(DeclDie &&
"This DIE should've already been constructed when the "
1200 "definition DIE was created in "
1201 "getOrCreateSubprogramDIE");
1204 DeclLinkageName = SPDecl->getLinkageName();
1207 if (DeclID != DefID)
1208 addUInt(SPDie, dwarf::DW_AT_decl_file,
None, DefID);
1210 if (SP->getLine() != SPDecl->getLine())
1211 addUInt(SPDie, dwarf::DW_AT_decl_line,
None, SP->getLine());
1222 "decl has a linkage name and it is different");
1223 if (DeclLinkageName.
empty() &&
1233 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1238 bool SkipSPAttributes) {
1241 bool SkipSPSourceLocation = SkipSPAttributes &&
1243 if (!SkipSPSourceLocation)
1253 if (!SkipSPSourceLocation)
1257 if (SkipSPAttributes)
1263 if (SP->isPrototyped() &&
1266 addFlag(SPDie, dwarf::DW_AT_prototyped);
1268 if (SP->isObjCDirect())
1269 addFlag(SPDie, dwarf::DW_AT_APPLE_objc_direct);
1274 Args = SPTy->getTypeArray();
1279 if (CC && CC != dwarf::DW_CC_normal)
1280 addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
1285 if (
auto Ty =
Args[0])
1288 unsigned VK = SP->getVirtuality();
1290 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1291 if (SP->getVirtualIndex() != -1u) {
1293 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1294 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1295 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1300 if (!SP->isDefinition()) {
1301 addFlag(SPDie, dwarf::DW_AT_declaration);
1310 if (SP->isArtificial())
1311 addFlag(SPDie, dwarf::DW_AT_artificial);
1313 if (!SP->isLocalToUnit())
1314 addFlag(SPDie, dwarf::DW_AT_external);
1317 if (SP->isOptimized())
1318 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1321 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag,
isa);
1324 if (SP->isLValueReference())
1325 addFlag(SPDie, dwarf::DW_AT_reference);
1327 if (SP->isRValueReference())
1328 addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1330 if (SP->isNoReturn())
1331 addFlag(SPDie, dwarf::DW_AT_noreturn);
1335 if (SP->isExplicit())
1336 addFlag(SPDie, dwarf::DW_AT_explicit);
1338 if (SP->isMainSubprogram())
1339 addFlag(SPDie, dwarf::DW_AT_main_subprogram);
1341 addFlag(SPDie, dwarf::DW_AT_pure);
1342 if (SP->isElemental())
1343 addFlag(SPDie, dwarf::DW_AT_elemental);
1344 if (SP->isRecursive())
1345 addFlag(SPDie, dwarf::DW_AT_recursive);
1347 if (!SP->getTargetFuncName().empty())
1348 addString(SPDie, dwarf::DW_AT_trampoline, SP->getTargetFuncName());
1351 addFlag(SPDie, dwarf::DW_AT_deleted);
1354 void DwarfUnit::constructSubrangeDIE(
DIE &Buffer,
const DISubrange *SR,
1357 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1363 int64_t DefaultLowerBound = getDefaultLowerBound();
1366 DISubrange::BoundType Bound) ->
void {
1367 if (
auto *BV = Bound.dyn_cast<
DIVariable *>()) {
1368 if (
auto *VarDIE =
getDIE(BV))
1370 }
else if (
auto *BE = Bound.dyn_cast<
DIExpression *>()) {
1373 DwarfExpr.setMemoryLocationKind();
1374 DwarfExpr.addExpression(BE);
1375 addBlock(DW_Subrange, Attr, DwarfExpr.finalize());
1376 }
else if (
auto *BI = Bound.dyn_cast<
ConstantInt *>()) {
1377 if (Attr == dwarf::DW_AT_count) {
1378 if (BI->getSExtValue() != -1)
1379 addUInt(DW_Subrange, Attr,
None, BI->getSExtValue());
1380 }
else if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1381 BI->getSExtValue() != DefaultLowerBound)
1382 addSInt(DW_Subrange, Attr, dwarf::DW_FORM_sdata, BI->getSExtValue());
1386 AddBoundTypeEntry(dwarf::DW_AT_lower_bound, SR->
getLowerBound());
1388 AddBoundTypeEntry(dwarf::DW_AT_count, SR->
getCount());
1390 AddBoundTypeEntry(dwarf::DW_AT_upper_bound, SR->
getUpperBound());
1392 AddBoundTypeEntry(dwarf::DW_AT_byte_stride, SR->
getStride());
1395 void DwarfUnit::constructGenericSubrangeDIE(
DIE &Buffer,
1398 DIE &DwGenericSubrange =
1400 addDIEEntry(DwGenericSubrange, dwarf::DW_AT_type, *IndexTy);
1402 int64_t DefaultLowerBound = getDefaultLowerBound();
1406 if (
auto *BV = Bound.dyn_cast<
DIVariable *>()) {
1407 if (
auto *VarDIE =
getDIE(BV))
1409 }
else if (
auto *BE = Bound.dyn_cast<
DIExpression *>()) {
1410 if (BE->isConstant() &&
1411 DIExpression::SignedOrUnsignedConstant::SignedConstant ==
1412 *BE->isConstant()) {
1413 if (Attr != dwarf::DW_AT_lower_bound || DefaultLowerBound == -1 ||
1414 static_cast<int64_t
>(BE->getElement(1)) != DefaultLowerBound)
1415 addSInt(DwGenericSubrange, Attr, dwarf::DW_FORM_sdata,
1420 DwarfExpr.setMemoryLocationKind();
1421 DwarfExpr.addExpression(BE);
1422 addBlock(DwGenericSubrange, Attr, DwarfExpr.finalize());
1427 AddBoundTypeEntry(dwarf::DW_AT_lower_bound, GSR->
getLowerBound());
1428 AddBoundTypeEntry(dwarf::DW_AT_count, GSR->
getCount());
1429 AddBoundTypeEntry(dwarf::DW_AT_upper_bound, GSR->
getUpperBound());
1430 AddBoundTypeEntry(dwarf::DW_AT_byte_stride, GSR->
getStride());
1433 DIE *DwarfUnit::getIndexTyDie() {
1452 assert(CTy && CTy->
isVector() &&
"Composite type is not a vector");
1457 assert(BaseTy &&
"Unknown vector element type.");
1462 assert(Elements.size() == 1 &&
1463 Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
1464 "Invalid vector element array, expected one element of type subrange");
1465 const auto Subrange = cast<DISubrange>(Elements[0]);
1466 const auto NumVecElements =
1467 Subrange->getCount()
1468 ? Subrange->getCount().get<
ConstantInt *>()->getSExtValue()
1473 assert(ActualSize >= (NumVecElements * ElementSize) &&
"Invalid vector size");
1474 return ActualSize != (NumVecElements * ElementSize);
1479 addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1486 if (
auto *VarDIE =
getDIE(Var))
1487 addDIEEntry(Buffer, dwarf::DW_AT_data_location, *VarDIE);
1491 DwarfExpr.setMemoryLocationKind();
1492 DwarfExpr.addExpression(Expr);
1493 addBlock(Buffer, dwarf::DW_AT_data_location, DwarfExpr.finalize());
1497 if (
auto *VarDIE =
getDIE(Var))
1498 addDIEEntry(Buffer, dwarf::DW_AT_associated, *VarDIE);
1502 DwarfExpr.setMemoryLocationKind();
1503 DwarfExpr.addExpression(Expr);
1504 addBlock(Buffer, dwarf::DW_AT_associated, DwarfExpr.finalize());
1508 if (
auto *VarDIE =
getDIE(Var))
1509 addDIEEntry(Buffer, dwarf::DW_AT_allocated, *VarDIE);
1513 DwarfExpr.setMemoryLocationKind();
1514 DwarfExpr.addExpression(Expr);
1515 addBlock(Buffer, dwarf::DW_AT_allocated, DwarfExpr.finalize());
1519 addSInt(Buffer, dwarf::DW_AT_rank, dwarf::DW_FORM_sdata,
1520 RankConst->getSExtValue());
1521 }
else if (
auto *RankExpr = CTy->
getRankExp()) {
1524 DwarfExpr.setMemoryLocationKind();
1525 DwarfExpr.addExpression(RankExpr);
1526 addBlock(Buffer, dwarf::DW_AT_rank, DwarfExpr.finalize());
1535 DIE *IdxTy = getIndexTyDie();
1541 if (
auto *Element = dyn_cast_or_null<DINode>(
E)) {
1542 if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1543 constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1544 else if (Element->getTag() == dwarf::DW_TAG_generic_subrange)
1545 constructGenericSubrangeDIE(Buffer, cast<DIGenericSubrange>(Element),
1558 addFlag(Buffer, dwarf::DW_AT_enum_class);
1567 for (
const DINode *
E : Elements) {
1568 auto *
Enum = dyn_cast_or_null<DIEnumerator>(
E);
1574 if (IndexEnumerators)
1582 DIE &SPDie = *
P.first;
1589 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1601 if (
DIType *Resolved = DT->getBaseType())
1613 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1614 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1615 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1617 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1618 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1619 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1621 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1628 bool IsBitfield = FieldSize && Size != FieldSize;
1632 addUInt(MemberDie, dwarf::DW_AT_byte_size,
None, FieldSize/8);
1633 addUInt(MemberDie, dwarf::DW_AT_bit_size,
None, Size);
1640 uint32_t AlignMask = ~(AlignInBits - 1);
1642 uint64_t StartBitOffset = Offset - (Offset & AlignMask);
1644 OffsetInBytes = (Offset - StartBitOffset) / 8;
1647 uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1648 uint64_t FieldOffset = (HiMark - FieldSize);
1649 Offset -= FieldOffset;
1653 Offset = FieldSize - (Offset + Size);
1655 addUInt(MemberDie, dwarf::DW_AT_bit_offset,
None, Offset);
1656 OffsetInBytes = FieldOffset >> 3;
1658 addUInt(MemberDie, dwarf::DW_AT_data_bit_offset,
None, Offset);
1664 addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1670 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1671 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1672 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1679 addUInt(MemberDie, dwarf::DW_AT_data_member_location,
1680 dwarf::DW_FORM_udata, OffsetInBytes);
1682 addUInt(MemberDie, dwarf::DW_AT_data_member_location,
None,
1690 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1691 dwarf::DW_VIRTUALITY_virtual);
1697 dwarf::DW_FORM_ref4,
DIEEntry(*PDie));
1700 addFlag(MemberDie, dwarf::DW_AT_artificial);
1713 "Static member should belong to a type.");
1716 return StaticMemberDIE;
1720 const DIType *Ty = DT->getBaseType();
1725 addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1726 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1738 addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
1741 return &StaticMemberDIE;
1748 isDwoUnit() ?
"debug_info_dwo" :
"debug_info",
"Length of Unit");
1785 : dwarf::DW_UT_type);
1787 Asm->
OutStreamer->emitIntValue(TypeSignature,
sizeof(TypeSignature));
1807 bool DwarfTypeUnit::isDwoUnit()
const {
1823 const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress()
const {
1840 "DW_AT_rnglists_base requires DWARF version 5 or later");