1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file contains support for constructing a dwarf compile unit. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "DwarfUnit.h" 15 #include "DwarfAccelTable.h" 16 #include "DwarfDebug.h" 17 #include "llvm/ADT/APFloat.h" 18 #include "llvm/IR/Constants.h" 19 #include "llvm/IR/DIBuilder.h" 20 #include "llvm/IR/DataLayout.h" 21 #include "llvm/IR/GlobalVariable.h" 22 #include "llvm/IR/Instructions.h" 23 #include "llvm/IR/Mangler.h" 24 #include "llvm/MC/MCAsmInfo.h" 25 #include "llvm/MC/MCContext.h" 26 #include "llvm/MC/MCSection.h" 27 #include "llvm/MC/MCStreamer.h" 28 #include "llvm/Support/CommandLine.h" 29 #include "llvm/Target/TargetFrameLowering.h" 30 #include "llvm/Target/TargetLoweringObjectFile.h" 31 #include "llvm/Target/TargetMachine.h" 32 #include "llvm/Target/TargetRegisterInfo.h" 33 34 using namespace llvm; 35 36 #define DEBUG_TYPE "dwarfdebug" 37 38 static cl::opt<bool> 39 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, 40 cl::desc("Generate DWARF4 type units."), 41 cl::init(false)); 42 43 /// Unit - Unit constructor. 44 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node, 45 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU) 46 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A), 47 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr), 48 Skeleton(nullptr) { 49 assert(UnitTag == dwarf::DW_TAG_compile_unit || 50 UnitTag == dwarf::DW_TAG_type_unit); 51 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1); 52 } 53 54 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, DICompileUnit Node, 55 AsmPrinter *A, DwarfDebug *DW, 56 DwarfFile *DWU) 57 : DwarfUnit(UID, dwarf::DW_TAG_compile_unit, Node, A, DW, DWU) { 58 insertDIE(Node, &getUnitDie()); 59 } 60 61 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A, 62 DwarfDebug *DW, DwarfFile *DWU, 63 MCDwarfDwoLineTable *SplitLineTable) 64 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), 65 CU(CU), SplitLineTable(SplitLineTable) { 66 if (SplitLineTable) 67 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0); 68 } 69 70 /// ~Unit - Destructor for compile unit. 71 DwarfUnit::~DwarfUnit() { 72 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 73 DIEBlocks[j]->~DIEBlock(); 74 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j) 75 DIELocs[j]->~DIELoc(); 76 } 77 78 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 79 /// information entry. 80 DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) { 81 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry); 82 return Value; 83 } 84 85 /// getDefaultLowerBound - Return the default lower bound for an array. If the 86 /// DWARF version doesn't handle the language, return -1. 87 int64_t DwarfUnit::getDefaultLowerBound() const { 88 switch (getLanguage()) { 89 default: 90 break; 91 92 case dwarf::DW_LANG_C89: 93 case dwarf::DW_LANG_C99: 94 case dwarf::DW_LANG_C: 95 case dwarf::DW_LANG_C_plus_plus: 96 case dwarf::DW_LANG_ObjC: 97 case dwarf::DW_LANG_ObjC_plus_plus: 98 return 0; 99 100 case dwarf::DW_LANG_Fortran77: 101 case dwarf::DW_LANG_Fortran90: 102 case dwarf::DW_LANG_Fortran95: 103 return 1; 104 105 // The languages below have valid values only if the DWARF version >= 4. 106 case dwarf::DW_LANG_Java: 107 case dwarf::DW_LANG_Python: 108 case dwarf::DW_LANG_UPC: 109 case dwarf::DW_LANG_D: 110 if (dwarf::DWARF_VERSION >= 4) 111 return 0; 112 break; 113 114 case dwarf::DW_LANG_Ada83: 115 case dwarf::DW_LANG_Ada95: 116 case dwarf::DW_LANG_Cobol74: 117 case dwarf::DW_LANG_Cobol85: 118 case dwarf::DW_LANG_Modula2: 119 case dwarf::DW_LANG_Pascal83: 120 case dwarf::DW_LANG_PLI: 121 if (dwarf::DWARF_VERSION >= 4) 122 return 1; 123 break; 124 } 125 126 return -1; 127 } 128 129 /// Check whether the DIE for this MDNode can be shared across CUs. 130 static bool isShareableAcrossCUs(DIDescriptor D) { 131 // When the MDNode can be part of the type system, the DIE can be shared 132 // across CUs. 133 // Combining type units and cross-CU DIE sharing is lower value (since 134 // cross-CU DIE sharing is used in LTO and removes type redundancy at that 135 // level already) but may be implementable for some value in projects 136 // building multiple independent libraries with LTO and then linking those 137 // together. 138 return (D.isType() || 139 (D.isSubprogram() && !DISubprogram(D).isDefinition())) && 140 !GenerateDwarfTypeUnits; 141 } 142 143 /// getDIE - Returns the debug information entry map slot for the 144 /// specified debug variable. We delegate the request to DwarfDebug 145 /// when the DIE for this MDNode can be shared across CUs. The mappings 146 /// will be kept in DwarfDebug for shareable DIEs. 147 DIE *DwarfUnit::getDIE(DIDescriptor D) const { 148 if (isShareableAcrossCUs(D)) 149 return DD->getDIE(D); 150 return MDNodeToDieMap.lookup(D); 151 } 152 153 /// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug 154 /// when the DIE for this MDNode can be shared across CUs. The mappings 155 /// will be kept in DwarfDebug for shareable DIEs. 156 void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) { 157 if (isShareableAcrossCUs(Desc)) { 158 DD->insertDIE(Desc, D); 159 return; 160 } 161 MDNodeToDieMap.insert(std::make_pair(Desc, D)); 162 } 163 164 /// addFlag - Add a flag that is true. 165 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) { 166 if (DD->getDwarfVersion() >= 4) 167 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne); 168 else 169 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne); 170 } 171 172 /// addUInt - Add an unsigned integer attribute data and value. 173 /// 174 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute, 175 Optional<dwarf::Form> Form, uint64_t Integer) { 176 if (!Form) 177 Form = DIEInteger::BestForm(false, Integer); 178 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator) 179 DIEInteger(Integer); 180 Die.addValue(Attribute, *Form, Value); 181 } 182 183 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) { 184 addUInt(Block, (dwarf::Attribute)0, Form, Integer); 185 } 186 187 /// addSInt - Add an signed integer attribute data and value. 188 /// 189 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute, 190 Optional<dwarf::Form> Form, int64_t Integer) { 191 if (!Form) 192 Form = DIEInteger::BestForm(true, Integer); 193 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 194 Die.addValue(Attribute, *Form, Value); 195 } 196 197 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form, 198 int64_t Integer) { 199 addSInt(Die, (dwarf::Attribute)0, Form, Integer); 200 } 201 202 /// addString - Add a string attribute data and value. We always emit a 203 /// reference to the string pool instead of immediate strings so that DIEs have 204 /// more predictable sizes. In the case of split dwarf we emit an index 205 /// into another table which gets us the static offset into the string 206 /// table. 207 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute, 208 StringRef String) { 209 210 if (!DD->useSplitDwarf()) 211 return addLocalString(Die, Attribute, String); 212 213 unsigned idx = DU->getStringPool().getIndex(*Asm, String); 214 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx); 215 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String); 216 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str); 217 } 218 219 /// addLocalString - Add a string attribute data and value. This is guaranteed 220 /// to be in the local string pool instead of indirected. 221 void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute, 222 StringRef String) { 223 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String); 224 DIEValue *Value; 225 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 226 Value = new (DIEValueAllocator) DIELabel(Symb); 227 else { 228 MCSymbol *StringPool = DU->getStringPool().getSectionSymbol(); 229 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool); 230 } 231 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String); 232 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str); 233 } 234 235 /// addExpr - Add a Dwarf expression attribute data and value. 236 /// 237 void DwarfUnit::addExpr(DIELoc &Die, dwarf::Form Form, const MCExpr *Expr) { 238 DIEValue *Value = new (DIEValueAllocator) DIEExpr(Expr); 239 Die.addValue((dwarf::Attribute)0, Form, Value); 240 } 241 242 /// addLocationList - Add a Dwarf loclistptr attribute data and value. 243 /// 244 void DwarfUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute, 245 unsigned Index) { 246 DIEValue *Value = new (DIEValueAllocator) DIELocList(Index); 247 dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset 248 : dwarf::DW_FORM_data4; 249 Die.addValue(Attribute, Form, Value); 250 } 251 252 /// addLabel - Add a Dwarf label attribute data and value. 253 /// 254 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, 255 const MCSymbol *Label) { 256 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 257 Die.addValue(Attribute, Form, Value); 258 } 259 260 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) { 261 addLabel(Die, (dwarf::Attribute)0, Form, Label); 262 } 263 264 /// addSectionLabel - Add a Dwarf section label attribute data and value. 265 /// 266 void DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute, 267 const MCSymbol *Label) { 268 if (DD->getDwarfVersion() >= 4) 269 addLabel(Die, Attribute, dwarf::DW_FORM_sec_offset, Label); 270 else 271 addLabel(Die, Attribute, dwarf::DW_FORM_data4, Label); 272 } 273 274 /// addSectionOffset - Add an offset into a section attribute data and value. 275 /// 276 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute, 277 uint64_t Integer) { 278 if (DD->getDwarfVersion() >= 4) 279 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer); 280 else 281 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer); 282 } 283 284 /// addLabelAddress - Add a dwarf label attribute data and value using 285 /// DW_FORM_addr or DW_FORM_GNU_addr_index. 286 /// 287 void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute, 288 const MCSymbol *Label) { 289 290 if (!DD->useSplitDwarf()) 291 return addLocalLabelAddress(Die, Attribute, Label); 292 293 if (Label) 294 DD->addArangeLabel(SymbolCU(this, Label)); 295 296 unsigned idx = DD->getAddressPool().getIndex(Label); 297 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx); 298 Die.addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value); 299 } 300 301 void DwarfCompileUnit::addLocalLabelAddress(DIE &Die, 302 dwarf::Attribute Attribute, 303 const MCSymbol *Label) { 304 if (Label) 305 DD->addArangeLabel(SymbolCU(this, Label)); 306 307 Die.addValue(Attribute, dwarf::DW_FORM_addr, 308 Label ? (DIEValue *)new (DIEValueAllocator) DIELabel(Label) 309 : new (DIEValueAllocator) DIEInteger(0)); 310 } 311 312 unsigned DwarfCompileUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) { 313 // If we print assembly, we can't separate .file entries according to 314 // compile units. Thus all files will belong to the default compile unit. 315 316 // FIXME: add a better feature test than hasRawTextSupport. Even better, 317 // extend .file to support this. 318 return Asm->OutStreamer.EmitDwarfFileDirective( 319 0, DirName, FileName, 320 Asm->OutStreamer.hasRawTextSupport() ? 0 : getUniqueID()); 321 } 322 323 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) { 324 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName) 325 : getCU().getOrCreateSourceID(FileName, DirName); 326 } 327 328 /// addOpAddress - Add a dwarf op address data and value using the 329 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index. 330 /// 331 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) { 332 if (!DD->useSplitDwarf()) { 333 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 334 addLabel(Die, dwarf::DW_FORM_udata, Sym); 335 } else { 336 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index); 337 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, 338 DD->getAddressPool().getIndex(Sym)); 339 } 340 } 341 342 /// addSectionDelta - Add a section label delta attribute data and value. 343 /// 344 void DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute, 345 const MCSymbol *Hi, const MCSymbol *Lo) { 346 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 347 Die.addValue(Attribute, DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset 348 : dwarf::DW_FORM_data4, 349 Value); 350 } 351 352 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute, 353 const MCSymbol *Hi, const MCSymbol *Lo) { 354 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 355 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value); 356 } 357 358 /// addDIEEntry - Add a DIE attribute data and value. 359 /// 360 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) { 361 addDIEEntry(Die, Attribute, createDIEEntry(Entry)); 362 } 363 364 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) { 365 // Flag the type unit reference as a declaration so that if it contains 366 // members (implicit special members, static data member definitions, member 367 // declarations for definitions in this CU, etc) consumers don't get confused 368 // and think this is a full definition. 369 addFlag(Die, dwarf::DW_AT_declaration); 370 371 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8, 372 new (DIEValueAllocator) DIETypeSignature(Type)); 373 } 374 375 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, 376 DIEEntry *Entry) { 377 const DIE *DieCU = Die.getUnitOrNull(); 378 const DIE *EntryCU = Entry->getEntry().getUnitOrNull(); 379 if (!DieCU) 380 // We assume that Die belongs to this CU, if it is not linked to any CU yet. 381 DieCU = &getUnitDie(); 382 if (!EntryCU) 383 EntryCU = &getUnitDie(); 384 Die.addValue(Attribute, 385 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, 386 Entry); 387 } 388 389 /// Create a DIE with the given Tag, add the DIE to its parent, and 390 /// call insertDIE if MD is not null. 391 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) { 392 assert(Tag != dwarf::DW_TAG_auto_variable && 393 Tag != dwarf::DW_TAG_arg_variable); 394 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag)); 395 DIE &Die = *Parent.getChildren().back(); 396 if (N) 397 insertDIE(N, &Die); 398 return Die; 399 } 400 401 /// addBlock - Add block data. 402 /// 403 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) { 404 Loc->ComputeSize(Asm); 405 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on. 406 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc); 407 } 408 409 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, 410 DIEBlock *Block) { 411 Block->ComputeSize(Asm); 412 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 413 Die.addValue(Attribute, Block->BestForm(), Block); 414 } 415 416 /// addSourceLine - Add location information to specified debug information 417 /// entry. 418 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File, 419 StringRef Directory) { 420 if (Line == 0) 421 return; 422 423 unsigned FileID = getOrCreateSourceID(File, Directory); 424 assert(FileID && "Invalid file id"); 425 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID); 426 addUInt(Die, dwarf::DW_AT_decl_line, None, Line); 427 } 428 429 /// addSourceLine - Add location information to specified debug information 430 /// entry. 431 void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) { 432 assert(V.isVariable()); 433 434 addSourceLine(Die, V.getLineNumber(), V.getContext().getFilename(), 435 V.getContext().getDirectory()); 436 } 437 438 /// addSourceLine - Add location information to specified debug information 439 /// entry. 440 void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) { 441 assert(G.isGlobalVariable()); 442 443 addSourceLine(Die, G.getLineNumber(), G.getFilename(), G.getDirectory()); 444 } 445 446 /// addSourceLine - Add location information to specified debug information 447 /// entry. 448 void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) { 449 assert(SP.isSubprogram()); 450 451 addSourceLine(Die, SP.getLineNumber(), SP.getFilename(), SP.getDirectory()); 452 } 453 454 /// addSourceLine - Add location information to specified debug information 455 /// entry. 456 void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) { 457 assert(Ty.isType()); 458 459 addSourceLine(Die, Ty.getLineNumber(), Ty.getFilename(), Ty.getDirectory()); 460 } 461 462 /// addSourceLine - Add location information to specified debug information 463 /// entry. 464 void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) { 465 assert(Ty.isObjCProperty()); 466 467 DIFile File = Ty.getFile(); 468 addSourceLine(Die, Ty.getLineNumber(), File.getFilename(), 469 File.getDirectory()); 470 } 471 472 /// addSourceLine - Add location information to specified debug information 473 /// entry. 474 void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) { 475 assert(NS.Verify()); 476 477 addSourceLine(Die, NS.getLineNumber(), NS.getFilename(), NS.getDirectory()); 478 } 479 480 /// addVariableAddress - Add DW_AT_location attribute for a 481 /// DbgVariable based on provided MachineLocation. 482 void DwarfUnit::addVariableAddress(const DbgVariable &DV, DIE &Die, 483 MachineLocation Location) { 484 if (DV.variableHasComplexAddress()) 485 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); 486 else if (DV.isBlockByrefVariable()) 487 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location); 488 else 489 addAddress(Die, dwarf::DW_AT_location, Location, 490 DV.getVariable().isIndirect()); 491 } 492 493 /// addRegisterOp - Add register operand. 494 void DwarfUnit::addRegisterOp(DIELoc &TheDie, unsigned Reg) { 495 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 496 int DWReg = RI->getDwarfRegNum(Reg, false); 497 bool isSubRegister = DWReg < 0; 498 499 unsigned Idx = 0; 500 501 // Go up the super-register chain until we hit a valid dwarf register number. 502 for (MCSuperRegIterator SR(Reg, RI); SR.isValid() && DWReg < 0; ++SR) { 503 DWReg = RI->getDwarfRegNum(*SR, false); 504 if (DWReg >= 0) 505 Idx = RI->getSubRegIndex(*SR, Reg); 506 } 507 508 if (DWReg < 0) { 509 DEBUG(dbgs() << "Invalid Dwarf register number.\n"); 510 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_nop); 511 return; 512 } 513 514 // Emit register 515 if (DWReg < 32) 516 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg); 517 else { 518 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 519 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg); 520 } 521 522 // Emit Mask 523 if (isSubRegister) { 524 unsigned Size = RI->getSubRegIdxSize(Idx); 525 unsigned Offset = RI->getSubRegIdxOffset(Idx); 526 if (Offset > 0) { 527 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bit_piece); 528 addUInt(TheDie, dwarf::DW_FORM_data1, Size); 529 addUInt(TheDie, dwarf::DW_FORM_data1, Offset); 530 } else { 531 unsigned ByteSize = Size / 8; // Assuming 8 bits per byte. 532 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_piece); 533 addUInt(TheDie, dwarf::DW_FORM_data1, ByteSize); 534 } 535 } 536 } 537 538 /// addRegisterOffset - Add register offset. 539 void DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg, 540 int64_t Offset) { 541 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 542 unsigned DWReg = RI->getDwarfRegNum(Reg, false); 543 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 544 if (Reg == TRI->getFrameRegister(*Asm->MF)) 545 // If variable offset is based in frame register then use fbreg. 546 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg); 547 else if (DWReg < 32) 548 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg); 549 else { 550 addUInt(TheDie, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 551 addUInt(TheDie, dwarf::DW_FORM_udata, DWReg); 552 } 553 addSInt(TheDie, dwarf::DW_FORM_sdata, Offset); 554 } 555 556 /// addAddress - Add an address attribute to a die based on the location 557 /// provided. 558 void DwarfUnit::addAddress(DIE &Die, dwarf::Attribute Attribute, 559 const MachineLocation &Location, bool Indirect) { 560 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 561 562 if (Location.isReg() && !Indirect) 563 addRegisterOp(*Loc, Location.getReg()); 564 else { 565 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset()); 566 if (Indirect && !Location.isReg()) { 567 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 568 } 569 } 570 571 // Now attach the location information to the DIE. 572 addBlock(Die, Attribute, Loc); 573 } 574 575 /// addComplexAddress - Start with the address based on the location provided, 576 /// and generate the DWARF information necessary to find the actual variable 577 /// given the extra address information encoded in the DbgVariable, starting 578 /// from the starting location. Add the DWARF information to the die. 579 /// 580 void DwarfUnit::addComplexAddress(const DbgVariable &DV, DIE &Die, 581 dwarf::Attribute Attribute, 582 const MachineLocation &Location) { 583 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 584 unsigned N = DV.getNumAddrElements(); 585 unsigned i = 0; 586 if (Location.isReg()) { 587 if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) { 588 // If first address element is OpPlus then emit 589 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 590 addRegisterOffset(*Loc, Location.getReg(), DV.getAddrElement(1)); 591 i = 2; 592 } else 593 addRegisterOp(*Loc, Location.getReg()); 594 } else 595 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset()); 596 597 for (; i < N; ++i) { 598 uint64_t Element = DV.getAddrElement(i); 599 if (Element == DIBuilder::OpPlus) { 600 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 601 addUInt(*Loc, dwarf::DW_FORM_udata, DV.getAddrElement(++i)); 602 } else if (Element == DIBuilder::OpDeref) { 603 if (!Location.isReg()) 604 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 605 } else 606 llvm_unreachable("unknown DIBuilder Opcode"); 607 } 608 609 // Now attach the location information to the DIE. 610 addBlock(Die, Attribute, Loc); 611 } 612 613 /* Byref variables, in Blocks, are declared by the programmer as "SomeType 614 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and 615 gives the variable VarName either the struct, or a pointer to the struct, as 616 its type. This is necessary for various behind-the-scenes things the 617 compiler needs to do with by-reference variables in Blocks. 618 619 However, as far as the original *programmer* is concerned, the variable 620 should still have type 'SomeType', as originally declared. 621 622 The function getBlockByrefType dives into the __Block_byref_x_VarName 623 struct to find the original type of the variable, which is then assigned to 624 the variable's Debug Information Entry as its real type. So far, so good. 625 However now the debugger will expect the variable VarName to have the type 626 SomeType. So we need the location attribute for the variable to be an 627 expression that explains to the debugger how to navigate through the 628 pointers and struct to find the actual variable of type SomeType. 629 630 The following function does just that. We start by getting 631 the "normal" location for the variable. This will be the location 632 of either the struct __Block_byref_x_VarName or the pointer to the 633 struct __Block_byref_x_VarName. 634 635 The struct will look something like: 636 637 struct __Block_byref_x_VarName { 638 ... <various fields> 639 struct __Block_byref_x_VarName *forwarding; 640 ... <various other fields> 641 SomeType VarName; 642 ... <maybe more fields> 643 }; 644 645 If we are given the struct directly (as our starting point) we 646 need to tell the debugger to: 647 648 1). Add the offset of the forwarding field. 649 650 2). Follow that pointer to get the real __Block_byref_x_VarName 651 struct to use (the real one may have been copied onto the heap). 652 653 3). Add the offset for the field VarName, to find the actual variable. 654 655 If we started with a pointer to the struct, then we need to 656 dereference that pointer first, before the other steps. 657 Translating this into DWARF ops, we will need to append the following 658 to the current location description for the variable: 659 660 DW_OP_deref -- optional, if we start with a pointer 661 DW_OP_plus_uconst <forward_fld_offset> 662 DW_OP_deref 663 DW_OP_plus_uconst <varName_fld_offset> 664 665 That is what this function does. */ 666 667 /// addBlockByrefAddress - Start with the address based on the location 668 /// provided, and generate the DWARF information necessary to find the 669 /// actual Block variable (navigating the Block struct) based on the 670 /// starting location. Add the DWARF information to the die. For 671 /// more information, read large comment just above here. 672 /// 673 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die, 674 dwarf::Attribute Attribute, 675 const MachineLocation &Location) { 676 DIType Ty = DV.getType(); 677 DIType TmpTy = Ty; 678 uint16_t Tag = Ty.getTag(); 679 bool isPointer = false; 680 681 StringRef varName = DV.getName(); 682 683 if (Tag == dwarf::DW_TAG_pointer_type) { 684 DIDerivedType DTy(Ty); 685 TmpTy = resolve(DTy.getTypeDerivedFrom()); 686 isPointer = true; 687 } 688 689 DICompositeType blockStruct(TmpTy); 690 691 // Find the __forwarding field and the variable field in the __Block_byref 692 // struct. 693 DIArray Fields = blockStruct.getTypeArray(); 694 DIDerivedType varField; 695 DIDerivedType forwardingField; 696 697 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) { 698 DIDerivedType DT(Fields.getElement(i)); 699 StringRef fieldName = DT.getName(); 700 if (fieldName == "__forwarding") 701 forwardingField = DT; 702 else if (fieldName == varName) 703 varField = DT; 704 } 705 706 // Get the offsets for the forwarding field and the variable field. 707 unsigned forwardingFieldOffset = forwardingField.getOffsetInBits() >> 3; 708 unsigned varFieldOffset = varField.getOffsetInBits() >> 2; 709 710 // Decode the original location, and use that as the start of the byref 711 // variable's location. 712 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 713 714 if (Location.isReg()) 715 addRegisterOp(*Loc, Location.getReg()); 716 else 717 addRegisterOffset(*Loc, Location.getReg(), Location.getOffset()); 718 719 // If we started with a pointer to the __Block_byref... struct, then 720 // the first thing we need to do is dereference the pointer (DW_OP_deref). 721 if (isPointer) 722 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 723 724 // Next add the offset for the '__forwarding' field: 725 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in 726 // adding the offset if it's 0. 727 if (forwardingFieldOffset > 0) { 728 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 729 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset); 730 } 731 732 // Now dereference the __forwarding field to get to the real __Block_byref 733 // struct: DW_OP_deref. 734 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 735 736 // Now that we've got the real __Block_byref... struct, add the offset 737 // for the variable's field to get to the location of the actual variable: 738 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0. 739 if (varFieldOffset > 0) { 740 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 741 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset); 742 } 743 744 // Now attach the location information to the DIE. 745 addBlock(Die, Attribute, Loc); 746 } 747 748 /// Return true if type encoding is unsigned. 749 static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) { 750 DIDerivedType DTy(Ty); 751 if (DTy.isDerivedType()) { 752 dwarf::Tag T = (dwarf::Tag)Ty.getTag(); 753 // Encode pointer constants as unsigned bytes. This is used at least for 754 // null pointer constant emission. 755 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed 756 // here, but accept them for now due to a bug in SROA producing bogus 757 // dbg.values. 758 if (T == dwarf::DW_TAG_pointer_type || 759 T == dwarf::DW_TAG_ptr_to_member_type || 760 T == dwarf::DW_TAG_reference_type || 761 T == dwarf::DW_TAG_rvalue_reference_type) 762 return true; 763 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type || 764 T == dwarf::DW_TAG_volatile_type || 765 T == dwarf::DW_TAG_restrict_type || 766 T == dwarf::DW_TAG_enumeration_type); 767 if (DITypeRef Deriv = DTy.getTypeDerivedFrom()) 768 return isUnsignedDIType(DD, DD->resolve(Deriv)); 769 // FIXME: Enums without a fixed underlying type have unknown signedness 770 // here, leading to incorrectly emitted constants. 771 assert(DTy.getTag() == dwarf::DW_TAG_enumeration_type); 772 return false; 773 } 774 775 DIBasicType BTy(Ty); 776 assert(BTy.isBasicType()); 777 unsigned Encoding = BTy.getEncoding(); 778 assert((Encoding == dwarf::DW_ATE_unsigned || 779 Encoding == dwarf::DW_ATE_unsigned_char || 780 Encoding == dwarf::DW_ATE_signed || 781 Encoding == dwarf::DW_ATE_signed_char || 782 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean) && 783 "Unsupported encoding"); 784 return (Encoding == dwarf::DW_ATE_unsigned || 785 Encoding == dwarf::DW_ATE_unsigned_char || 786 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean); 787 } 788 789 /// If this type is derived from a base type then return base type size. 790 static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) { 791 unsigned Tag = Ty.getTag(); 792 793 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && 794 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && 795 Tag != dwarf::DW_TAG_restrict_type) 796 return Ty.getSizeInBits(); 797 798 DIType BaseType = DD->resolve(Ty.getTypeDerivedFrom()); 799 800 // If this type is not derived from any type or the type is a declaration then 801 // take conservative approach. 802 if (!BaseType.isValid() || BaseType.isForwardDecl()) 803 return Ty.getSizeInBits(); 804 805 // If this is a derived type, go ahead and get the base type, unless it's a 806 // reference then it's just the size of the field. Pointer types have no need 807 // of this since they're a different type of qualification on the type. 808 if (BaseType.getTag() == dwarf::DW_TAG_reference_type || 809 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type) 810 return Ty.getSizeInBits(); 811 812 if (BaseType.isDerivedType()) 813 return getBaseTypeSize(DD, DIDerivedType(BaseType)); 814 815 return BaseType.getSizeInBits(); 816 } 817 818 /// addConstantFPValue - Add constant value entry in variable DIE. 819 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) { 820 assert(MO.isFPImm() && "Invalid machine operand!"); 821 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 822 APFloat FPImm = MO.getFPImm()->getValueAPF(); 823 824 // Get the raw data form of the floating point. 825 const APInt FltVal = FPImm.bitcastToAPInt(); 826 const char *FltPtr = (const char *)FltVal.getRawData(); 827 828 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte. 829 bool LittleEndian = Asm->getDataLayout().isLittleEndian(); 830 int Incr = (LittleEndian ? 1 : -1); 831 int Start = (LittleEndian ? 0 : NumBytes - 1); 832 int Stop = (LittleEndian ? NumBytes : -1); 833 834 // Output the constant to DWARF one byte at a time. 835 for (; Start != Stop; Start += Incr) 836 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]); 837 838 addBlock(Die, dwarf::DW_AT_const_value, Block); 839 } 840 841 /// addConstantFPValue - Add constant value entry in variable DIE. 842 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) { 843 // Pass this down to addConstantValue as an unsigned bag of bits. 844 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true); 845 } 846 847 /// addConstantValue - Add constant value entry in variable DIE. 848 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) { 849 addConstantValue(Die, CI->getValue(), Ty); 850 } 851 852 /// addConstantValue - Add constant value entry in variable DIE. 853 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO, 854 DIType Ty) { 855 assert(MO.isImm() && "Invalid machine operand!"); 856 857 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm()); 858 } 859 860 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) { 861 // FIXME: This is a bit conservative/simple - it emits negative values always 862 // sign extended to 64 bits rather than minimizing the number of bytes. 863 addUInt(Die, dwarf::DW_AT_const_value, 864 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val); 865 } 866 867 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) { 868 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty)); 869 } 870 871 // addConstantValue - Add constant value entry in variable DIE. 872 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) { 873 unsigned CIBitWidth = Val.getBitWidth(); 874 if (CIBitWidth <= 64) { 875 addConstantValue(Die, Unsigned, 876 Unsigned ? Val.getZExtValue() : Val.getSExtValue()); 877 return; 878 } 879 880 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 881 882 // Get the raw data form of the large APInt. 883 const uint64_t *Ptr64 = Val.getRawData(); 884 885 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte. 886 bool LittleEndian = Asm->getDataLayout().isLittleEndian(); 887 888 // Output the constant to DWARF one byte at a time. 889 for (int i = 0; i < NumBytes; i++) { 890 uint8_t c; 891 if (LittleEndian) 892 c = Ptr64[i / 8] >> (8 * (i & 7)); 893 else 894 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7)); 895 addUInt(*Block, dwarf::DW_FORM_data1, c); 896 } 897 898 addBlock(Die, dwarf::DW_AT_const_value, Block); 899 } 900 901 /// addTemplateParams - Add template parameters into buffer. 902 void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) { 903 // Add template parameters. 904 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) { 905 DIDescriptor Element = TParams.getElement(i); 906 if (Element.isTemplateTypeParameter()) 907 constructTemplateTypeParameterDIE(Buffer, 908 DITemplateTypeParameter(Element)); 909 else if (Element.isTemplateValueParameter()) 910 constructTemplateValueParameterDIE(Buffer, 911 DITemplateValueParameter(Element)); 912 } 913 } 914 915 /// getOrCreateContextDIE - Get context owner's DIE. 916 DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) { 917 if (!Context || Context.isFile()) 918 return &getUnitDie(); 919 if (Context.isType()) 920 return getOrCreateTypeDIE(DIType(Context)); 921 if (Context.isNameSpace()) 922 return getOrCreateNameSpace(DINameSpace(Context)); 923 if (Context.isSubprogram()) 924 return getOrCreateSubprogramDIE(DISubprogram(Context)); 925 return getDIE(Context); 926 } 927 928 DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) { 929 DIScope Context = resolve(Ty.getContext()); 930 DIE *ContextDIE = getOrCreateContextDIE(Context); 931 932 if (DIE *TyDIE = getDIE(Ty)) 933 return TyDIE; 934 935 // Create new type. 936 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty); 937 938 constructTypeDIE(TyDIE, Ty); 939 940 updateAcceleratorTables(Context, Ty, TyDIE); 941 return &TyDIE; 942 } 943 944 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 945 /// given DIType. 946 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) { 947 if (!TyNode) 948 return nullptr; 949 950 DIType Ty(TyNode); 951 assert(Ty.isType()); 952 assert(Ty == resolve(Ty.getRef()) && 953 "type was not uniqued, possible ODR violation."); 954 955 // DW_TAG_restrict_type is not supported in DWARF2 956 if (Ty.getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2) 957 return getOrCreateTypeDIE(resolve(DIDerivedType(Ty).getTypeDerivedFrom())); 958 959 // Construct the context before querying for the existence of the DIE in case 960 // such construction creates the DIE. 961 DIScope Context = resolve(Ty.getContext()); 962 DIE *ContextDIE = getOrCreateContextDIE(Context); 963 assert(ContextDIE); 964 965 if (DIE *TyDIE = getDIE(Ty)) 966 return TyDIE; 967 968 // Create new type. 969 DIE &TyDIE = createAndAddDIE(Ty.getTag(), *ContextDIE, Ty); 970 971 updateAcceleratorTables(Context, Ty, TyDIE); 972 973 if (Ty.isBasicType()) 974 constructTypeDIE(TyDIE, DIBasicType(Ty)); 975 else if (Ty.isCompositeType()) { 976 DICompositeType CTy(Ty); 977 if (GenerateDwarfTypeUnits && !Ty.isForwardDecl()) 978 if (MDString *TypeId = CTy.getIdentifier()) { 979 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy); 980 // Skip updating the accelerator tables since this is not the full type. 981 return &TyDIE; 982 } 983 constructTypeDIE(TyDIE, CTy); 984 } else { 985 assert(Ty.isDerivedType() && "Unknown kind of DIType"); 986 constructTypeDIE(TyDIE, DIDerivedType(Ty)); 987 } 988 989 return &TyDIE; 990 } 991 992 void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty, 993 const DIE &TyDIE) { 994 if (!Ty.getName().empty() && !Ty.isForwardDecl()) { 995 bool IsImplementation = 0; 996 if (Ty.isCompositeType()) { 997 DICompositeType CT(Ty); 998 // A runtime language of 0 actually means C/C++ and that any 999 // non-negative value is some version of Objective-C/C++. 1000 IsImplementation = (CT.getRunTimeLang() == 0) || CT.isObjcClassComplete(); 1001 } 1002 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0; 1003 DD->addAccelType(Ty.getName(), TyDIE, Flags); 1004 1005 if ((!Context || Context.isCompileUnit() || Context.isFile() || 1006 Context.isNameSpace()) && 1007 getCUNode().getEmissionKind() != DIBuilder::LineTablesOnly) 1008 GlobalTypes[getParentContextString(Context) + Ty.getName().str()] = 1009 &TyDIE; 1010 } 1011 } 1012 1013 /// addType - Add a new type attribute to the specified entity. 1014 void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) { 1015 assert(Ty && "Trying to add a type that doesn't exist?"); 1016 1017 // Check for pre-existence. 1018 DIEEntry *Entry = getDIEEntry(Ty); 1019 // If it exists then use the existing value. 1020 if (Entry) { 1021 addDIEEntry(Entity, Attribute, Entry); 1022 return; 1023 } 1024 1025 // Construct type. 1026 DIE *Buffer = getOrCreateTypeDIE(Ty); 1027 1028 // Set up proxy. 1029 Entry = createDIEEntry(*Buffer); 1030 insertDIEEntry(Ty, Entry); 1031 addDIEEntry(Entity, Attribute, Entry); 1032 } 1033 1034 /// addGlobalName - Add a new global name to the compile unit. 1035 void DwarfUnit::addGlobalName(StringRef Name, DIE &Die, DIScope Context) { 1036 if (getCUNode().getEmissionKind() == DIBuilder::LineTablesOnly) 1037 return; 1038 std::string FullName = getParentContextString(Context) + Name.str(); 1039 GlobalNames[FullName] = &Die; 1040 } 1041 1042 /// getParentContextString - Walks the metadata parent chain in a language 1043 /// specific manner (using the compile unit language) and returns 1044 /// it as a string. This is done at the metadata level because DIEs may 1045 /// not currently have been added to the parent context and walking the 1046 /// DIEs looking for names is more expensive than walking the metadata. 1047 std::string DwarfUnit::getParentContextString(DIScope Context) const { 1048 if (!Context) 1049 return ""; 1050 1051 // FIXME: Decide whether to implement this for non-C++ languages. 1052 if (getLanguage() != dwarf::DW_LANG_C_plus_plus) 1053 return ""; 1054 1055 std::string CS; 1056 SmallVector<DIScope, 1> Parents; 1057 while (!Context.isCompileUnit()) { 1058 Parents.push_back(Context); 1059 if (Context.getContext()) 1060 Context = resolve(Context.getContext()); 1061 else 1062 // Structure, etc types will have a NULL context if they're at the top 1063 // level. 1064 break; 1065 } 1066 1067 // Reverse iterate over our list to go from the outermost construct to the 1068 // innermost. 1069 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(), 1070 E = Parents.rend(); 1071 I != E; ++I) { 1072 DIScope Ctx = *I; 1073 StringRef Name = Ctx.getName(); 1074 if (Name.empty() && Ctx.isNameSpace()) 1075 Name = "(anonymous namespace)"; 1076 if (!Name.empty()) { 1077 CS += Name; 1078 CS += "::"; 1079 } 1080 } 1081 return CS; 1082 } 1083 1084 /// constructTypeDIE - Construct basic type die from DIBasicType. 1085 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 1086 // Get core information. 1087 StringRef Name = BTy.getName(); 1088 // Add name if not anonymous or intermediate type. 1089 if (!Name.empty()) 1090 addString(Buffer, dwarf::DW_AT_name, Name); 1091 1092 // An unspecified type only has a name attribute. 1093 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) 1094 return; 1095 1096 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1097 BTy.getEncoding()); 1098 1099 uint64_t Size = BTy.getSizeInBits() >> 3; 1100 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 1101 } 1102 1103 /// constructTypeDIE - Construct derived type die from DIDerivedType. 1104 void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 1105 // Get core information. 1106 StringRef Name = DTy.getName(); 1107 uint64_t Size = DTy.getSizeInBits() >> 3; 1108 uint16_t Tag = Buffer.getTag(); 1109 1110 // Map to main type, void will not have a type. 1111 DIType FromTy = resolve(DTy.getTypeDerivedFrom()); 1112 if (FromTy) 1113 addType(Buffer, FromTy); 1114 1115 // Add name if not anonymous or intermediate type. 1116 if (!Name.empty()) 1117 addString(Buffer, dwarf::DW_AT_name, Name); 1118 1119 // Add size if non-zero (derived types might be zero-sized.) 1120 if (Size && Tag != dwarf::DW_TAG_pointer_type) 1121 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 1122 1123 if (Tag == dwarf::DW_TAG_ptr_to_member_type) 1124 addDIEEntry(Buffer, dwarf::DW_AT_containing_type, 1125 *getOrCreateTypeDIE(resolve(DTy.getClassType()))); 1126 // Add source line info if available and TyDesc is not a forward declaration. 1127 if (!DTy.isForwardDecl()) 1128 addSourceLine(Buffer, DTy); 1129 } 1130 1131 /// constructSubprogramArguments - Construct function argument DIEs. 1132 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) { 1133 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1134 DIDescriptor Ty = Args.getElement(i); 1135 if (Ty.isUnspecifiedParameter()) { 1136 assert(i == N-1 && "Unspecified parameter must be the last argument"); 1137 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer); 1138 } else { 1139 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer); 1140 addType(Arg, DIType(Ty)); 1141 if (DIType(Ty).isArtificial()) 1142 addFlag(Arg, dwarf::DW_AT_artificial); 1143 } 1144 } 1145 } 1146 1147 /// constructTypeDIE - Construct type DIE from DICompositeType. 1148 void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 1149 // Add name if not anonymous or intermediate type. 1150 StringRef Name = CTy.getName(); 1151 1152 uint64_t Size = CTy.getSizeInBits() >> 3; 1153 uint16_t Tag = Buffer.getTag(); 1154 1155 switch (Tag) { 1156 case dwarf::DW_TAG_array_type: 1157 constructArrayTypeDIE(Buffer, CTy); 1158 break; 1159 case dwarf::DW_TAG_enumeration_type: 1160 constructEnumTypeDIE(Buffer, CTy); 1161 break; 1162 case dwarf::DW_TAG_subroutine_type: { 1163 // Add return type. A void return won't have a type. 1164 DIArray Elements = CTy.getTypeArray(); 1165 DIType RTy(Elements.getElement(0)); 1166 if (RTy) 1167 addType(Buffer, RTy); 1168 1169 bool isPrototyped = true; 1170 if (Elements.getNumElements() == 2 && 1171 Elements.getElement(1).isUnspecifiedParameter()) 1172 isPrototyped = false; 1173 1174 constructSubprogramArguments(Buffer, Elements); 1175 1176 // Add prototype flag if we're dealing with a C language and the 1177 // function has been prototyped. 1178 uint16_t Language = getLanguage(); 1179 if (isPrototyped && 1180 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 1181 Language == dwarf::DW_LANG_ObjC)) 1182 addFlag(Buffer, dwarf::DW_AT_prototyped); 1183 1184 if (CTy.isLValueReference()) 1185 addFlag(Buffer, dwarf::DW_AT_reference); 1186 1187 if (CTy.isRValueReference()) 1188 addFlag(Buffer, dwarf::DW_AT_rvalue_reference); 1189 } break; 1190 case dwarf::DW_TAG_structure_type: 1191 case dwarf::DW_TAG_union_type: 1192 case dwarf::DW_TAG_class_type: { 1193 // Add elements to structure type. 1194 DIArray Elements = CTy.getTypeArray(); 1195 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1196 DIDescriptor Element = Elements.getElement(i); 1197 if (Element.isSubprogram()) 1198 getOrCreateSubprogramDIE(DISubprogram(Element)); 1199 else if (Element.isDerivedType()) { 1200 DIDerivedType DDTy(Element); 1201 if (DDTy.getTag() == dwarf::DW_TAG_friend) { 1202 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer); 1203 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()), 1204 dwarf::DW_AT_friend); 1205 } else if (DDTy.isStaticMember()) { 1206 getOrCreateStaticMemberDIE(DDTy); 1207 } else { 1208 constructMemberDIE(Buffer, DDTy); 1209 } 1210 } else if (Element.isObjCProperty()) { 1211 DIObjCProperty Property(Element); 1212 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer); 1213 StringRef PropertyName = Property.getObjCPropertyName(); 1214 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName); 1215 if (Property.getType()) 1216 addType(ElemDie, Property.getType()); 1217 addSourceLine(ElemDie, Property); 1218 StringRef GetterName = Property.getObjCPropertyGetterName(); 1219 if (!GetterName.empty()) 1220 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName); 1221 StringRef SetterName = Property.getObjCPropertySetterName(); 1222 if (!SetterName.empty()) 1223 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName); 1224 unsigned PropertyAttributes = 0; 1225 if (Property.isReadOnlyObjCProperty()) 1226 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly; 1227 if (Property.isReadWriteObjCProperty()) 1228 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite; 1229 if (Property.isAssignObjCProperty()) 1230 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign; 1231 if (Property.isRetainObjCProperty()) 1232 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain; 1233 if (Property.isCopyObjCProperty()) 1234 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy; 1235 if (Property.isNonAtomicObjCProperty()) 1236 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic; 1237 if (PropertyAttributes) 1238 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None, 1239 PropertyAttributes); 1240 1241 DIEEntry *Entry = getDIEEntry(Element); 1242 if (!Entry) { 1243 Entry = createDIEEntry(ElemDie); 1244 insertDIEEntry(Element, Entry); 1245 } 1246 } else 1247 continue; 1248 } 1249 1250 if (CTy.isAppleBlockExtension()) 1251 addFlag(Buffer, dwarf::DW_AT_APPLE_block); 1252 1253 DICompositeType ContainingType(resolve(CTy.getContainingType())); 1254 if (ContainingType) 1255 addDIEEntry(Buffer, dwarf::DW_AT_containing_type, 1256 *getOrCreateTypeDIE(ContainingType)); 1257 1258 if (CTy.isObjcClassComplete()) 1259 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type); 1260 1261 // Add template parameters to a class, structure or union types. 1262 // FIXME: The support isn't in the metadata for this yet. 1263 if (Tag == dwarf::DW_TAG_class_type || 1264 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 1265 addTemplateParams(Buffer, CTy.getTemplateParams()); 1266 1267 break; 1268 } 1269 default: 1270 break; 1271 } 1272 1273 // Add name if not anonymous or intermediate type. 1274 if (!Name.empty()) 1275 addString(Buffer, dwarf::DW_AT_name, Name); 1276 1277 if (Tag == dwarf::DW_TAG_enumeration_type || 1278 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type || 1279 Tag == dwarf::DW_TAG_union_type) { 1280 // Add size if non-zero (derived types might be zero-sized.) 1281 // TODO: Do we care about size for enum forward declarations? 1282 if (Size) 1283 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 1284 else if (!CTy.isForwardDecl()) 1285 // Add zero size if it is not a forward declaration. 1286 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0); 1287 1288 // If we're a forward decl, say so. 1289 if (CTy.isForwardDecl()) 1290 addFlag(Buffer, dwarf::DW_AT_declaration); 1291 1292 // Add source line info if available. 1293 if (!CTy.isForwardDecl()) 1294 addSourceLine(Buffer, CTy); 1295 1296 // No harm in adding the runtime language to the declaration. 1297 unsigned RLang = CTy.getRunTimeLang(); 1298 if (RLang) 1299 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1, 1300 RLang); 1301 } 1302 } 1303 1304 /// constructTemplateTypeParameterDIE - Construct new DIE for the given 1305 /// DITemplateTypeParameter. 1306 void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer, 1307 DITemplateTypeParameter TP) { 1308 DIE &ParamDIE = 1309 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer); 1310 // Add the type if it exists, it could be void and therefore no type. 1311 if (TP.getType()) 1312 addType(ParamDIE, resolve(TP.getType())); 1313 if (!TP.getName().empty()) 1314 addString(ParamDIE, dwarf::DW_AT_name, TP.getName()); 1315 } 1316 1317 /// constructTemplateValueParameterDIE - Construct new DIE for the given 1318 /// DITemplateValueParameter. 1319 void 1320 DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer, 1321 DITemplateValueParameter VP) { 1322 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer); 1323 1324 // Add the type if there is one, template template and template parameter 1325 // packs will not have a type. 1326 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter) 1327 addType(ParamDIE, resolve(VP.getType())); 1328 if (!VP.getName().empty()) 1329 addString(ParamDIE, dwarf::DW_AT_name, VP.getName()); 1330 if (Value *Val = VP.getValue()) { 1331 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) 1332 addConstantValue(ParamDIE, CI, resolve(VP.getType())); 1333 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) { 1334 // For declaration non-type template parameters (such as global values and 1335 // functions) 1336 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 1337 addOpAddress(*Loc, Asm->getSymbol(GV)); 1338 // Emit DW_OP_stack_value to use the address as the immediate value of the 1339 // parameter, rather than a pointer to it. 1340 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value); 1341 addBlock(ParamDIE, dwarf::DW_AT_location, Loc); 1342 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) { 1343 assert(isa<MDString>(Val)); 1344 addString(ParamDIE, dwarf::DW_AT_GNU_template_name, 1345 cast<MDString>(Val)->getString()); 1346 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) { 1347 assert(isa<MDNode>(Val)); 1348 DIArray A(cast<MDNode>(Val)); 1349 addTemplateParams(ParamDIE, A); 1350 } 1351 } 1352 } 1353 1354 /// getOrCreateNameSpace - Create a DIE for DINameSpace. 1355 DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) { 1356 // Construct the context before querying for the existence of the DIE in case 1357 // such construction creates the DIE. 1358 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext()); 1359 1360 if (DIE *NDie = getDIE(NS)) 1361 return NDie; 1362 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS); 1363 1364 StringRef Name = NS.getName(); 1365 if (!Name.empty()) 1366 addString(NDie, dwarf::DW_AT_name, NS.getName()); 1367 else 1368 Name = "(anonymous namespace)"; 1369 DD->addAccelNamespace(Name, NDie); 1370 addGlobalName(Name, NDie, NS.getContext()); 1371 addSourceLine(NDie, NS); 1372 return &NDie; 1373 } 1374 1375 /// getOrCreateSubprogramDIE - Create new DIE using SP. 1376 DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) { 1377 // Construct the context before querying for the existence of the DIE in case 1378 // such construction creates the DIE (as is the case for member function 1379 // declarations). 1380 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext())); 1381 1382 if (DIE *SPDie = getDIE(SP)) 1383 return SPDie; 1384 1385 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) { 1386 // Add subprogram definitions to the CU die directly. 1387 ContextDIE = &getUnitDie(); 1388 // Build the decl now to ensure it precedes the definition. 1389 getOrCreateSubprogramDIE(SPDecl); 1390 } 1391 1392 // DW_TAG_inlined_subroutine may refer to this DIE. 1393 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP); 1394 1395 // Stop here and fill this in later, depending on whether or not this 1396 // subprogram turns out to have inlined instances or not. 1397 if (SP.isDefinition()) 1398 return &SPDie; 1399 1400 applySubprogramAttributes(SP, SPDie); 1401 return &SPDie; 1402 } 1403 1404 void DwarfUnit::applySubprogramAttributesToDefinition(DISubprogram SP, DIE &SPDie) { 1405 DISubprogram SPDecl = SP.getFunctionDeclaration(); 1406 DIScope Context = resolve(SPDecl ? SPDecl.getContext() : SP.getContext()); 1407 applySubprogramAttributes(SP, SPDie); 1408 addGlobalName(SP.getName(), SPDie, Context); 1409 } 1410 1411 void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) { 1412 DIE *DeclDie = nullptr; 1413 StringRef DeclLinkageName; 1414 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) { 1415 DeclDie = getDIE(SPDecl); 1416 assert(DeclDie && "This DIE should've already been constructed when the " 1417 "definition DIE was created in " 1418 "getOrCreateSubprogramDIE"); 1419 DeclLinkageName = SPDecl.getLinkageName(); 1420 } 1421 1422 // Add function template parameters. 1423 addTemplateParams(SPDie, SP.getTemplateParams()); 1424 1425 // Add the linkage name if we have one and it isn't in the Decl. 1426 StringRef LinkageName = SP.getLinkageName(); 1427 assert(((LinkageName.empty() || DeclLinkageName.empty()) || 1428 LinkageName == DeclLinkageName) && 1429 "decl has a linkage name and it is different"); 1430 if (!LinkageName.empty() && DeclLinkageName.empty()) 1431 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, 1432 GlobalValue::getRealLinkageName(LinkageName)); 1433 1434 if (DeclDie) { 1435 // Refer to the function declaration where all the other attributes will be 1436 // found. 1437 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie); 1438 return; 1439 } 1440 1441 // Constructors and operators for anonymous aggregates do not have names. 1442 if (!SP.getName().empty()) 1443 addString(SPDie, dwarf::DW_AT_name, SP.getName()); 1444 1445 addSourceLine(SPDie, SP); 1446 1447 // Add the prototype if we have a prototype and we have a C like 1448 // language. 1449 uint16_t Language = getLanguage(); 1450 if (SP.isPrototyped() && 1451 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 1452 Language == dwarf::DW_LANG_ObjC)) 1453 addFlag(SPDie, dwarf::DW_AT_prototyped); 1454 1455 DICompositeType SPTy = SP.getType(); 1456 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type && 1457 "the type of a subprogram should be a subroutine"); 1458 1459 DIArray Args = SPTy.getTypeArray(); 1460 // Add a return type. If this is a type like a C/C++ void type we don't add a 1461 // return type. 1462 if (Args.getElement(0)) 1463 addType(SPDie, DIType(Args.getElement(0))); 1464 1465 unsigned VK = SP.getVirtuality(); 1466 if (VK) { 1467 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK); 1468 DIELoc *Block = getDIELoc(); 1469 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1470 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex()); 1471 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block); 1472 ContainingTypeMap.insert( 1473 std::make_pair(&SPDie, resolve(SP.getContainingType()))); 1474 } 1475 1476 if (!SP.isDefinition()) { 1477 addFlag(SPDie, dwarf::DW_AT_declaration); 1478 1479 // Add arguments. Do not add arguments for subprogram definition. They will 1480 // be handled while processing variables. 1481 constructSubprogramArguments(SPDie, Args); 1482 } 1483 1484 if (SP.isArtificial()) 1485 addFlag(SPDie, dwarf::DW_AT_artificial); 1486 1487 if (!SP.isLocalToUnit()) 1488 addFlag(SPDie, dwarf::DW_AT_external); 1489 1490 if (SP.isOptimized()) 1491 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized); 1492 1493 if (unsigned isa = Asm->getISAEncoding()) { 1494 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 1495 } 1496 1497 if (SP.isLValueReference()) 1498 addFlag(SPDie, dwarf::DW_AT_reference); 1499 1500 if (SP.isRValueReference()) 1501 addFlag(SPDie, dwarf::DW_AT_rvalue_reference); 1502 1503 if (SP.isProtected()) 1504 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1505 dwarf::DW_ACCESS_protected); 1506 else if (SP.isPrivate()) 1507 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1508 dwarf::DW_ACCESS_private); 1509 else 1510 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1511 dwarf::DW_ACCESS_public); 1512 1513 if (SP.isExplicit()) 1514 addFlag(SPDie, dwarf::DW_AT_explicit); 1515 } 1516 1517 void DwarfUnit::applyVariableAttributes(const DbgVariable &Var, 1518 DIE &VariableDie) { 1519 StringRef Name = Var.getName(); 1520 if (!Name.empty()) 1521 addString(VariableDie, dwarf::DW_AT_name, Name); 1522 addSourceLine(VariableDie, Var.getVariable()); 1523 addType(VariableDie, Var.getType()); 1524 if (Var.isArtificial()) 1525 addFlag(VariableDie, dwarf::DW_AT_artificial); 1526 } 1527 1528 // Return const expression if value is a GEP to access merged global 1529 // constant. e.g. 1530 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0) 1531 static const ConstantExpr *getMergedGlobalExpr(const Value *V) { 1532 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V); 1533 if (!CE || CE->getNumOperands() != 3 || 1534 CE->getOpcode() != Instruction::GetElementPtr) 1535 return nullptr; 1536 1537 // First operand points to a global struct. 1538 Value *Ptr = CE->getOperand(0); 1539 if (!isa<GlobalValue>(Ptr) || 1540 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType())) 1541 return nullptr; 1542 1543 // Second operand is zero. 1544 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1)); 1545 if (!CI || !CI->isZero()) 1546 return nullptr; 1547 1548 // Third operand is offset. 1549 if (!isa<ConstantInt>(CE->getOperand(2))) 1550 return nullptr; 1551 1552 return CE; 1553 } 1554 1555 /// createGlobalVariableDIE - create global variable DIE. 1556 void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) { 1557 // Check for pre-existence. 1558 if (getDIE(GV)) 1559 return; 1560 1561 assert(GV.isGlobalVariable()); 1562 1563 DIScope GVContext = GV.getContext(); 1564 DIType GTy = DD->resolve(GV.getType()); 1565 1566 // If this is a static data member definition, some attributes belong 1567 // to the declaration DIE. 1568 DIE *VariableDIE = nullptr; 1569 bool IsStaticMember = false; 1570 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration(); 1571 if (SDMDecl.Verify()) { 1572 assert(SDMDecl.isStaticMember() && "Expected static member decl"); 1573 // We need the declaration DIE that is in the static member's class. 1574 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl); 1575 IsStaticMember = true; 1576 } 1577 1578 // If this is not a static data member definition, create the variable 1579 // DIE and add the initial set of attributes to it. 1580 if (!VariableDIE) { 1581 // Construct the context before querying for the existence of the DIE in 1582 // case such construction creates the DIE. 1583 DIE *ContextDIE = getOrCreateContextDIE(GVContext); 1584 1585 // Add to map. 1586 VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV); 1587 1588 // Add name and type. 1589 addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName()); 1590 addType(*VariableDIE, GTy); 1591 1592 // Add scoping info. 1593 if (!GV.isLocalToUnit()) 1594 addFlag(*VariableDIE, dwarf::DW_AT_external); 1595 1596 // Add line number info. 1597 addSourceLine(*VariableDIE, GV); 1598 } 1599 1600 // Add location. 1601 bool addToAccelTable = false; 1602 DIE *VariableSpecDIE = nullptr; 1603 bool isGlobalVariable = GV.getGlobal() != nullptr; 1604 if (isGlobalVariable) { 1605 addToAccelTable = true; 1606 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 1607 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal()); 1608 if (GV.getGlobal()->isThreadLocal()) { 1609 // FIXME: Make this work with -gsplit-dwarf. 1610 unsigned PointerSize = Asm->getDataLayout().getPointerSize(); 1611 assert((PointerSize == 4 || PointerSize == 8) && 1612 "Add support for other sizes if necessary"); 1613 // Based on GCC's support for TLS: 1614 if (!DD->useSplitDwarf()) { 1615 // 1) Start with a constNu of the appropriate pointer size 1616 addUInt(*Loc, dwarf::DW_FORM_data1, 1617 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u); 1618 // 2) containing the (relocated) offset of the TLS variable 1619 // within the module's TLS block. 1620 addExpr(*Loc, dwarf::DW_FORM_udata, 1621 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym)); 1622 } else { 1623 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index); 1624 addUInt(*Loc, dwarf::DW_FORM_udata, 1625 DD->getAddressPool().getIndex(Sym, /* TLS */ true)); 1626 } 1627 // 3) followed by a custom OP to make the debugger do a TLS lookup. 1628 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address); 1629 } else { 1630 DD->addArangeLabel(SymbolCU(this, Sym)); 1631 addOpAddress(*Loc, Sym); 1632 } 1633 // Do not create specification DIE if context is either compile unit 1634 // or a subprogram. 1635 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() && 1636 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) { 1637 // Create specification DIE. 1638 VariableSpecDIE = &createAndAddDIE(dwarf::DW_TAG_variable, UnitDie); 1639 addDIEEntry(*VariableSpecDIE, dwarf::DW_AT_specification, *VariableDIE); 1640 addBlock(*VariableSpecDIE, dwarf::DW_AT_location, Loc); 1641 // A static member's declaration is already flagged as such. 1642 if (!SDMDecl.Verify()) 1643 addFlag(*VariableDIE, dwarf::DW_AT_declaration); 1644 } else { 1645 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc); 1646 } 1647 // Add the linkage name. 1648 StringRef LinkageName = GV.getLinkageName(); 1649 if (!LinkageName.empty()) 1650 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include: 1651 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and 1652 // TAG_variable. 1653 addString(IsStaticMember && VariableSpecDIE ? *VariableSpecDIE 1654 : *VariableDIE, 1655 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name 1656 : dwarf::DW_AT_MIPS_linkage_name, 1657 GlobalValue::getRealLinkageName(LinkageName)); 1658 } else if (const ConstantInt *CI = 1659 dyn_cast_or_null<ConstantInt>(GV.getConstant())) { 1660 // AT_const_value was added when the static member was created. To avoid 1661 // emitting AT_const_value multiple times, we only add AT_const_value when 1662 // it is not a static member. 1663 if (!IsStaticMember) 1664 addConstantValue(*VariableDIE, CI, GTy); 1665 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) { 1666 addToAccelTable = true; 1667 // GV is a merged global. 1668 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 1669 Value *Ptr = CE->getOperand(0); 1670 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr)); 1671 DD->addArangeLabel(SymbolCU(this, Sym)); 1672 addOpAddress(*Loc, Sym); 1673 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1674 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end()); 1675 addUInt(*Loc, dwarf::DW_FORM_udata, 1676 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx)); 1677 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1678 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc); 1679 } 1680 1681 if (addToAccelTable) { 1682 DIE &AddrDIE = VariableSpecDIE ? *VariableSpecDIE : *VariableDIE; 1683 DD->addAccelName(GV.getName(), AddrDIE); 1684 1685 // If the linkage name is different than the name, go ahead and output 1686 // that as well into the name table. 1687 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName()) 1688 DD->addAccelName(GV.getLinkageName(), AddrDIE); 1689 } 1690 1691 addGlobalName(GV.getName(), VariableSpecDIE ? *VariableSpecDIE : *VariableDIE, 1692 GV.getContext()); 1693 } 1694 1695 /// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1696 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) { 1697 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer); 1698 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy); 1699 1700 // The LowerBound value defines the lower bounds which is typically zero for 1701 // C/C++. The Count value is the number of elements. Values are 64 bit. If 1702 // Count == -1 then the array is unbounded and we do not emit 1703 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and 1704 // Count == 0, then the array has zero elements in which case we do not emit 1705 // an upper bound. 1706 int64_t LowerBound = SR.getLo(); 1707 int64_t DefaultLowerBound = getDefaultLowerBound(); 1708 int64_t Count = SR.getCount(); 1709 1710 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound) 1711 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound); 1712 1713 if (Count != -1 && Count != 0) 1714 // FIXME: An unbounded array should reference the expression that defines 1715 // the array. 1716 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None, 1717 LowerBound + Count - 1); 1718 } 1719 1720 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1721 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) { 1722 if (CTy.isVector()) 1723 addFlag(Buffer, dwarf::DW_AT_GNU_vector); 1724 1725 // Emit the element type. 1726 addType(Buffer, resolve(CTy.getTypeDerivedFrom())); 1727 1728 // Get an anonymous type for index type. 1729 // FIXME: This type should be passed down from the front end 1730 // as different languages may have different sizes for indexes. 1731 DIE *IdxTy = getIndexTyDie(); 1732 if (!IdxTy) { 1733 // Construct an integer type to use for indexes. 1734 IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie); 1735 addString(*IdxTy, dwarf::DW_AT_name, "sizetype"); 1736 addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t)); 1737 addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1738 dwarf::DW_ATE_unsigned); 1739 setIndexTyDie(IdxTy); 1740 } 1741 1742 // Add subranges to array type. 1743 DIArray Elements = CTy.getTypeArray(); 1744 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1745 DIDescriptor Element = Elements.getElement(i); 1746 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 1747 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy); 1748 } 1749 } 1750 1751 /// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType. 1752 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) { 1753 DIArray Elements = CTy.getTypeArray(); 1754 1755 // Add enumerators to enumeration type. 1756 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1757 DIEnumerator Enum(Elements.getElement(i)); 1758 if (Enum.isEnumerator()) { 1759 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer); 1760 StringRef Name = Enum.getName(); 1761 addString(Enumerator, dwarf::DW_AT_name, Name); 1762 int64_t Value = Enum.getEnumValue(); 1763 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, 1764 Value); 1765 } 1766 } 1767 DIType DTy = resolve(CTy.getTypeDerivedFrom()); 1768 if (DTy) { 1769 addType(Buffer, DTy); 1770 addFlag(Buffer, dwarf::DW_AT_enum_class); 1771 } 1772 } 1773 1774 /// constructContainingTypeDIEs - Construct DIEs for types that contain 1775 /// vtables. 1776 void DwarfUnit::constructContainingTypeDIEs() { 1777 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 1778 CE = ContainingTypeMap.end(); 1779 CI != CE; ++CI) { 1780 DIE &SPDie = *CI->first; 1781 DIDescriptor D(CI->second); 1782 if (!D) 1783 continue; 1784 DIE *NDie = getDIE(D); 1785 if (!NDie) 1786 continue; 1787 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie); 1788 } 1789 } 1790 1791 /// constructVariableDIE - Construct a DIE for the given DbgVariable. 1792 std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV, 1793 bool Abstract) { 1794 auto D = constructVariableDIEImpl(DV, Abstract); 1795 DV.setDIE(*D); 1796 return D; 1797 } 1798 1799 std::unique_ptr<DIE> DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV, 1800 bool Abstract) { 1801 // Define variable debug information entry. 1802 auto VariableDie = make_unique<DIE>(DV.getTag()); 1803 1804 if (Abstract) { 1805 applyVariableAttributes(DV, *VariableDie); 1806 return VariableDie; 1807 } 1808 1809 // Add variable address. 1810 1811 unsigned Offset = DV.getDotDebugLocOffset(); 1812 if (Offset != ~0U) { 1813 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset); 1814 return VariableDie; 1815 } 1816 1817 // Check if variable is described by a DBG_VALUE instruction. 1818 if (const MachineInstr *DVInsn = DV.getMInsn()) { 1819 assert(DVInsn->getNumOperands() == 3); 1820 if (DVInsn->getOperand(0).isReg()) { 1821 const MachineOperand RegOp = DVInsn->getOperand(0); 1822 // If the second operand is an immediate, this is an indirect value. 1823 if (DVInsn->getOperand(1).isImm()) { 1824 MachineLocation Location(RegOp.getReg(), 1825 DVInsn->getOperand(1).getImm()); 1826 addVariableAddress(DV, *VariableDie, Location); 1827 } else if (RegOp.getReg()) 1828 addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg())); 1829 } else if (DVInsn->getOperand(0).isImm()) 1830 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType()); 1831 else if (DVInsn->getOperand(0).isFPImm()) 1832 addConstantFPValue(*VariableDie, DVInsn->getOperand(0)); 1833 else if (DVInsn->getOperand(0).isCImm()) 1834 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(), 1835 DV.getType()); 1836 1837 return VariableDie; 1838 } 1839 1840 // .. else use frame index. 1841 int FI = DV.getFrameIndex(); 1842 if (FI != ~0) { 1843 unsigned FrameReg = 0; 1844 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering(); 1845 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg); 1846 MachineLocation Location(FrameReg, Offset); 1847 addVariableAddress(DV, *VariableDie, Location); 1848 } 1849 1850 return VariableDie; 1851 } 1852 1853 /// constructMemberDIE - Construct member DIE from DIDerivedType. 1854 void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) { 1855 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer); 1856 StringRef Name = DT.getName(); 1857 if (!Name.empty()) 1858 addString(MemberDie, dwarf::DW_AT_name, Name); 1859 1860 addType(MemberDie, resolve(DT.getTypeDerivedFrom())); 1861 1862 addSourceLine(MemberDie, DT); 1863 1864 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) { 1865 1866 // For C++, virtual base classes are not at fixed offset. Use following 1867 // expression to extract appropriate offset from vtable. 1868 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1869 1870 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc(); 1871 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1872 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1873 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1874 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 1875 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1876 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1877 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1878 1879 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie); 1880 } else { 1881 uint64_t Size = DT.getSizeInBits(); 1882 uint64_t FieldSize = getBaseTypeSize(DD, DT); 1883 uint64_t OffsetInBytes; 1884 1885 if (Size != FieldSize) { 1886 // Handle bitfield, assume bytes are 8 bits. 1887 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8); 1888 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size); 1889 1890 uint64_t Offset = DT.getOffsetInBits(); 1891 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 1892 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1893 uint64_t FieldOffset = (HiMark - FieldSize); 1894 Offset -= FieldOffset; 1895 1896 // Maybe we need to work from the other end. 1897 if (Asm->getDataLayout().isLittleEndian()) 1898 Offset = FieldSize - (Offset + Size); 1899 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset); 1900 1901 // Here DW_AT_data_member_location points to the anonymous 1902 // field that includes this bit field. 1903 OffsetInBytes = FieldOffset >> 3; 1904 } else 1905 // This is not a bitfield. 1906 OffsetInBytes = DT.getOffsetInBits() >> 3; 1907 1908 if (DD->getDwarfVersion() <= 2) { 1909 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc(); 1910 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1911 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes); 1912 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie); 1913 } else 1914 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, 1915 OffsetInBytes); 1916 } 1917 1918 if (DT.isProtected()) 1919 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1920 dwarf::DW_ACCESS_protected); 1921 else if (DT.isPrivate()) 1922 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1923 dwarf::DW_ACCESS_private); 1924 // Otherwise C++ member and base classes are considered public. 1925 else 1926 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1927 dwarf::DW_ACCESS_public); 1928 if (DT.isVirtual()) 1929 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, 1930 dwarf::DW_VIRTUALITY_virtual); 1931 1932 // Objective-C properties. 1933 if (MDNode *PNode = DT.getObjCProperty()) 1934 if (DIEEntry *PropertyDie = getDIEEntry(PNode)) 1935 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4, 1936 PropertyDie); 1937 1938 if (DT.isArtificial()) 1939 addFlag(MemberDie, dwarf::DW_AT_artificial); 1940 } 1941 1942 /// getOrCreateStaticMemberDIE - Create new DIE for C++ static member. 1943 DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) { 1944 if (!DT.Verify()) 1945 return nullptr; 1946 1947 // Construct the context before querying for the existence of the DIE in case 1948 // such construction creates the DIE. 1949 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext())); 1950 assert(dwarf::isType(ContextDIE->getTag()) && 1951 "Static member should belong to a type."); 1952 1953 if (DIE *StaticMemberDIE = getDIE(DT)) 1954 return StaticMemberDIE; 1955 1956 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT); 1957 1958 DIType Ty = resolve(DT.getTypeDerivedFrom()); 1959 1960 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName()); 1961 addType(StaticMemberDIE, Ty); 1962 addSourceLine(StaticMemberDIE, DT); 1963 addFlag(StaticMemberDIE, dwarf::DW_AT_external); 1964 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration); 1965 1966 // FIXME: We could omit private if the parent is a class_type, and 1967 // public if the parent is something else. 1968 if (DT.isProtected()) 1969 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1970 dwarf::DW_ACCESS_protected); 1971 else if (DT.isPrivate()) 1972 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1973 dwarf::DW_ACCESS_private); 1974 else 1975 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1976 dwarf::DW_ACCESS_public); 1977 1978 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant())) 1979 addConstantValue(StaticMemberDIE, CI, Ty); 1980 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant())) 1981 addConstantFPValue(StaticMemberDIE, CFP); 1982 1983 return &StaticMemberDIE; 1984 } 1985 1986 void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const { 1987 Asm->OutStreamer.AddComment("DWARF version number"); 1988 Asm->EmitInt16(DD->getDwarfVersion()); 1989 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 1990 // We share one abbreviations table across all units so it's always at the 1991 // start of the section. Use a relocatable offset where needed to ensure 1992 // linking doesn't invalidate that offset. 1993 if (ASectionSym) 1994 Asm->EmitSectionOffset(ASectionSym, ASectionSym); 1995 else 1996 // Use a constant value when no symbol is provided. 1997 Asm->EmitInt32(0); 1998 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 1999 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 2000 } 2001 2002 void DwarfUnit::addRange(RangeSpan Range) { 2003 // Only add a range for this unit if we're emitting full debug. 2004 if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) { 2005 // If we have no current ranges just add the range and return, otherwise, 2006 // check the current section and CU against the previous section and CU we 2007 // emitted into and the subprogram was contained within. If these are the 2008 // same then extend our current range, otherwise add this as a new range. 2009 if (CURanges.size() == 0 || 2010 this != DD->getPrevCU() || 2011 Asm->getCurrentSection() != DD->getPrevSection()) { 2012 CURanges.push_back(Range); 2013 return; 2014 } 2015 2016 assert(&(CURanges.back().getEnd()->getSection()) == 2017 &(Range.getEnd()->getSection()) && 2018 "We can only append to a range in the same section!"); 2019 CURanges.back().setEnd(Range.getEnd()); 2020 } 2021 } 2022 2023 void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) { 2024 // Define start line table label for each Compile Unit. 2025 MCSymbol *LineTableStartSym = 2026 Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID()); 2027 2028 stmtListIndex = UnitDie.getValues().size(); 2029 2030 // DW_AT_stmt_list is a offset of line number information for this 2031 // compile unit in debug_line section. For split dwarf this is 2032 // left in the skeleton CU and so not included. 2033 // The line table entries are not always emitted in assembly, so it 2034 // is not okay to use line_table_start here. 2035 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2036 addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym); 2037 else 2038 addSectionDelta(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym, 2039 DwarfLineSectionSym); 2040 } 2041 2042 void DwarfCompileUnit::applyStmtList(DIE &D) { 2043 D.addValue(dwarf::DW_AT_stmt_list, 2044 UnitDie.getAbbrev().getData()[stmtListIndex].getForm(), 2045 UnitDie.getValues()[stmtListIndex]); 2046 } 2047 2048 void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const { 2049 DwarfUnit::emitHeader(ASectionSym); 2050 Asm->OutStreamer.AddComment("Type Signature"); 2051 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature)); 2052 Asm->OutStreamer.AddComment("Type DIE Offset"); 2053 // In a skeleton type unit there is no type DIE so emit a zero offset. 2054 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0, 2055 sizeof(Ty->getOffset())); 2056 } 2057 2058 void DwarfTypeUnit::initSection(const MCSection *Section) { 2059 assert(!this->Section); 2060 this->Section = Section; 2061 // Since each type unit is contained in its own COMDAT section, the begin 2062 // label and the section label are the same. Using the begin label emission in 2063 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but 2064 // the only other alternative of lazily constructing start-of-section labels 2065 // and storing a mapping in DwarfDebug (or AsmPrinter). 2066 this->SectionSym = this->LabelBegin = 2067 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID()); 2068 this->LabelEnd = 2069 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID()); 2070 } 2071