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 "DwarfCompileUnit.h" 17#include "DwarfDebug.h" 18#include "DwarfExpression.h" 19#include "llvm/ADT/APFloat.h" 20#include "llvm/CodeGen/MachineFunction.h" 21#include "llvm/IR/Constants.h" 22#include "llvm/IR/DIBuilder.h" 23#include "llvm/IR/DataLayout.h" 24#include "llvm/IR/GlobalVariable.h" 25#include "llvm/IR/Instructions.h" 26#include "llvm/IR/Mangler.h" 27#include "llvm/MC/MCAsmInfo.h" 28#include "llvm/MC/MCContext.h" 29#include "llvm/MC/MCSection.h" 30#include "llvm/MC/MCStreamer.h" 31#include "llvm/Support/CommandLine.h" 32#include "llvm/Target/TargetFrameLowering.h" 33#include "llvm/Target/TargetLoweringObjectFile.h" 34#include "llvm/Target/TargetMachine.h" 35#include "llvm/Target/TargetRegisterInfo.h" 36#include "llvm/Target/TargetSubtargetInfo.h" 37 38using namespace llvm; 39 40#define DEBUG_TYPE "dwarfdebug" 41 42static cl::opt<bool> 43GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, 44 cl::desc("Generate DWARF4 type units."), 45 cl::init(false)); 46 47DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU, 48 DIELoc &DIE) 49 : DwarfExpression(*AP.MF->getSubtarget().getRegisterInfo(), 50 AP.getDwarfDebug()->getDwarfVersion()), 51 AP(AP), DU(DU), DIE(DIE) {} 52 53void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) { 54 DU.addUInt(DIE, dwarf::DW_FORM_data1, Op); 55} 56void DIEDwarfExpression::EmitSigned(int64_t Value) { 57 DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value); 58} 59void DIEDwarfExpression::EmitUnsigned(uint64_t Value) { 60 DU.addUInt(DIE, dwarf::DW_FORM_udata, Value); 61} 62bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) { 63 return MachineReg == TRI.getFrameRegister(*AP.MF); 64} 65 66 67/// Unit - Unit constructor. 68DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag, DICompileUnit Node, 69 AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU) 70 : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A), 71 DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) { 72 assert(UnitTag == dwarf::DW_TAG_compile_unit || 73 UnitTag == dwarf::DW_TAG_type_unit); 74 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1); 75} 76 77DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A, 78 DwarfDebug *DW, DwarfFile *DWU, 79 MCDwarfDwoLineTable *SplitLineTable) 80 : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), 81 CU(CU), SplitLineTable(SplitLineTable) { 82 if (SplitLineTable) 83 addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0); 84} 85 86/// ~Unit - Destructor for compile unit. 87DwarfUnit::~DwarfUnit() { 88 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 89 DIEBlocks[j]->~DIEBlock(); 90 for (unsigned j = 0, M = DIELocs.size(); j < M; ++j) 91 DIELocs[j]->~DIELoc(); 92} 93 94/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 95/// information entry. 96DIEEntry *DwarfUnit::createDIEEntry(DIE &Entry) { 97 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry); 98 return Value; 99} 100 101/// getDefaultLowerBound - Return the default lower bound for an array. If the 102/// DWARF version doesn't handle the language, return -1. 103int64_t DwarfUnit::getDefaultLowerBound() const { 104 switch (getLanguage()) { 105 default: 106 break; 107 108 case dwarf::DW_LANG_C89: 109 case dwarf::DW_LANG_C99: 110 case dwarf::DW_LANG_C: 111 case dwarf::DW_LANG_C_plus_plus: 112 case dwarf::DW_LANG_ObjC: 113 case dwarf::DW_LANG_ObjC_plus_plus: 114 return 0; 115 116 case dwarf::DW_LANG_Fortran77: 117 case dwarf::DW_LANG_Fortran90: 118 case dwarf::DW_LANG_Fortran95: 119 return 1; 120 121 // The languages below have valid values only if the DWARF version >= 4. 122 case dwarf::DW_LANG_Java: 123 case dwarf::DW_LANG_Python: 124 case dwarf::DW_LANG_UPC: 125 case dwarf::DW_LANG_D: 126 if (dwarf::DWARF_VERSION >= 4) 127 return 0; 128 break; 129 130 case dwarf::DW_LANG_Ada83: 131 case dwarf::DW_LANG_Ada95: 132 case dwarf::DW_LANG_Cobol74: 133 case dwarf::DW_LANG_Cobol85: 134 case dwarf::DW_LANG_Modula2: 135 case dwarf::DW_LANG_Pascal83: 136 case dwarf::DW_LANG_PLI: 137 if (dwarf::DWARF_VERSION >= 4) 138 return 1; 139 break; 140 141 // The languages below have valid values only if the DWARF version >= 5. 142 case dwarf::DW_LANG_OpenCL: 143 case dwarf::DW_LANG_Go: 144 case dwarf::DW_LANG_Haskell: 145 case dwarf::DW_LANG_C_plus_plus_03: 146 case dwarf::DW_LANG_C_plus_plus_11: 147 case dwarf::DW_LANG_OCaml: 148 case dwarf::DW_LANG_Rust: 149 case dwarf::DW_LANG_C11: 150 case dwarf::DW_LANG_Swift: 151 case dwarf::DW_LANG_Dylan: 152 case dwarf::DW_LANG_C_plus_plus_14: 153 if (dwarf::DWARF_VERSION >= 5) 154 return 0; 155 break; 156 157 case dwarf::DW_LANG_Modula3: 158 case dwarf::DW_LANG_Julia: 159 case dwarf::DW_LANG_Fortran03: 160 case dwarf::DW_LANG_Fortran08: 161 if (dwarf::DWARF_VERSION >= 5) 162 return 1; 163 break; 164 } 165 166 return -1; 167} 168 169/// Check whether the DIE for this MDNode can be shared across CUs. 170static bool isShareableAcrossCUs(DIDescriptor D) { 171 // When the MDNode can be part of the type system, the DIE can be shared 172 // across CUs. 173 // Combining type units and cross-CU DIE sharing is lower value (since 174 // cross-CU DIE sharing is used in LTO and removes type redundancy at that 175 // level already) but may be implementable for some value in projects 176 // building multiple independent libraries with LTO and then linking those 177 // together. 178 return (isa<MDType>(D) || 179 (isa<MDSubprogram>(D) && !cast<MDSubprogram>(D)->isDefinition())) && 180 !GenerateDwarfTypeUnits; 181} 182 183/// getDIE - Returns the debug information entry map slot for the 184/// specified debug variable. We delegate the request to DwarfDebug 185/// when the DIE for this MDNode can be shared across CUs. The mappings 186/// will be kept in DwarfDebug for shareable DIEs. 187DIE *DwarfUnit::getDIE(DIDescriptor D) const { 188 if (isShareableAcrossCUs(D)) 189 return DU->getDIE(D); 190 return MDNodeToDieMap.lookup(D); 191} 192 193/// insertDIE - Insert DIE into the map. We delegate the request to DwarfDebug 194/// when the DIE for this MDNode can be shared across CUs. The mappings 195/// will be kept in DwarfDebug for shareable DIEs. 196void DwarfUnit::insertDIE(DIDescriptor Desc, DIE *D) { 197 if (isShareableAcrossCUs(Desc)) { 198 DU->insertDIE(Desc, D); 199 return; 200 } 201 MDNodeToDieMap.insert(std::make_pair(Desc, D)); 202} 203 204/// addFlag - Add a flag that is true. 205void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) { 206 if (DD->getDwarfVersion() >= 4) 207 Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEIntegerOne); 208 else 209 Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEIntegerOne); 210} 211 212/// addUInt - Add an unsigned integer attribute data and value. 213/// 214void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute, 215 Optional<dwarf::Form> Form, uint64_t Integer) { 216 if (!Form) 217 Form = DIEInteger::BestForm(false, Integer); 218 DIEValue *Value = Integer == 1 ? DIEIntegerOne : new (DIEValueAllocator) 219 DIEInteger(Integer); 220 Die.addValue(Attribute, *Form, Value); 221} 222 223void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) { 224 addUInt(Block, (dwarf::Attribute)0, Form, Integer); 225} 226 227/// addSInt - Add an signed integer attribute data and value. 228/// 229void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute, 230 Optional<dwarf::Form> Form, int64_t Integer) { 231 if (!Form) 232 Form = DIEInteger::BestForm(true, Integer); 233 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 234 Die.addValue(Attribute, *Form, Value); 235} 236 237void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form, 238 int64_t Integer) { 239 addSInt(Die, (dwarf::Attribute)0, Form, Integer); 240} 241 242/// addString - Add a string attribute data and value. We always emit a 243/// reference to the string pool instead of immediate strings so that DIEs have 244/// more predictable sizes. In the case of split dwarf we emit an index 245/// into another table which gets us the static offset into the string 246/// table. 247void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute, 248 StringRef String) { 249 if (!isDwoUnit()) 250 return addLocalString(Die, Attribute, String); 251 252 addIndexedString(Die, Attribute, String); 253} 254 255void DwarfUnit::addIndexedString(DIE &Die, dwarf::Attribute Attribute, 256 StringRef String) { 257 unsigned idx = DU->getStringPool().getIndex(*Asm, String); 258 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx); 259 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String); 260 Die.addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Str); 261} 262 263/// addLocalString - Add a string attribute data and value. This is guaranteed 264/// to be in the local string pool instead of indirected. 265void DwarfUnit::addLocalString(DIE &Die, dwarf::Attribute Attribute, 266 StringRef String) { 267 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 268 MCSymbol *Symb = DU->getStringPool().getSymbol(*Asm, String); 269 DIEValue *Value; 270 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 271 Value = new (DIEValueAllocator) DIELabel(Symb); 272 else 273 Value = new (DIEValueAllocator) 274 DIEDelta(Symb, TLOF.getDwarfStrSection()->getBeginSymbol()); 275 DIEValue *Str = new (DIEValueAllocator) DIEString(Value, String); 276 Die.addValue(Attribute, dwarf::DW_FORM_strp, Str); 277} 278 279/// addLabel - Add a Dwarf label attribute data and value. 280/// 281void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form, 282 const MCSymbol *Label) { 283 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 284 Die.addValue(Attribute, Form, Value); 285} 286 287void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) { 288 addLabel(Die, (dwarf::Attribute)0, Form, Label); 289} 290 291/// addSectionOffset - Add an offset into a section attribute data and value. 292/// 293void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute, 294 uint64_t Integer) { 295 if (DD->getDwarfVersion() >= 4) 296 addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer); 297 else 298 addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer); 299} 300 301unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) { 302 return SplitLineTable ? SplitLineTable->getFile(DirName, FileName) 303 : getCU().getOrCreateSourceID(FileName, DirName); 304} 305 306/// addOpAddress - Add a dwarf op address data and value using the 307/// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index. 308/// 309void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) { 310 if (!DD->useSplitDwarf()) { 311 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 312 addLabel(Die, dwarf::DW_FORM_udata, Sym); 313 } else { 314 addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index); 315 addUInt(Die, dwarf::DW_FORM_GNU_addr_index, 316 DD->getAddressPool().getIndex(Sym)); 317 } 318} 319 320void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute, 321 const MCSymbol *Hi, const MCSymbol *Lo) { 322 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 323 Die.addValue(Attribute, dwarf::DW_FORM_data4, Value); 324} 325 326/// addDIEEntry - Add a DIE attribute data and value. 327/// 328void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) { 329 addDIEEntry(Die, Attribute, createDIEEntry(Entry)); 330} 331 332void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) { 333 // Flag the type unit reference as a declaration so that if it contains 334 // members (implicit special members, static data member definitions, member 335 // declarations for definitions in this CU, etc) consumers don't get confused 336 // and think this is a full definition. 337 addFlag(Die, dwarf::DW_AT_declaration); 338 339 Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8, 340 new (DIEValueAllocator) DIETypeSignature(Type)); 341} 342 343void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, 344 DIEEntry *Entry) { 345 const DIE *DieCU = Die.getUnitOrNull(); 346 const DIE *EntryCU = Entry->getEntry().getUnitOrNull(); 347 if (!DieCU) 348 // We assume that Die belongs to this CU, if it is not linked to any CU yet. 349 DieCU = &getUnitDie(); 350 if (!EntryCU) 351 EntryCU = &getUnitDie(); 352 Die.addValue(Attribute, 353 EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr, 354 Entry); 355} 356 357/// Create a DIE with the given Tag, add the DIE to its parent, and 358/// call insertDIE if MD is not null. 359DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, DIDescriptor N) { 360 assert(Tag != dwarf::DW_TAG_auto_variable && 361 Tag != dwarf::DW_TAG_arg_variable); 362 Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag)); 363 DIE &Die = *Parent.getChildren().back(); 364 if (N) 365 insertDIE(N, &Die); 366 return Die; 367} 368 369/// addBlock - Add block data. 370/// 371void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) { 372 Loc->ComputeSize(Asm); 373 DIELocs.push_back(Loc); // Memoize so we can call the destructor later on. 374 Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc); 375} 376 377void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, 378 DIEBlock *Block) { 379 Block->ComputeSize(Asm); 380 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 381 Die.addValue(Attribute, Block->BestForm(), Block); 382} 383 384/// addSourceLine - Add location information to specified debug information 385/// entry. 386void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File, 387 StringRef Directory) { 388 if (Line == 0) 389 return; 390 391 unsigned FileID = getOrCreateSourceID(File, Directory); 392 assert(FileID && "Invalid file id"); 393 addUInt(Die, dwarf::DW_AT_decl_file, None, FileID); 394 addUInt(Die, dwarf::DW_AT_decl_line, None, Line); 395} 396 397/// addSourceLine - Add location information to specified debug information 398/// entry. 399void DwarfUnit::addSourceLine(DIE &Die, DIVariable V) { 400 assert(V); 401 402 addSourceLine(Die, V->getLine(), V->getScope()->getFilename(), 403 V->getScope()->getDirectory()); 404} 405 406/// addSourceLine - Add location information to specified debug information 407/// entry. 408void DwarfUnit::addSourceLine(DIE &Die, DIGlobalVariable G) { 409 assert(G); 410 411 addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory()); 412} 413 414/// addSourceLine - Add location information to specified debug information 415/// entry. 416void DwarfUnit::addSourceLine(DIE &Die, DISubprogram SP) { 417 assert(SP); 418 419 addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory()); 420} 421 422/// addSourceLine - Add location information to specified debug information 423/// entry. 424void DwarfUnit::addSourceLine(DIE &Die, DIType Ty) { 425 assert(Ty); 426 427 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory()); 428} 429 430/// addSourceLine - Add location information to specified debug information 431/// entry. 432void DwarfUnit::addSourceLine(DIE &Die, DIObjCProperty Ty) { 433 assert(Ty); 434 435 addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory()); 436} 437 438/// addSourceLine - Add location information to specified debug information 439/// entry. 440void DwarfUnit::addSourceLine(DIE &Die, DINameSpace NS) { 441 addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory()); 442} 443 444/// addRegisterOp - Add register operand. 445bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg, 446 unsigned SizeInBits, unsigned OffsetInBits) { 447 DIEDwarfExpression Expr(*Asm, *this, TheDie); 448 Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits); 449 return true; 450} 451 452/// addRegisterOffset - Add register offset. 453bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg, 454 int64_t Offset) { 455 DIEDwarfExpression Expr(*Asm, *this, TheDie); 456 return Expr.AddMachineRegIndirect(Reg, Offset); 457} 458 459/* Byref variables, in Blocks, are declared by the programmer as "SomeType 460 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and 461 gives the variable VarName either the struct, or a pointer to the struct, as 462 its type. This is necessary for various behind-the-scenes things the 463 compiler needs to do with by-reference variables in Blocks. 464 465 However, as far as the original *programmer* is concerned, the variable 466 should still have type 'SomeType', as originally declared. 467 468 The function getBlockByrefType dives into the __Block_byref_x_VarName 469 struct to find the original type of the variable, which is then assigned to 470 the variable's Debug Information Entry as its real type. So far, so good. 471 However now the debugger will expect the variable VarName to have the type 472 SomeType. So we need the location attribute for the variable to be an 473 expression that explains to the debugger how to navigate through the 474 pointers and struct to find the actual variable of type SomeType. 475 476 The following function does just that. We start by getting 477 the "normal" location for the variable. This will be the location 478 of either the struct __Block_byref_x_VarName or the pointer to the 479 struct __Block_byref_x_VarName. 480 481 The struct will look something like: 482 483 struct __Block_byref_x_VarName { 484 ... <various fields> 485 struct __Block_byref_x_VarName *forwarding; 486 ... <various other fields> 487 SomeType VarName; 488 ... <maybe more fields> 489 }; 490 491 If we are given the struct directly (as our starting point) we 492 need to tell the debugger to: 493 494 1). Add the offset of the forwarding field. 495 496 2). Follow that pointer to get the real __Block_byref_x_VarName 497 struct to use (the real one may have been copied onto the heap). 498 499 3). Add the offset for the field VarName, to find the actual variable. 500 501 If we started with a pointer to the struct, then we need to 502 dereference that pointer first, before the other steps. 503 Translating this into DWARF ops, we will need to append the following 504 to the current location description for the variable: 505 506 DW_OP_deref -- optional, if we start with a pointer 507 DW_OP_plus_uconst <forward_fld_offset> 508 DW_OP_deref 509 DW_OP_plus_uconst <varName_fld_offset> 510 511 That is what this function does. */ 512 513/// addBlockByrefAddress - Start with the address based on the location 514/// provided, and generate the DWARF information necessary to find the 515/// actual Block variable (navigating the Block struct) based on the 516/// starting location. Add the DWARF information to the die. For 517/// more information, read large comment just above here. 518/// 519void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die, 520 dwarf::Attribute Attribute, 521 const MachineLocation &Location) { 522 DIType Ty = DV.getType(); 523 DIType TmpTy = Ty; 524 uint16_t Tag = Ty->getTag(); 525 bool isPointer = false; 526 527 StringRef varName = DV.getName(); 528 529 if (Tag == dwarf::DW_TAG_pointer_type) { 530 DIDerivedType DTy = cast<MDDerivedType>(Ty); 531 TmpTy = resolve(DTy->getBaseType()); 532 isPointer = true; 533 } 534 535 // Find the __forwarding field and the variable field in the __Block_byref 536 // struct. 537 DIArray Fields = cast<MDCompositeTypeBase>(TmpTy)->getElements(); 538 DIDerivedType varField; 539 DIDerivedType forwardingField; 540 541 for (unsigned i = 0, N = Fields.size(); i < N; ++i) { 542 DIDerivedType DT = cast<MDDerivedTypeBase>(Fields[i]); 543 StringRef fieldName = DT->getName(); 544 if (fieldName == "__forwarding") 545 forwardingField = DT; 546 else if (fieldName == varName) 547 varField = DT; 548 } 549 550 // Get the offsets for the forwarding field and the variable field. 551 unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3; 552 unsigned varFieldOffset = varField->getOffsetInBits() >> 2; 553 554 // Decode the original location, and use that as the start of the byref 555 // variable's location. 556 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 557 558 bool validReg; 559 if (Location.isReg()) 560 validReg = addRegisterOpPiece(*Loc, Location.getReg()); 561 else 562 validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset()); 563 564 if (!validReg) 565 return; 566 567 // If we started with a pointer to the __Block_byref... struct, then 568 // the first thing we need to do is dereference the pointer (DW_OP_deref). 569 if (isPointer) 570 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 571 572 // Next add the offset for the '__forwarding' field: 573 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in 574 // adding the offset if it's 0. 575 if (forwardingFieldOffset > 0) { 576 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 577 addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset); 578 } 579 580 // Now dereference the __forwarding field to get to the real __Block_byref 581 // struct: DW_OP_deref. 582 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 583 584 // Now that we've got the real __Block_byref... struct, add the offset 585 // for the variable's field to get to the location of the actual variable: 586 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0. 587 if (varFieldOffset > 0) { 588 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 589 addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset); 590 } 591 592 // Now attach the location information to the DIE. 593 addBlock(Die, Attribute, Loc); 594} 595 596/// Return true if type encoding is unsigned. 597static bool isUnsignedDIType(DwarfDebug *DD, DIType Ty) { 598 if (DIDerivedType DTy = dyn_cast<MDDerivedTypeBase>(Ty)) { 599 dwarf::Tag T = (dwarf::Tag)Ty->getTag(); 600 // Encode pointer constants as unsigned bytes. This is used at least for 601 // null pointer constant emission. 602 // (Pieces of) aggregate types that get hacked apart by SROA may also be 603 // represented by a constant. Encode them as unsigned bytes. 604 // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed 605 // here, but accept them for now due to a bug in SROA producing bogus 606 // dbg.values. 607 if (T == dwarf::DW_TAG_array_type || 608 T == dwarf::DW_TAG_class_type || 609 T == dwarf::DW_TAG_pointer_type || 610 T == dwarf::DW_TAG_ptr_to_member_type || 611 T == dwarf::DW_TAG_reference_type || 612 T == dwarf::DW_TAG_rvalue_reference_type || 613 T == dwarf::DW_TAG_structure_type || 614 T == dwarf::DW_TAG_union_type) 615 return true; 616 assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type || 617 T == dwarf::DW_TAG_volatile_type || 618 T == dwarf::DW_TAG_restrict_type || 619 T == dwarf::DW_TAG_enumeration_type); 620 if (DITypeRef Deriv = DTy->getBaseType()) 621 return isUnsignedDIType(DD, DD->resolve(Deriv)); 622 // FIXME: Enums without a fixed underlying type have unknown signedness 623 // here, leading to incorrectly emitted constants. 624 assert(DTy->getTag() == dwarf::DW_TAG_enumeration_type); 625 return false; 626 } 627 628 DIBasicType BTy = cast<MDBasicType>(Ty); 629 unsigned Encoding = BTy->getEncoding(); 630 assert((Encoding == dwarf::DW_ATE_unsigned || 631 Encoding == dwarf::DW_ATE_unsigned_char || 632 Encoding == dwarf::DW_ATE_signed || 633 Encoding == dwarf::DW_ATE_signed_char || 634 Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF || 635 Encoding == dwarf::DW_ATE_boolean || 636 (Ty->getTag() == dwarf::DW_TAG_unspecified_type && 637 Ty->getName() == "decltype(nullptr)")) && 638 "Unsupported encoding"); 639 return Encoding == dwarf::DW_ATE_unsigned || 640 Encoding == dwarf::DW_ATE_unsigned_char || 641 Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean || 642 Ty->getTag() == dwarf::DW_TAG_unspecified_type; 643} 644 645/// If this type is derived from a base type then return base type size. 646static uint64_t getBaseTypeSize(DwarfDebug *DD, DIDerivedType Ty) { 647 unsigned Tag = Ty->getTag(); 648 649 if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && 650 Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && 651 Tag != dwarf::DW_TAG_restrict_type) 652 return Ty->getSizeInBits(); 653 654 auto *BaseType = DD->resolve(Ty->getBaseType()); 655 656 assert(BaseType && "Unexpected invalid base type"); 657 658 // If this is a derived type, go ahead and get the base type, unless it's a 659 // reference then it's just the size of the field. Pointer types have no need 660 // of this since they're a different type of qualification on the type. 661 if (BaseType->getTag() == dwarf::DW_TAG_reference_type || 662 BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type) 663 return Ty->getSizeInBits(); 664 665 if (auto *DT = dyn_cast<MDDerivedTypeBase>(BaseType)) 666 return getBaseTypeSize(DD, DT); 667 668 return BaseType->getSizeInBits(); 669} 670 671/// addConstantFPValue - Add constant value entry in variable DIE. 672void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) { 673 assert(MO.isFPImm() && "Invalid machine operand!"); 674 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 675 APFloat FPImm = MO.getFPImm()->getValueAPF(); 676 677 // Get the raw data form of the floating point. 678 const APInt FltVal = FPImm.bitcastToAPInt(); 679 const char *FltPtr = (const char *)FltVal.getRawData(); 680 681 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte. 682 bool LittleEndian = Asm->getDataLayout().isLittleEndian(); 683 int Incr = (LittleEndian ? 1 : -1); 684 int Start = (LittleEndian ? 0 : NumBytes - 1); 685 int Stop = (LittleEndian ? NumBytes : -1); 686 687 // Output the constant to DWARF one byte at a time. 688 for (; Start != Stop; Start += Incr) 689 addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]); 690 691 addBlock(Die, dwarf::DW_AT_const_value, Block); 692} 693 694/// addConstantFPValue - Add constant value entry in variable DIE. 695void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) { 696 // Pass this down to addConstantValue as an unsigned bag of bits. 697 addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true); 698} 699 700/// addConstantValue - Add constant value entry in variable DIE. 701void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI, DIType Ty) { 702 addConstantValue(Die, CI->getValue(), Ty); 703} 704 705/// addConstantValue - Add constant value entry in variable DIE. 706void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO, 707 DIType Ty) { 708 assert(MO.isImm() && "Invalid machine operand!"); 709 710 addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm()); 711} 712 713void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) { 714 // FIXME: This is a bit conservative/simple - it emits negative values always 715 // sign extended to 64 bits rather than minimizing the number of bytes. 716 addUInt(Die, dwarf::DW_AT_const_value, 717 Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val); 718} 719 720void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, DIType Ty) { 721 addConstantValue(Die, Val, isUnsignedDIType(DD, Ty)); 722} 723 724// addConstantValue - Add constant value entry in variable DIE. 725void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) { 726 unsigned CIBitWidth = Val.getBitWidth(); 727 if (CIBitWidth <= 64) { 728 addConstantValue(Die, Unsigned, 729 Unsigned ? Val.getZExtValue() : Val.getSExtValue()); 730 return; 731 } 732 733 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 734 735 // Get the raw data form of the large APInt. 736 const uint64_t *Ptr64 = Val.getRawData(); 737 738 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte. 739 bool LittleEndian = Asm->getDataLayout().isLittleEndian(); 740 741 // Output the constant to DWARF one byte at a time. 742 for (int i = 0; i < NumBytes; i++) { 743 uint8_t c; 744 if (LittleEndian) 745 c = Ptr64[i / 8] >> (8 * (i & 7)); 746 else 747 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7)); 748 addUInt(*Block, dwarf::DW_FORM_data1, c); 749 } 750 751 addBlock(Die, dwarf::DW_AT_const_value, Block); 752} 753 754// Add a linkage name to the DIE. 755void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) { 756 if (!LinkageName.empty()) 757 addString(Die, 758 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name 759 : dwarf::DW_AT_MIPS_linkage_name, 760 GlobalValue::getRealLinkageName(LinkageName)); 761} 762 763/// addTemplateParams - Add template parameters into buffer. 764void DwarfUnit::addTemplateParams(DIE &Buffer, DIArray TParams) { 765 // Add template parameters. 766 for (unsigned i = 0, e = TParams.size(); i != e; ++i) { 767 DIDescriptor Element = TParams[i]; 768 if (auto *TTP = dyn_cast<MDTemplateTypeParameter>(Element)) 769 constructTemplateTypeParameterDIE(Buffer, TTP); 770 else if (auto *TVP = dyn_cast<MDTemplateValueParameter>(Element)) 771 constructTemplateValueParameterDIE(Buffer, TVP); 772 } 773} 774 775/// getOrCreateContextDIE - Get context owner's DIE. 776DIE *DwarfUnit::getOrCreateContextDIE(DIScope Context) { 777 if (!Context || isa<MDFile>(Context)) 778 return &getUnitDie(); 779 if (auto *T = dyn_cast<MDType>(Context)) 780 return getOrCreateTypeDIE(T); 781 if (auto *NS = dyn_cast<MDNamespace>(Context)) 782 return getOrCreateNameSpace(NS); 783 if (auto *SP = dyn_cast<MDSubprogram>(Context)) 784 return getOrCreateSubprogramDIE(SP); 785 return getDIE(Context); 786} 787 788DIE *DwarfUnit::createTypeDIE(DICompositeType Ty) { 789 DIScope Context = resolve(Ty->getScope()); 790 DIE *ContextDIE = getOrCreateContextDIE(Context); 791 792 if (DIE *TyDIE = getDIE(Ty)) 793 return TyDIE; 794 795 // Create new type. 796 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty); 797 798 constructTypeDIE(TyDIE, Ty); 799 800 updateAcceleratorTables(Context, Ty, TyDIE); 801 return &TyDIE; 802} 803 804/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 805/// given DIType. 806DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) { 807 if (!TyNode) 808 return nullptr; 809 810 auto *Ty = cast<MDType>(TyNode); 811 assert(Ty == resolve(Ty->getRef()) && 812 "type was not uniqued, possible ODR violation."); 813 814 // DW_TAG_restrict_type is not supported in DWARF2 815 if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2) 816 return getOrCreateTypeDIE( 817 resolve(DITypeRef(cast<MDDerivedType>(Ty)->getBaseType()))); 818 819 // Construct the context before querying for the existence of the DIE in case 820 // such construction creates the DIE. 821 DIScope Context = resolve(Ty->getScope()); 822 DIE *ContextDIE = getOrCreateContextDIE(Context); 823 assert(ContextDIE); 824 825 if (DIE *TyDIE = getDIE(Ty)) 826 return TyDIE; 827 828 // Create new type. 829 DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty); 830 831 updateAcceleratorTables(Context, Ty, TyDIE); 832 833 if (auto *BT = dyn_cast<MDBasicType>(Ty)) 834 constructTypeDIE(TyDIE, BT); 835 else if (DICompositeType CTy = dyn_cast<MDCompositeTypeBase>(Ty)) { 836 if (GenerateDwarfTypeUnits && !Ty->isForwardDecl()) 837 if (MDString *TypeId = CTy->getRawIdentifier()) { 838 DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy); 839 // Skip updating the accelerator tables since this is not the full type. 840 return &TyDIE; 841 } 842 constructTypeDIE(TyDIE, CTy); 843 } else { 844 constructTypeDIE(TyDIE, cast<MDDerivedType>(Ty)); 845 } 846 847 return &TyDIE; 848} 849 850void DwarfUnit::updateAcceleratorTables(DIScope Context, DIType Ty, 851 const DIE &TyDIE) { 852 if (!Ty->getName().empty() && !Ty->isForwardDecl()) { 853 bool IsImplementation = 0; 854 if (auto *CT = dyn_cast<MDCompositeTypeBase>(Ty)) { 855 // A runtime language of 0 actually means C/C++ and that any 856 // non-negative value is some version of Objective-C/C++. 857 IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete(); 858 } 859 unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0; 860 DD->addAccelType(Ty->getName(), TyDIE, Flags); 861 862 if (!Context || isa<MDCompileUnit>(Context) || isa<MDFile>(Context) || 863 isa<MDNamespace>(Context)) 864 addGlobalType(Ty, TyDIE, Context); 865 } 866} 867 868/// addType - Add a new type attribute to the specified entity. 869void DwarfUnit::addType(DIE &Entity, DIType Ty, dwarf::Attribute Attribute) { 870 assert(Ty && "Trying to add a type that doesn't exist?"); 871 872 // Check for pre-existence. 873 DIEEntry *Entry = getDIEEntry(Ty); 874 // If it exists then use the existing value. 875 if (Entry) { 876 addDIEEntry(Entity, Attribute, Entry); 877 return; 878 } 879 880 // Construct type. 881 DIE *Buffer = getOrCreateTypeDIE(Ty); 882 883 // Set up proxy. 884 Entry = createDIEEntry(*Buffer); 885 insertDIEEntry(Ty, Entry); 886 addDIEEntry(Entity, Attribute, Entry); 887} 888 889/// getParentContextString - Walks the metadata parent chain in a language 890/// specific manner (using the compile unit language) and returns 891/// it as a string. This is done at the metadata level because DIEs may 892/// not currently have been added to the parent context and walking the 893/// DIEs looking for names is more expensive than walking the metadata. 894std::string DwarfUnit::getParentContextString(DIScope Context) const { 895 if (!Context) 896 return ""; 897 898 // FIXME: Decide whether to implement this for non-C++ languages. 899 if (getLanguage() != dwarf::DW_LANG_C_plus_plus) 900 return ""; 901 902 std::string CS; 903 SmallVector<DIScope, 1> Parents; 904 while (!isa<MDCompileUnit>(Context)) { 905 Parents.push_back(Context); 906 if (Context->getScope()) 907 Context = resolve(Context->getScope()); 908 else 909 // Structure, etc types will have a NULL context if they're at the top 910 // level. 911 break; 912 } 913 914 // Reverse iterate over our list to go from the outermost construct to the 915 // innermost. 916 for (SmallVectorImpl<DIScope>::reverse_iterator I = Parents.rbegin(), 917 E = Parents.rend(); 918 I != E; ++I) { 919 const MDScope *Ctx = *I; 920 StringRef Name = Ctx->getName(); 921 if (Name.empty() && isa<MDNamespace>(Ctx)) 922 Name = "(anonymous namespace)"; 923 if (!Name.empty()) { 924 CS += Name; 925 CS += "::"; 926 } 927 } 928 return CS; 929} 930 931/// constructTypeDIE - Construct basic type die from DIBasicType. 932void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 933 // Get core information. 934 StringRef Name = BTy->getName(); 935 // Add name if not anonymous or intermediate type. 936 if (!Name.empty()) 937 addString(Buffer, dwarf::DW_AT_name, Name); 938 939 // An unspecified type only has a name attribute. 940 if (BTy->getTag() == dwarf::DW_TAG_unspecified_type) 941 return; 942 943 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 944 BTy->getEncoding()); 945 946 uint64_t Size = BTy->getSizeInBits() >> 3; 947 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 948} 949 950/// constructTypeDIE - Construct derived type die from DIDerivedType. 951void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 952 // Get core information. 953 StringRef Name = DTy->getName(); 954 uint64_t Size = DTy->getSizeInBits() >> 3; 955 uint16_t Tag = Buffer.getTag(); 956 957 // Map to main type, void will not have a type. 958 DIType FromTy = resolve(DTy->getBaseType()); 959 if (FromTy) 960 addType(Buffer, FromTy); 961 962 // Add name if not anonymous or intermediate type. 963 if (!Name.empty()) 964 addString(Buffer, dwarf::DW_AT_name, Name); 965 966 // Add size if non-zero (derived types might be zero-sized.) 967 if (Size && Tag != dwarf::DW_TAG_pointer_type 968 && Tag != dwarf::DW_TAG_ptr_to_member_type) 969 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 970 971 if (Tag == dwarf::DW_TAG_ptr_to_member_type) 972 addDIEEntry( 973 Buffer, dwarf::DW_AT_containing_type, 974 *getOrCreateTypeDIE(resolve(cast<MDDerivedType>(DTy)->getClassType()))); 975 // Add source line info if available and TyDesc is not a forward declaration. 976 if (!DTy->isForwardDecl()) 977 addSourceLine(Buffer, DTy); 978} 979 980/// constructSubprogramArguments - Construct function argument DIEs. 981void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeArray Args) { 982 for (unsigned i = 1, N = Args.size(); i < N; ++i) { 983 DIType Ty = resolve(Args[i]); 984 if (!Ty) { 985 assert(i == N-1 && "Unspecified parameter must be the last argument"); 986 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer); 987 } else { 988 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer); 989 addType(Arg, Ty); 990 if (Ty->isArtificial()) 991 addFlag(Arg, dwarf::DW_AT_artificial); 992 } 993 } 994} 995 996/// constructTypeDIE - Construct type DIE from DICompositeType. 997void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 998 // Add name if not anonymous or intermediate type. 999 StringRef Name = CTy->getName(); 1000 1001 uint64_t Size = CTy->getSizeInBits() >> 3; 1002 uint16_t Tag = Buffer.getTag(); 1003 1004 switch (Tag) { 1005 case dwarf::DW_TAG_array_type: 1006 constructArrayTypeDIE(Buffer, CTy); 1007 break; 1008 case dwarf::DW_TAG_enumeration_type: 1009 constructEnumTypeDIE(Buffer, CTy); 1010 break; 1011 case dwarf::DW_TAG_subroutine_type: { 1012 // Add return type. A void return won't have a type. 1013 auto Elements = cast<MDSubroutineType>(CTy)->getTypeArray(); 1014 if (Elements.size()) 1015 if (auto RTy = resolve(Elements[0])) 1016 addType(Buffer, RTy); 1017 1018 bool isPrototyped = true; 1019 if (Elements.size() == 2 && !Elements[1]) 1020 isPrototyped = false; 1021 1022 constructSubprogramArguments(Buffer, Elements); 1023 1024 // Add prototype flag if we're dealing with a C language and the 1025 // function has been prototyped. 1026 uint16_t Language = getLanguage(); 1027 if (isPrototyped && 1028 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 1029 Language == dwarf::DW_LANG_ObjC)) 1030 addFlag(Buffer, dwarf::DW_AT_prototyped); 1031 1032 if (CTy->isLValueReference()) 1033 addFlag(Buffer, dwarf::DW_AT_reference); 1034 1035 if (CTy->isRValueReference()) 1036 addFlag(Buffer, dwarf::DW_AT_rvalue_reference); 1037 } break; 1038 case dwarf::DW_TAG_structure_type: 1039 case dwarf::DW_TAG_union_type: 1040 case dwarf::DW_TAG_class_type: { 1041 // Add elements to structure type. 1042 DIArray Elements = CTy->getElements(); 1043 for (unsigned i = 0, N = Elements.size(); i < N; ++i) { 1044 DIDescriptor Element = Elements[i]; 1045 if (!Element) 1046 continue; 1047 if (auto *SP = dyn_cast<MDSubprogram>(Element)) 1048 getOrCreateSubprogramDIE(SP); 1049 else if (DIDerivedType DDTy = dyn_cast<MDDerivedTypeBase>(Element)) { 1050 if (DDTy->getTag() == dwarf::DW_TAG_friend) { 1051 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer); 1052 addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend); 1053 } else if (DDTy->isStaticMember()) { 1054 getOrCreateStaticMemberDIE(DDTy); 1055 } else { 1056 constructMemberDIE(Buffer, DDTy); 1057 } 1058 } else if (DIObjCProperty Property = dyn_cast<MDObjCProperty>(Element)) { 1059 DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer); 1060 StringRef PropertyName = Property->getName(); 1061 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName); 1062 if (Property->getType()) 1063 addType(ElemDie, Property->getType()); 1064 addSourceLine(ElemDie, Property); 1065 StringRef GetterName = Property->getGetterName(); 1066 if (!GetterName.empty()) 1067 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName); 1068 StringRef SetterName = Property->getSetterName(); 1069 if (!SetterName.empty()) 1070 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName); 1071 if (unsigned PropertyAttributes = Property->getAttributes()) 1072 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None, 1073 PropertyAttributes); 1074 1075 DIEEntry *Entry = getDIEEntry(Element); 1076 if (!Entry) { 1077 Entry = createDIEEntry(ElemDie); 1078 insertDIEEntry(Element, Entry); 1079 } 1080 } 1081 } 1082 1083 if (CTy->isAppleBlockExtension()) 1084 addFlag(Buffer, dwarf::DW_AT_APPLE_block); 1085 1086 // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type 1087 // inside C++ composite types to point to the base class with the vtable. 1088 if (DICompositeType ContainingType = 1089 dyn_cast_or_null<MDCompositeType>(resolve(CTy->getVTableHolder()))) 1090 addDIEEntry(Buffer, dwarf::DW_AT_containing_type, 1091 *getOrCreateTypeDIE(ContainingType)); 1092 1093 if (CTy->isObjcClassComplete()) 1094 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type); 1095 1096 // Add template parameters to a class, structure or union types. 1097 // FIXME: The support isn't in the metadata for this yet. 1098 if (Tag == dwarf::DW_TAG_class_type || 1099 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 1100 addTemplateParams(Buffer, CTy->getTemplateParams()); 1101 1102 break; 1103 } 1104 default: 1105 break; 1106 } 1107 1108 // Add name if not anonymous or intermediate type. 1109 if (!Name.empty()) 1110 addString(Buffer, dwarf::DW_AT_name, Name); 1111 1112 if (Tag == dwarf::DW_TAG_enumeration_type || 1113 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type || 1114 Tag == dwarf::DW_TAG_union_type) { 1115 // Add size if non-zero (derived types might be zero-sized.) 1116 // TODO: Do we care about size for enum forward declarations? 1117 if (Size) 1118 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 1119 else if (!CTy->isForwardDecl()) 1120 // Add zero size if it is not a forward declaration. 1121 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0); 1122 1123 // If we're a forward decl, say so. 1124 if (CTy->isForwardDecl()) 1125 addFlag(Buffer, dwarf::DW_AT_declaration); 1126 1127 // Add source line info if available. 1128 if (!CTy->isForwardDecl()) 1129 addSourceLine(Buffer, CTy); 1130 1131 // No harm in adding the runtime language to the declaration. 1132 unsigned RLang = CTy->getRuntimeLang(); 1133 if (RLang) 1134 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1, 1135 RLang); 1136 } 1137} 1138 1139/// constructTemplateTypeParameterDIE - Construct new DIE for the given 1140/// DITemplateTypeParameter. 1141void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer, 1142 DITemplateTypeParameter TP) { 1143 DIE &ParamDIE = 1144 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer); 1145 // Add the type if it exists, it could be void and therefore no type. 1146 if (TP->getType()) 1147 addType(ParamDIE, resolve(TP->getType())); 1148 if (!TP->getName().empty()) 1149 addString(ParamDIE, dwarf::DW_AT_name, TP->getName()); 1150} 1151 1152/// constructTemplateValueParameterDIE - Construct new DIE for the given 1153/// DITemplateValueParameter. 1154void 1155DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer, 1156 DITemplateValueParameter VP) { 1157 DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer); 1158 1159 // Add the type if there is one, template template and template parameter 1160 // packs will not have a type. 1161 if (VP->getTag() == dwarf::DW_TAG_template_value_parameter) 1162 addType(ParamDIE, resolve(VP->getType())); 1163 if (!VP->getName().empty()) 1164 addString(ParamDIE, dwarf::DW_AT_name, VP->getName()); 1165 if (Metadata *Val = VP->getValue()) { 1166 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val)) 1167 addConstantValue(ParamDIE, CI, resolve(VP->getType())); 1168 else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) { 1169 // For declaration non-type template parameters (such as global values and 1170 // functions) 1171 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 1172 addOpAddress(*Loc, Asm->getSymbol(GV)); 1173 // Emit DW_OP_stack_value to use the address as the immediate value of the 1174 // parameter, rather than a pointer to it. 1175 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value); 1176 addBlock(ParamDIE, dwarf::DW_AT_location, Loc); 1177 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) { 1178 assert(isa<MDString>(Val)); 1179 addString(ParamDIE, dwarf::DW_AT_GNU_template_name, 1180 cast<MDString>(Val)->getString()); 1181 } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) { 1182 addTemplateParams(ParamDIE, cast<MDTuple>(Val)); 1183 } 1184 } 1185} 1186 1187/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1188DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) { 1189 // Construct the context before querying for the existence of the DIE in case 1190 // such construction creates the DIE. 1191 DIE *ContextDIE = getOrCreateContextDIE(NS->getScope()); 1192 1193 if (DIE *NDie = getDIE(NS)) 1194 return NDie; 1195 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS); 1196 1197 StringRef Name = NS->getName(); 1198 if (!Name.empty()) 1199 addString(NDie, dwarf::DW_AT_name, NS->getName()); 1200 else 1201 Name = "(anonymous namespace)"; 1202 DD->addAccelNamespace(Name, NDie); 1203 addGlobalName(Name, NDie, NS->getScope()); 1204 addSourceLine(NDie, NS); 1205 return &NDie; 1206} 1207 1208/// getOrCreateSubprogramDIE - Create new DIE using SP. 1209DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP, bool Minimal) { 1210 // Construct the context before querying for the existence of the DIE in case 1211 // such construction creates the DIE (as is the case for member function 1212 // declarations). 1213 DIE *ContextDIE = 1214 Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope())); 1215 1216 if (DIE *SPDie = getDIE(SP)) 1217 return SPDie; 1218 1219 if (auto *SPDecl = SP->getDeclaration()) { 1220 if (!Minimal) { 1221 // Add subprogram definitions to the CU die directly. 1222 ContextDIE = &getUnitDie(); 1223 // Build the decl now to ensure it precedes the definition. 1224 getOrCreateSubprogramDIE(SPDecl); 1225 } 1226 } 1227 1228 // DW_TAG_inlined_subroutine may refer to this DIE. 1229 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP); 1230 1231 // Stop here and fill this in later, depending on whether or not this 1232 // subprogram turns out to have inlined instances or not. 1233 if (SP->isDefinition()) 1234 return &SPDie; 1235 1236 applySubprogramAttributes(SP, SPDie); 1237 return &SPDie; 1238} 1239 1240bool DwarfUnit::applySubprogramDefinitionAttributes(DISubprogram SP, 1241 DIE &SPDie) { 1242 DIE *DeclDie = nullptr; 1243 StringRef DeclLinkageName; 1244 if (auto *SPDecl = SP->getDeclaration()) { 1245 DeclDie = getDIE(SPDecl); 1246 assert(DeclDie && "This DIE should've already been constructed when the " 1247 "definition DIE was created in " 1248 "getOrCreateSubprogramDIE"); 1249 DeclLinkageName = SPDecl->getLinkageName(); 1250 } 1251 1252 // Add function template parameters. 1253 addTemplateParams(SPDie, SP->getTemplateParams()); 1254 1255 // Add the linkage name if we have one and it isn't in the Decl. 1256 StringRef LinkageName = SP->getLinkageName(); 1257 assert(((LinkageName.empty() || DeclLinkageName.empty()) || 1258 LinkageName == DeclLinkageName) && 1259 "decl has a linkage name and it is different"); 1260 if (DeclLinkageName.empty()) 1261 addLinkageName(SPDie, LinkageName); 1262 1263 if (!DeclDie) 1264 return false; 1265 1266 // Refer to the function declaration where all the other attributes will be 1267 // found. 1268 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie); 1269 return true; 1270} 1271 1272void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie, 1273 bool Minimal) { 1274 if (!Minimal) 1275 if (applySubprogramDefinitionAttributes(SP, SPDie)) 1276 return; 1277 1278 // Constructors and operators for anonymous aggregates do not have names. 1279 if (!SP->getName().empty()) 1280 addString(SPDie, dwarf::DW_AT_name, SP->getName()); 1281 1282 // Skip the rest of the attributes under -gmlt to save space. 1283 if (Minimal) 1284 return; 1285 1286 addSourceLine(SPDie, SP); 1287 1288 // Add the prototype if we have a prototype and we have a C like 1289 // language. 1290 uint16_t Language = getLanguage(); 1291 if (SP->isPrototyped() && 1292 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 1293 Language == dwarf::DW_LANG_ObjC)) 1294 addFlag(SPDie, dwarf::DW_AT_prototyped); 1295 1296 DISubroutineType SPTy = SP->getType(); 1297 assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type && 1298 "the type of a subprogram should be a subroutine"); 1299 1300 auto Args = SPTy->getTypeArray(); 1301 // Add a return type. If this is a type like a C/C++ void type we don't add a 1302 // return type. 1303 if (Args.size()) 1304 if (auto Ty = resolve(Args[0])) 1305 addType(SPDie, Ty); 1306 1307 unsigned VK = SP->getVirtuality(); 1308 if (VK) { 1309 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK); 1310 DIELoc *Block = getDIELoc(); 1311 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1312 addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex()); 1313 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block); 1314 ContainingTypeMap.insert( 1315 std::make_pair(&SPDie, resolve(SP->getContainingType()))); 1316 } 1317 1318 if (!SP->isDefinition()) { 1319 addFlag(SPDie, dwarf::DW_AT_declaration); 1320 1321 // Add arguments. Do not add arguments for subprogram definition. They will 1322 // be handled while processing variables. 1323 constructSubprogramArguments(SPDie, Args); 1324 } 1325 1326 if (SP->isArtificial()) 1327 addFlag(SPDie, dwarf::DW_AT_artificial); 1328 1329 if (!SP->isLocalToUnit()) 1330 addFlag(SPDie, dwarf::DW_AT_external); 1331 1332 if (SP->isOptimized()) 1333 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized); 1334 1335 if (unsigned isa = Asm->getISAEncoding()) 1336 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 1337 1338 if (SP->isLValueReference()) 1339 addFlag(SPDie, dwarf::DW_AT_reference); 1340 1341 if (SP->isRValueReference()) 1342 addFlag(SPDie, dwarf::DW_AT_rvalue_reference); 1343 1344 if (SP->isProtected()) 1345 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1346 dwarf::DW_ACCESS_protected); 1347 else if (SP->isPrivate()) 1348 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1349 dwarf::DW_ACCESS_private); 1350 else if (SP->isPublic()) 1351 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1352 dwarf::DW_ACCESS_public); 1353 1354 if (SP->isExplicit()) 1355 addFlag(SPDie, dwarf::DW_AT_explicit); 1356} 1357 1358/// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1359void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) { 1360 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer); 1361 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy); 1362 1363 // The LowerBound value defines the lower bounds which is typically zero for 1364 // C/C++. The Count value is the number of elements. Values are 64 bit. If 1365 // Count == -1 then the array is unbounded and we do not emit 1366 // DW_AT_lower_bound and DW_AT_count attributes. 1367 int64_t LowerBound = SR->getLowerBound(); 1368 int64_t DefaultLowerBound = getDefaultLowerBound(); 1369 int64_t Count = SR->getCount(); 1370 1371 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound) 1372 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound); 1373 1374 if (Count != -1) 1375 // FIXME: An unbounded array should reference the expression that defines 1376 // the array. 1377 addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count); 1378} 1379 1380DIE *DwarfUnit::getIndexTyDie() { 1381 if (IndexTyDie) 1382 return IndexTyDie; 1383 // Construct an integer type to use for indexes. 1384 IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie); 1385 addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype"); 1386 addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t)); 1387 addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1388 dwarf::DW_ATE_unsigned); 1389 return IndexTyDie; 1390} 1391 1392/// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1393void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) { 1394 if (CTy->isVector()) 1395 addFlag(Buffer, dwarf::DW_AT_GNU_vector); 1396 1397 // Emit the element type. 1398 addType(Buffer, resolve(CTy->getBaseType())); 1399 1400 // Get an anonymous type for index type. 1401 // FIXME: This type should be passed down from the front end 1402 // as different languages may have different sizes for indexes. 1403 DIE *IdxTy = getIndexTyDie(); 1404 1405 // Add subranges to array type. 1406 DIArray Elements = CTy->getElements(); 1407 for (unsigned i = 0, N = Elements.size(); i < N; ++i) { 1408 // FIXME: Should this really be such a loose cast? 1409 if (auto *Element = dyn_cast_or_null<DebugNode>(Elements[i])) 1410 if (Element->getTag() == dwarf::DW_TAG_subrange_type) 1411 constructSubrangeDIE(Buffer, cast<MDSubrange>(Element), IdxTy); 1412 } 1413} 1414 1415/// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType. 1416void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) { 1417 DIArray Elements = CTy->getElements(); 1418 1419 // Add enumerators to enumeration type. 1420 for (unsigned i = 0, N = Elements.size(); i < N; ++i) { 1421 auto *Enum = dyn_cast_or_null<MDEnumerator>(Elements[i]); 1422 if (Enum) { 1423 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer); 1424 StringRef Name = Enum->getName(); 1425 addString(Enumerator, dwarf::DW_AT_name, Name); 1426 int64_t Value = Enum->getValue(); 1427 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, 1428 Value); 1429 } 1430 } 1431 DIType DTy = resolve(CTy->getBaseType()); 1432 if (DTy) { 1433 addType(Buffer, DTy); 1434 addFlag(Buffer, dwarf::DW_AT_enum_class); 1435 } 1436} 1437 1438/// constructContainingTypeDIEs - Construct DIEs for types that contain 1439/// vtables. 1440void DwarfUnit::constructContainingTypeDIEs() { 1441 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 1442 CE = ContainingTypeMap.end(); 1443 CI != CE; ++CI) { 1444 DIE &SPDie = *CI->first; 1445 DIDescriptor D(CI->second); 1446 if (!D) 1447 continue; 1448 DIE *NDie = getDIE(D); 1449 if (!NDie) 1450 continue; 1451 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie); 1452 } 1453} 1454 1455/// constructMemberDIE - Construct member DIE from DIDerivedType. 1456void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT_) { 1457 // Downcast to MDDerivedType. 1458 const MDDerivedType *DT = cast<MDDerivedType>(DT_); 1459 1460 DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer); 1461 StringRef Name = DT->getName(); 1462 if (!Name.empty()) 1463 addString(MemberDie, dwarf::DW_AT_name, Name); 1464 1465 addType(MemberDie, resolve(DT->getBaseType())); 1466 1467 addSourceLine(MemberDie, DT); 1468 1469 if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) { 1470 1471 // For C++, virtual base classes are not at fixed offset. Use following 1472 // expression to extract appropriate offset from vtable. 1473 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1474 1475 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc(); 1476 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1477 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1478 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1479 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits()); 1480 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1481 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1482 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1483 1484 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie); 1485 } else { 1486 uint64_t Size = DT->getSizeInBits(); 1487 uint64_t FieldSize = getBaseTypeSize(DD, DT); 1488 uint64_t OffsetInBytes; 1489 1490 if (FieldSize && Size != FieldSize) { 1491 // Handle bitfield, assume bytes are 8 bits. 1492 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8); 1493 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size); 1494 1495 uint64_t Offset = DT->getOffsetInBits(); 1496 uint64_t AlignMask = ~(DT->getAlignInBits() - 1); 1497 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1498 uint64_t FieldOffset = (HiMark - FieldSize); 1499 Offset -= FieldOffset; 1500 1501 // Maybe we need to work from the other end. 1502 if (Asm->getDataLayout().isLittleEndian()) 1503 Offset = FieldSize - (Offset + Size); 1504 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset); 1505 1506 // Here DW_AT_data_member_location points to the anonymous 1507 // field that includes this bit field. 1508 OffsetInBytes = FieldOffset >> 3; 1509 } else 1510 // This is not a bitfield. 1511 OffsetInBytes = DT->getOffsetInBits() >> 3; 1512 1513 if (DD->getDwarfVersion() <= 2) { 1514 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc(); 1515 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1516 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes); 1517 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie); 1518 } else 1519 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, 1520 OffsetInBytes); 1521 } 1522 1523 if (DT->isProtected()) 1524 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1525 dwarf::DW_ACCESS_protected); 1526 else if (DT->isPrivate()) 1527 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1528 dwarf::DW_ACCESS_private); 1529 // Otherwise C++ member and base classes are considered public. 1530 else if (DT->isPublic()) 1531 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1532 dwarf::DW_ACCESS_public); 1533 if (DT->isVirtual()) 1534 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, 1535 dwarf::DW_VIRTUALITY_virtual); 1536 1537 // Objective-C properties. 1538 if (MDNode *PNode = DT->getObjCProperty()) 1539 if (DIEEntry *PropertyDie = getDIEEntry(PNode)) 1540 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4, 1541 PropertyDie); 1542 1543 if (DT->isArtificial()) 1544 addFlag(MemberDie, dwarf::DW_AT_artificial); 1545} 1546 1547/// getOrCreateStaticMemberDIE - Create new DIE for C++ static member. 1548DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT_) { 1549 const MDDerivedType *DT = cast_or_null<MDDerivedType>(DT_); 1550 if (!DT) 1551 return nullptr; 1552 1553 // Construct the context before querying for the existence of the DIE in case 1554 // such construction creates the DIE. 1555 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope())); 1556 assert(dwarf::isType(ContextDIE->getTag()) && 1557 "Static member should belong to a type."); 1558 1559 if (DIE *StaticMemberDIE = getDIE(DT)) 1560 return StaticMemberDIE; 1561 1562 DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT); 1563 1564 DIType Ty = resolve(DT->getBaseType()); 1565 1566 addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName()); 1567 addType(StaticMemberDIE, Ty); 1568 addSourceLine(StaticMemberDIE, DT); 1569 addFlag(StaticMemberDIE, dwarf::DW_AT_external); 1570 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration); 1571 1572 // FIXME: We could omit private if the parent is a class_type, and 1573 // public if the parent is something else. 1574 if (DT->isProtected()) 1575 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1576 dwarf::DW_ACCESS_protected); 1577 else if (DT->isPrivate()) 1578 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1579 dwarf::DW_ACCESS_private); 1580 else if (DT->isPublic()) 1581 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1582 dwarf::DW_ACCESS_public); 1583 1584 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant())) 1585 addConstantValue(StaticMemberDIE, CI, Ty); 1586 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant())) 1587 addConstantFPValue(StaticMemberDIE, CFP); 1588 1589 return &StaticMemberDIE; 1590} 1591 1592void DwarfUnit::emitHeader(bool UseOffsets) { 1593 // Emit size of content not including length itself 1594 Asm->OutStreamer.AddComment("Length of Unit"); 1595 Asm->EmitInt32(getHeaderSize() + UnitDie.getSize()); 1596 1597 Asm->OutStreamer.AddComment("DWARF version number"); 1598 Asm->EmitInt16(DD->getDwarfVersion()); 1599 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 1600 1601 // We share one abbreviations table across all units so it's always at the 1602 // start of the section. Use a relocatable offset where needed to ensure 1603 // linking doesn't invalidate that offset. 1604 const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering(); 1605 if (!UseOffsets) 1606 Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol()); 1607 else 1608 Asm->EmitInt32(0); 1609 1610 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 1611 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 1612} 1613 1614void DwarfUnit::initSection(const MCSection *Section) { 1615 assert(!this->Section); 1616 this->Section = Section; 1617} 1618 1619void DwarfTypeUnit::emitHeader(bool UseOffsets) { 1620 DwarfUnit::emitHeader(UseOffsets); 1621 Asm->OutStreamer.AddComment("Type Signature"); 1622 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature)); 1623 Asm->OutStreamer.AddComment("Type DIE Offset"); 1624 // In a skeleton type unit there is no type DIE so emit a zero offset. 1625 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0, 1626 sizeof(Ty->getOffset())); 1627} 1628 1629bool DwarfTypeUnit::isDwoUnit() const { 1630 // Since there are no skeleton type units, all type units are dwo type units 1631 // when split DWARF is being used. 1632 return DD->useSplitDwarf(); 1633} 1634