DwarfUnit.cpp revision dce4a407a24b04eebc6a376f8e62b41aaa7b071f
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 34using namespace llvm; 35 36#define DEBUG_TYPE "dwarfdebug" 37 38static cl::opt<bool> 39GenerateDwarfTypeUnits("generate-type-units", cl::Hidden, 40 cl::desc("Generate DWARF4 type units."), 41 cl::init(false)); 42 43/// Unit - Unit constructor. 44DwarfUnit::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 54DwarfCompileUnit::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 61DwarfTypeUnit::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. 71DwarfUnit::~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. 80DIEEntry *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. 87int64_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. 130static 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. 147DIE *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. 156void 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. 165void 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/// 174void 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 183void 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/// 189void 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 197void 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. 207void 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. 221void 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/// 237void 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/// 244void 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/// 254void 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 260void 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/// 266void 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/// 276void 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/// 287void 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 301void 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 312unsigned 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 323unsigned 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/// 331void 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/// 344void 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 352void 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/// 360void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) { 361 addDIEEntry(Die, Attribute, createDIEEntry(Entry)); 362} 363 364void 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 375void 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. 391DIE &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/// 403void 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 409void 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. 418void 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. 431void 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. 440void 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. 448void 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. 456void 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. 464void 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. 474void 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. 482void 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. 494void 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. 539void 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. 558void 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/// 580void 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/// 673void 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. 749static 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. 790static 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. 819void 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. 842void 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. 848void 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. 853void 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 860void 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 867void 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. 872void 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. 902void 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. 916DIE *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 928DIE *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. 946DIE *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 992void 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. 1014void 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. 1035void 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. 1047std::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()) { 1075 CS += Name; 1076 CS += "::"; 1077 } 1078 } 1079 return CS; 1080} 1081 1082/// constructTypeDIE - Construct basic type die from DIBasicType. 1083void DwarfUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 1084 // Get core information. 1085 StringRef Name = BTy.getName(); 1086 // Add name if not anonymous or intermediate type. 1087 if (!Name.empty()) 1088 addString(Buffer, dwarf::DW_AT_name, Name); 1089 1090 // An unspecified type only has a name attribute. 1091 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) 1092 return; 1093 1094 addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1095 BTy.getEncoding()); 1096 1097 uint64_t Size = BTy.getSizeInBits() >> 3; 1098 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 1099} 1100 1101/// constructTypeDIE - Construct derived type die from DIDerivedType. 1102void DwarfUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 1103 // Get core information. 1104 StringRef Name = DTy.getName(); 1105 uint64_t Size = DTy.getSizeInBits() >> 3; 1106 uint16_t Tag = Buffer.getTag(); 1107 1108 // Map to main type, void will not have a type. 1109 DIType FromTy = resolve(DTy.getTypeDerivedFrom()); 1110 if (FromTy) 1111 addType(Buffer, FromTy); 1112 1113 // Add name if not anonymous or intermediate type. 1114 if (!Name.empty()) 1115 addString(Buffer, dwarf::DW_AT_name, Name); 1116 1117 // Add size if non-zero (derived types might be zero-sized.) 1118 if (Size && Tag != dwarf::DW_TAG_pointer_type) 1119 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 1120 1121 if (Tag == dwarf::DW_TAG_ptr_to_member_type) 1122 addDIEEntry(Buffer, dwarf::DW_AT_containing_type, 1123 *getOrCreateTypeDIE(resolve(DTy.getClassType()))); 1124 // Add source line info if available and TyDesc is not a forward declaration. 1125 if (!DTy.isForwardDecl()) 1126 addSourceLine(Buffer, DTy); 1127} 1128 1129/// constructSubprogramArguments - Construct function argument DIEs. 1130void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DIArray Args) { 1131 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1132 DIDescriptor Ty = Args.getElement(i); 1133 if (Ty.isUnspecifiedParameter()) { 1134 assert(i == N-1 && "Unspecified parameter must be the last argument"); 1135 createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer); 1136 } else { 1137 DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer); 1138 addType(Arg, DIType(Ty)); 1139 if (DIType(Ty).isArtificial()) 1140 addFlag(Arg, dwarf::DW_AT_artificial); 1141 } 1142 } 1143} 1144 1145/// constructTypeDIE - Construct type DIE from DICompositeType. 1146void DwarfUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 1147 // Add name if not anonymous or intermediate type. 1148 StringRef Name = CTy.getName(); 1149 1150 uint64_t Size = CTy.getSizeInBits() >> 3; 1151 uint16_t Tag = Buffer.getTag(); 1152 1153 switch (Tag) { 1154 case dwarf::DW_TAG_array_type: 1155 constructArrayTypeDIE(Buffer, CTy); 1156 break; 1157 case dwarf::DW_TAG_enumeration_type: 1158 constructEnumTypeDIE(Buffer, CTy); 1159 break; 1160 case dwarf::DW_TAG_subroutine_type: { 1161 // Add return type. A void return won't have a type. 1162 DIArray Elements = CTy.getTypeArray(); 1163 DIType RTy(Elements.getElement(0)); 1164 if (RTy) 1165 addType(Buffer, RTy); 1166 1167 bool isPrototyped = true; 1168 if (Elements.getNumElements() == 2 && 1169 Elements.getElement(1).isUnspecifiedParameter()) 1170 isPrototyped = false; 1171 1172 constructSubprogramArguments(Buffer, Elements); 1173 1174 // Add prototype flag if we're dealing with a C language and the 1175 // function has been prototyped. 1176 uint16_t Language = getLanguage(); 1177 if (isPrototyped && 1178 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 1179 Language == dwarf::DW_LANG_ObjC)) 1180 addFlag(Buffer, dwarf::DW_AT_prototyped); 1181 1182 if (CTy.isLValueReference()) 1183 addFlag(Buffer, dwarf::DW_AT_reference); 1184 1185 if (CTy.isRValueReference()) 1186 addFlag(Buffer, dwarf::DW_AT_rvalue_reference); 1187 } break; 1188 case dwarf::DW_TAG_structure_type: 1189 case dwarf::DW_TAG_union_type: 1190 case dwarf::DW_TAG_class_type: { 1191 // Add elements to structure type. 1192 DIArray Elements = CTy.getTypeArray(); 1193 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1194 DIDescriptor Element = Elements.getElement(i); 1195 if (Element.isSubprogram()) 1196 getOrCreateSubprogramDIE(DISubprogram(Element)); 1197 else if (Element.isDerivedType()) { 1198 DIDerivedType DDTy(Element); 1199 if (DDTy.getTag() == dwarf::DW_TAG_friend) { 1200 DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer); 1201 addType(ElemDie, resolve(DDTy.getTypeDerivedFrom()), 1202 dwarf::DW_AT_friend); 1203 } else if (DDTy.isStaticMember()) { 1204 getOrCreateStaticMemberDIE(DDTy); 1205 } else { 1206 constructMemberDIE(Buffer, DDTy); 1207 } 1208 } else if (Element.isObjCProperty()) { 1209 DIObjCProperty Property(Element); 1210 DIE &ElemDie = createAndAddDIE(Property.getTag(), Buffer); 1211 StringRef PropertyName = Property.getObjCPropertyName(); 1212 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName); 1213 if (Property.getType()) 1214 addType(ElemDie, Property.getType()); 1215 addSourceLine(ElemDie, Property); 1216 StringRef GetterName = Property.getObjCPropertyGetterName(); 1217 if (!GetterName.empty()) 1218 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName); 1219 StringRef SetterName = Property.getObjCPropertySetterName(); 1220 if (!SetterName.empty()) 1221 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName); 1222 unsigned PropertyAttributes = 0; 1223 if (Property.isReadOnlyObjCProperty()) 1224 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly; 1225 if (Property.isReadWriteObjCProperty()) 1226 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite; 1227 if (Property.isAssignObjCProperty()) 1228 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign; 1229 if (Property.isRetainObjCProperty()) 1230 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain; 1231 if (Property.isCopyObjCProperty()) 1232 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy; 1233 if (Property.isNonAtomicObjCProperty()) 1234 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic; 1235 if (PropertyAttributes) 1236 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None, 1237 PropertyAttributes); 1238 1239 DIEEntry *Entry = getDIEEntry(Element); 1240 if (!Entry) { 1241 Entry = createDIEEntry(ElemDie); 1242 insertDIEEntry(Element, Entry); 1243 } 1244 } else 1245 continue; 1246 } 1247 1248 if (CTy.isAppleBlockExtension()) 1249 addFlag(Buffer, dwarf::DW_AT_APPLE_block); 1250 1251 DICompositeType ContainingType(resolve(CTy.getContainingType())); 1252 if (ContainingType) 1253 addDIEEntry(Buffer, dwarf::DW_AT_containing_type, 1254 *getOrCreateTypeDIE(ContainingType)); 1255 1256 if (CTy.isObjcClassComplete()) 1257 addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type); 1258 1259 // Add template parameters to a class, structure or union types. 1260 // FIXME: The support isn't in the metadata for this yet. 1261 if (Tag == dwarf::DW_TAG_class_type || 1262 Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 1263 addTemplateParams(Buffer, CTy.getTemplateParams()); 1264 1265 break; 1266 } 1267 default: 1268 break; 1269 } 1270 1271 // Add name if not anonymous or intermediate type. 1272 if (!Name.empty()) 1273 addString(Buffer, dwarf::DW_AT_name, Name); 1274 1275 if (Tag == dwarf::DW_TAG_enumeration_type || 1276 Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type || 1277 Tag == dwarf::DW_TAG_union_type) { 1278 // Add size if non-zero (derived types might be zero-sized.) 1279 // TODO: Do we care about size for enum forward declarations? 1280 if (Size) 1281 addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size); 1282 else if (!CTy.isForwardDecl()) 1283 // Add zero size if it is not a forward declaration. 1284 addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0); 1285 1286 // If we're a forward decl, say so. 1287 if (CTy.isForwardDecl()) 1288 addFlag(Buffer, dwarf::DW_AT_declaration); 1289 1290 // Add source line info if available. 1291 if (!CTy.isForwardDecl()) 1292 addSourceLine(Buffer, CTy); 1293 1294 // No harm in adding the runtime language to the declaration. 1295 unsigned RLang = CTy.getRunTimeLang(); 1296 if (RLang) 1297 addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1, 1298 RLang); 1299 } 1300} 1301 1302/// constructTemplateTypeParameterDIE - Construct new DIE for the given 1303/// DITemplateTypeParameter. 1304void DwarfUnit::constructTemplateTypeParameterDIE(DIE &Buffer, 1305 DITemplateTypeParameter TP) { 1306 DIE &ParamDIE = 1307 createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer); 1308 // Add the type if it exists, it could be void and therefore no type. 1309 if (TP.getType()) 1310 addType(ParamDIE, resolve(TP.getType())); 1311 if (!TP.getName().empty()) 1312 addString(ParamDIE, dwarf::DW_AT_name, TP.getName()); 1313} 1314 1315/// constructTemplateValueParameterDIE - Construct new DIE for the given 1316/// DITemplateValueParameter. 1317void 1318DwarfUnit::constructTemplateValueParameterDIE(DIE &Buffer, 1319 DITemplateValueParameter VP) { 1320 DIE &ParamDIE = createAndAddDIE(VP.getTag(), Buffer); 1321 1322 // Add the type if there is one, template template and template parameter 1323 // packs will not have a type. 1324 if (VP.getTag() == dwarf::DW_TAG_template_value_parameter) 1325 addType(ParamDIE, resolve(VP.getType())); 1326 if (!VP.getName().empty()) 1327 addString(ParamDIE, dwarf::DW_AT_name, VP.getName()); 1328 if (Value *Val = VP.getValue()) { 1329 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) 1330 addConstantValue(ParamDIE, CI, resolve(VP.getType())); 1331 else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) { 1332 // For declaration non-type template parameters (such as global values and 1333 // functions) 1334 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 1335 addOpAddress(*Loc, Asm->getSymbol(GV)); 1336 // Emit DW_OP_stack_value to use the address as the immediate value of the 1337 // parameter, rather than a pointer to it. 1338 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value); 1339 addBlock(ParamDIE, dwarf::DW_AT_location, Loc); 1340 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) { 1341 assert(isa<MDString>(Val)); 1342 addString(ParamDIE, dwarf::DW_AT_GNU_template_name, 1343 cast<MDString>(Val)->getString()); 1344 } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) { 1345 assert(isa<MDNode>(Val)); 1346 DIArray A(cast<MDNode>(Val)); 1347 addTemplateParams(ParamDIE, A); 1348 } 1349 } 1350} 1351 1352/// getOrCreateNameSpace - Create a DIE for DINameSpace. 1353DIE *DwarfUnit::getOrCreateNameSpace(DINameSpace NS) { 1354 // Construct the context before querying for the existence of the DIE in case 1355 // such construction creates the DIE. 1356 DIE *ContextDIE = getOrCreateContextDIE(NS.getContext()); 1357 1358 if (DIE *NDie = getDIE(NS)) 1359 return NDie; 1360 DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS); 1361 1362 if (!NS.getName().empty()) { 1363 addString(NDie, dwarf::DW_AT_name, NS.getName()); 1364 DD->addAccelNamespace(NS.getName(), NDie); 1365 addGlobalName(NS.getName(), NDie, NS.getContext()); 1366 } else 1367 DD->addAccelNamespace("(anonymous namespace)", NDie); 1368 addSourceLine(NDie, NS); 1369 return &NDie; 1370} 1371 1372/// getOrCreateSubprogramDIE - Create new DIE using SP. 1373DIE *DwarfUnit::getOrCreateSubprogramDIE(DISubprogram SP) { 1374 // Construct the context before querying for the existence of the DIE in case 1375 // such construction creates the DIE (as is the case for member function 1376 // declarations). 1377 DIE *ContextDIE = getOrCreateContextDIE(resolve(SP.getContext())); 1378 1379 if (DIE *SPDie = getDIE(SP)) 1380 return SPDie; 1381 1382 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) { 1383 // Add subprogram definitions to the CU die directly. 1384 ContextDIE = &getUnitDie(); 1385 // Build the decl now to ensure it preceeds the definition. 1386 getOrCreateSubprogramDIE(SPDecl); 1387 } 1388 1389 // DW_TAG_inlined_subroutine may refer to this DIE. 1390 DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP); 1391 1392 // Abort here and fill this in later, depending on whether or not this 1393 // subprogram turns out to have inlined instances or not. 1394 if (SP.isDefinition()) 1395 return &SPDie; 1396 1397 applySubprogramAttributes(SP, SPDie); 1398 return &SPDie; 1399} 1400 1401void DwarfUnit::applySubprogramAttributes(DISubprogram SP, DIE &SPDie) { 1402 DIE *DeclDie = nullptr; 1403 StringRef DeclLinkageName; 1404 if (DISubprogram SPDecl = SP.getFunctionDeclaration()) { 1405 DeclDie = getDIE(SPDecl); 1406 assert(DeclDie); 1407 DeclLinkageName = SPDecl.getLinkageName(); 1408 } 1409 1410 // Add function template parameters. 1411 addTemplateParams(SPDie, SP.getTemplateParams()); 1412 1413 // Add the linkage name if we have one and it isn't in the Decl. 1414 StringRef LinkageName = SP.getLinkageName(); 1415 assert(((LinkageName.empty() || DeclLinkageName.empty()) || 1416 LinkageName == DeclLinkageName) && 1417 "decl has a linkage name and it is different"); 1418 if (!LinkageName.empty() && DeclLinkageName.empty()) 1419 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, 1420 GlobalValue::getRealLinkageName(LinkageName)); 1421 1422 if (DeclDie) { 1423 // Refer to the function declaration where all the other attributes will be 1424 // found. 1425 addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie); 1426 return; 1427 } 1428 1429 // Constructors and operators for anonymous aggregates do not have names. 1430 if (!SP.getName().empty()) 1431 addString(SPDie, dwarf::DW_AT_name, SP.getName()); 1432 1433 addSourceLine(SPDie, SP); 1434 1435 // Add the prototype if we have a prototype and we have a C like 1436 // language. 1437 uint16_t Language = getLanguage(); 1438 if (SP.isPrototyped() && 1439 (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 || 1440 Language == dwarf::DW_LANG_ObjC)) 1441 addFlag(SPDie, dwarf::DW_AT_prototyped); 1442 1443 DICompositeType SPTy = SP.getType(); 1444 assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type && 1445 "the type of a subprogram should be a subroutine"); 1446 1447 DIArray Args = SPTy.getTypeArray(); 1448 // Add a return type. If this is a type like a C/C++ void type we don't add a 1449 // return type. 1450 if (Args.getElement(0)) 1451 addType(SPDie, DIType(Args.getElement(0))); 1452 1453 unsigned VK = SP.getVirtuality(); 1454 if (VK) { 1455 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK); 1456 DIELoc *Block = getDIELoc(); 1457 addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1458 addUInt(*Block, dwarf::DW_FORM_udata, SP.getVirtualIndex()); 1459 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block); 1460 ContainingTypeMap.insert( 1461 std::make_pair(&SPDie, resolve(SP.getContainingType()))); 1462 } 1463 1464 if (!SP.isDefinition()) { 1465 addFlag(SPDie, dwarf::DW_AT_declaration); 1466 1467 // Add arguments. Do not add arguments for subprogram definition. They will 1468 // be handled while processing variables. 1469 constructSubprogramArguments(SPDie, Args); 1470 } 1471 1472 if (SP.isArtificial()) 1473 addFlag(SPDie, dwarf::DW_AT_artificial); 1474 1475 if (!SP.isLocalToUnit()) 1476 addFlag(SPDie, dwarf::DW_AT_external); 1477 1478 if (SP.isOptimized()) 1479 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized); 1480 1481 if (unsigned isa = Asm->getISAEncoding()) { 1482 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 1483 } 1484 1485 if (SP.isLValueReference()) 1486 addFlag(SPDie, dwarf::DW_AT_reference); 1487 1488 if (SP.isRValueReference()) 1489 addFlag(SPDie, dwarf::DW_AT_rvalue_reference); 1490 1491 if (SP.isProtected()) 1492 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1493 dwarf::DW_ACCESS_protected); 1494 else if (SP.isPrivate()) 1495 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1496 dwarf::DW_ACCESS_private); 1497 else 1498 addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1499 dwarf::DW_ACCESS_public); 1500 1501 if (SP.isExplicit()) 1502 addFlag(SPDie, dwarf::DW_AT_explicit); 1503} 1504 1505// Return const expression if value is a GEP to access merged global 1506// constant. e.g. 1507// i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0) 1508static const ConstantExpr *getMergedGlobalExpr(const Value *V) { 1509 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V); 1510 if (!CE || CE->getNumOperands() != 3 || 1511 CE->getOpcode() != Instruction::GetElementPtr) 1512 return nullptr; 1513 1514 // First operand points to a global struct. 1515 Value *Ptr = CE->getOperand(0); 1516 if (!isa<GlobalValue>(Ptr) || 1517 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType())) 1518 return nullptr; 1519 1520 // Second operand is zero. 1521 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1)); 1522 if (!CI || !CI->isZero()) 1523 return nullptr; 1524 1525 // Third operand is offset. 1526 if (!isa<ConstantInt>(CE->getOperand(2))) 1527 return nullptr; 1528 1529 return CE; 1530} 1531 1532/// createGlobalVariableDIE - create global variable DIE. 1533void DwarfCompileUnit::createGlobalVariableDIE(DIGlobalVariable GV) { 1534 // Check for pre-existence. 1535 if (getDIE(GV)) 1536 return; 1537 1538 assert(GV.isGlobalVariable()); 1539 1540 DIScope GVContext = GV.getContext(); 1541 DIType GTy = DD->resolve(GV.getType()); 1542 1543 // If this is a static data member definition, some attributes belong 1544 // to the declaration DIE. 1545 DIE *VariableDIE = nullptr; 1546 bool IsStaticMember = false; 1547 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration(); 1548 if (SDMDecl.Verify()) { 1549 assert(SDMDecl.isStaticMember() && "Expected static member decl"); 1550 // We need the declaration DIE that is in the static member's class. 1551 VariableDIE = getOrCreateStaticMemberDIE(SDMDecl); 1552 IsStaticMember = true; 1553 } 1554 1555 // If this is not a static data member definition, create the variable 1556 // DIE and add the initial set of attributes to it. 1557 if (!VariableDIE) { 1558 // Construct the context before querying for the existence of the DIE in 1559 // case such construction creates the DIE. 1560 DIE *ContextDIE = getOrCreateContextDIE(GVContext); 1561 1562 // Add to map. 1563 VariableDIE = &createAndAddDIE(GV.getTag(), *ContextDIE, GV); 1564 1565 // Add name and type. 1566 addString(*VariableDIE, dwarf::DW_AT_name, GV.getDisplayName()); 1567 addType(*VariableDIE, GTy); 1568 1569 // Add scoping info. 1570 if (!GV.isLocalToUnit()) 1571 addFlag(*VariableDIE, dwarf::DW_AT_external); 1572 1573 // Add line number info. 1574 addSourceLine(*VariableDIE, GV); 1575 } 1576 1577 // Add location. 1578 bool addToAccelTable = false; 1579 DIE *VariableSpecDIE = nullptr; 1580 bool isGlobalVariable = GV.getGlobal() != nullptr; 1581 if (isGlobalVariable) { 1582 addToAccelTable = true; 1583 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 1584 const MCSymbol *Sym = Asm->getSymbol(GV.getGlobal()); 1585 if (GV.getGlobal()->isThreadLocal()) { 1586 // FIXME: Make this work with -gsplit-dwarf. 1587 unsigned PointerSize = Asm->getDataLayout().getPointerSize(); 1588 assert((PointerSize == 4 || PointerSize == 8) && 1589 "Add support for other sizes if necessary"); 1590 // Based on GCC's support for TLS: 1591 if (!DD->useSplitDwarf()) { 1592 // 1) Start with a constNu of the appropriate pointer size 1593 addUInt(*Loc, dwarf::DW_FORM_data1, 1594 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u); 1595 // 2) containing the (relocated) offset of the TLS variable 1596 // within the module's TLS block. 1597 addExpr(*Loc, dwarf::DW_FORM_udata, 1598 Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym)); 1599 } else { 1600 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index); 1601 addUInt(*Loc, dwarf::DW_FORM_udata, 1602 DD->getAddressPool().getIndex(Sym, /* TLS */ true)); 1603 } 1604 // 3) followed by a custom OP to make the debugger do a TLS lookup. 1605 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_push_tls_address); 1606 } else { 1607 DD->addArangeLabel(SymbolCU(this, Sym)); 1608 addOpAddress(*Loc, Sym); 1609 } 1610 // Do not create specification DIE if context is either compile unit 1611 // or a subprogram. 1612 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() && 1613 !GVContext.isFile() && !DD->isSubprogramContext(GVContext)) { 1614 // Create specification DIE. 1615 VariableSpecDIE = &createAndAddDIE(dwarf::DW_TAG_variable, UnitDie); 1616 addDIEEntry(*VariableSpecDIE, dwarf::DW_AT_specification, *VariableDIE); 1617 addBlock(*VariableSpecDIE, dwarf::DW_AT_location, Loc); 1618 // A static member's declaration is already flagged as such. 1619 if (!SDMDecl.Verify()) 1620 addFlag(*VariableDIE, dwarf::DW_AT_declaration); 1621 } else { 1622 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc); 1623 } 1624 // Add the linkage name. 1625 StringRef LinkageName = GV.getLinkageName(); 1626 if (!LinkageName.empty()) 1627 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include: 1628 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and 1629 // TAG_variable. 1630 addString(IsStaticMember && VariableSpecDIE ? *VariableSpecDIE 1631 : *VariableDIE, 1632 DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name 1633 : dwarf::DW_AT_MIPS_linkage_name, 1634 GlobalValue::getRealLinkageName(LinkageName)); 1635 } else if (const ConstantInt *CI = 1636 dyn_cast_or_null<ConstantInt>(GV.getConstant())) { 1637 // AT_const_value was added when the static member was created. To avoid 1638 // emitting AT_const_value multiple times, we only add AT_const_value when 1639 // it is not a static member. 1640 if (!IsStaticMember) 1641 addConstantValue(*VariableDIE, CI, GTy); 1642 } else if (const ConstantExpr *CE = getMergedGlobalExpr(GV->getOperand(11))) { 1643 addToAccelTable = true; 1644 // GV is a merged global. 1645 DIELoc *Loc = new (DIEValueAllocator) DIELoc(); 1646 Value *Ptr = CE->getOperand(0); 1647 MCSymbol *Sym = Asm->getSymbol(cast<GlobalValue>(Ptr)); 1648 DD->addArangeLabel(SymbolCU(this, Sym)); 1649 addOpAddress(*Loc, Sym); 1650 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1651 SmallVector<Value *, 3> Idx(CE->op_begin() + 1, CE->op_end()); 1652 addUInt(*Loc, dwarf::DW_FORM_udata, 1653 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx)); 1654 addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1655 addBlock(*VariableDIE, dwarf::DW_AT_location, Loc); 1656 } 1657 1658 if (addToAccelTable) { 1659 DIE &AddrDIE = VariableSpecDIE ? *VariableSpecDIE : *VariableDIE; 1660 DD->addAccelName(GV.getName(), AddrDIE); 1661 1662 // If the linkage name is different than the name, go ahead and output 1663 // that as well into the name table. 1664 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName()) 1665 DD->addAccelName(GV.getLinkageName(), AddrDIE); 1666 } 1667 1668 if (!GV.isLocalToUnit()) 1669 addGlobalName(GV.getName(), 1670 VariableSpecDIE ? *VariableSpecDIE : *VariableDIE, 1671 GV.getContext()); 1672} 1673 1674/// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1675void DwarfUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy) { 1676 DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer); 1677 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy); 1678 1679 // The LowerBound value defines the lower bounds which is typically zero for 1680 // C/C++. The Count value is the number of elements. Values are 64 bit. If 1681 // Count == -1 then the array is unbounded and we do not emit 1682 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and 1683 // Count == 0, then the array has zero elements in which case we do not emit 1684 // an upper bound. 1685 int64_t LowerBound = SR.getLo(); 1686 int64_t DefaultLowerBound = getDefaultLowerBound(); 1687 int64_t Count = SR.getCount(); 1688 1689 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound) 1690 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound); 1691 1692 if (Count != -1 && Count != 0) 1693 // FIXME: An unbounded array should reference the expression that defines 1694 // the array. 1695 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, None, 1696 LowerBound + Count - 1); 1697} 1698 1699/// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1700void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, DICompositeType CTy) { 1701 if (CTy.isVector()) 1702 addFlag(Buffer, dwarf::DW_AT_GNU_vector); 1703 1704 // Emit the element type. 1705 addType(Buffer, resolve(CTy.getTypeDerivedFrom())); 1706 1707 // Get an anonymous type for index type. 1708 // FIXME: This type should be passed down from the front end 1709 // as different languages may have different sizes for indexes. 1710 DIE *IdxTy = getIndexTyDie(); 1711 if (!IdxTy) { 1712 // Construct an integer type to use for indexes. 1713 IdxTy = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie); 1714 addString(*IdxTy, dwarf::DW_AT_name, "sizetype"); 1715 addUInt(*IdxTy, dwarf::DW_AT_byte_size, None, sizeof(int64_t)); 1716 addUInt(*IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1717 dwarf::DW_ATE_unsigned); 1718 setIndexTyDie(IdxTy); 1719 } 1720 1721 // Add subranges to array type. 1722 DIArray Elements = CTy.getTypeArray(); 1723 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1724 DIDescriptor Element = Elements.getElement(i); 1725 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 1726 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy); 1727 } 1728} 1729 1730/// constructEnumTypeDIE - Construct an enum type DIE from DICompositeType. 1731void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, DICompositeType CTy) { 1732 DIArray Elements = CTy.getTypeArray(); 1733 1734 // Add enumerators to enumeration type. 1735 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1736 DIEnumerator Enum(Elements.getElement(i)); 1737 if (Enum.isEnumerator()) { 1738 DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer); 1739 StringRef Name = Enum.getName(); 1740 addString(Enumerator, dwarf::DW_AT_name, Name); 1741 int64_t Value = Enum.getEnumValue(); 1742 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, 1743 Value); 1744 } 1745 } 1746 DIType DTy = resolve(CTy.getTypeDerivedFrom()); 1747 if (DTy) { 1748 addType(Buffer, DTy); 1749 addFlag(Buffer, dwarf::DW_AT_enum_class); 1750 } 1751} 1752 1753/// constructContainingTypeDIEs - Construct DIEs for types that contain 1754/// vtables. 1755void DwarfUnit::constructContainingTypeDIEs() { 1756 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 1757 CE = ContainingTypeMap.end(); 1758 CI != CE; ++CI) { 1759 DIE &SPDie = *CI->first; 1760 DIDescriptor D(CI->second); 1761 if (!D) 1762 continue; 1763 DIE *NDie = getDIE(D); 1764 if (!NDie) 1765 continue; 1766 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie); 1767 } 1768} 1769 1770/// constructVariableDIE - Construct a DIE for the given DbgVariable. 1771std::unique_ptr<DIE> DwarfUnit::constructVariableDIE(DbgVariable &DV, 1772 bool Abstract) { 1773 auto D = constructVariableDIEImpl(DV, Abstract); 1774 DV.setDIE(*D); 1775 return D; 1776} 1777 1778std::unique_ptr<DIE> DwarfUnit::constructVariableDIEImpl(const DbgVariable &DV, 1779 bool Abstract) { 1780 StringRef Name = DV.getName(); 1781 1782 // Define variable debug information entry. 1783 auto VariableDie = make_unique<DIE>(DV.getTag()); 1784 DbgVariable *AbsVar = DV.getAbstractVariable(); 1785 if (AbsVar && AbsVar->getDIE()) 1786 addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin, *AbsVar->getDIE()); 1787 else { 1788 if (!Name.empty()) 1789 addString(*VariableDie, dwarf::DW_AT_name, Name); 1790 addSourceLine(*VariableDie, DV.getVariable()); 1791 addType(*VariableDie, DV.getType()); 1792 if (DV.isArtificial()) 1793 addFlag(*VariableDie, dwarf::DW_AT_artificial); 1794 } 1795 1796 if (Abstract) 1797 return VariableDie; 1798 1799 // Add variable address. 1800 1801 unsigned Offset = DV.getDotDebugLocOffset(); 1802 if (Offset != ~0U) { 1803 addLocationList(*VariableDie, dwarf::DW_AT_location, Offset); 1804 return VariableDie; 1805 } 1806 1807 // Check if variable is described by a DBG_VALUE instruction. 1808 if (const MachineInstr *DVInsn = DV.getMInsn()) { 1809 assert(DVInsn->getNumOperands() == 3); 1810 if (DVInsn->getOperand(0).isReg()) { 1811 const MachineOperand RegOp = DVInsn->getOperand(0); 1812 // If the second operand is an immediate, this is an indirect value. 1813 if (DVInsn->getOperand(1).isImm()) { 1814 MachineLocation Location(RegOp.getReg(), 1815 DVInsn->getOperand(1).getImm()); 1816 addVariableAddress(DV, *VariableDie, Location); 1817 } else if (RegOp.getReg()) 1818 addVariableAddress(DV, *VariableDie, MachineLocation(RegOp.getReg())); 1819 } else if (DVInsn->getOperand(0).isImm()) 1820 addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType()); 1821 else if (DVInsn->getOperand(0).isFPImm()) 1822 addConstantFPValue(*VariableDie, DVInsn->getOperand(0)); 1823 else if (DVInsn->getOperand(0).isCImm()) 1824 addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(), 1825 DV.getType()); 1826 1827 return VariableDie; 1828 } 1829 1830 // .. else use frame index. 1831 int FI = DV.getFrameIndex(); 1832 if (FI != ~0) { 1833 unsigned FrameReg = 0; 1834 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering(); 1835 int Offset = TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg); 1836 MachineLocation Location(FrameReg, Offset); 1837 addVariableAddress(DV, *VariableDie, Location); 1838 } 1839 1840 return VariableDie; 1841} 1842 1843/// constructMemberDIE - Construct member DIE from DIDerivedType. 1844void DwarfUnit::constructMemberDIE(DIE &Buffer, DIDerivedType DT) { 1845 DIE &MemberDie = createAndAddDIE(DT.getTag(), Buffer); 1846 StringRef Name = DT.getName(); 1847 if (!Name.empty()) 1848 addString(MemberDie, dwarf::DW_AT_name, Name); 1849 1850 addType(MemberDie, resolve(DT.getTypeDerivedFrom())); 1851 1852 addSourceLine(MemberDie, DT); 1853 1854 if (DT.getTag() == dwarf::DW_TAG_inheritance && DT.isVirtual()) { 1855 1856 // For C++, virtual base classes are not at fixed offset. Use following 1857 // expression to extract appropriate offset from vtable. 1858 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1859 1860 DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc(); 1861 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1862 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1863 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1864 addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 1865 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1866 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1867 addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1868 1869 addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie); 1870 } else { 1871 uint64_t Size = DT.getSizeInBits(); 1872 uint64_t FieldSize = getBaseTypeSize(DD, DT); 1873 uint64_t OffsetInBytes; 1874 1875 if (Size != FieldSize) { 1876 // Handle bitfield, assume bytes are 8 bits. 1877 addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8); 1878 addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size); 1879 1880 uint64_t Offset = DT.getOffsetInBits(); 1881 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 1882 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1883 uint64_t FieldOffset = (HiMark - FieldSize); 1884 Offset -= FieldOffset; 1885 1886 // Maybe we need to work from the other end. 1887 if (Asm->getDataLayout().isLittleEndian()) 1888 Offset = FieldSize - (Offset + Size); 1889 addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset); 1890 1891 // Here DW_AT_data_member_location points to the anonymous 1892 // field that includes this bit field. 1893 OffsetInBytes = FieldOffset >> 3; 1894 } else 1895 // This is not a bitfield. 1896 OffsetInBytes = DT.getOffsetInBits() >> 3; 1897 1898 if (DD->getDwarfVersion() <= 2) { 1899 DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc(); 1900 addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1901 addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes); 1902 addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie); 1903 } else 1904 addUInt(MemberDie, dwarf::DW_AT_data_member_location, None, 1905 OffsetInBytes); 1906 } 1907 1908 if (DT.isProtected()) 1909 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1910 dwarf::DW_ACCESS_protected); 1911 else if (DT.isPrivate()) 1912 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1913 dwarf::DW_ACCESS_private); 1914 // Otherwise C++ member and base classes are considered public. 1915 else 1916 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1917 dwarf::DW_ACCESS_public); 1918 if (DT.isVirtual()) 1919 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, 1920 dwarf::DW_VIRTUALITY_virtual); 1921 1922 // Objective-C properties. 1923 if (MDNode *PNode = DT.getObjCProperty()) 1924 if (DIEEntry *PropertyDie = getDIEEntry(PNode)) 1925 MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4, 1926 PropertyDie); 1927 1928 if (DT.isArtificial()) 1929 addFlag(MemberDie, dwarf::DW_AT_artificial); 1930} 1931 1932/// getOrCreateStaticMemberDIE - Create new DIE for C++ static member. 1933DIE *DwarfUnit::getOrCreateStaticMemberDIE(DIDerivedType DT) { 1934 if (!DT.Verify()) 1935 return nullptr; 1936 1937 // Construct the context before querying for the existence of the DIE in case 1938 // such construction creates the DIE. 1939 DIE *ContextDIE = getOrCreateContextDIE(resolve(DT.getContext())); 1940 assert(dwarf::isType(ContextDIE->getTag()) && 1941 "Static member should belong to a type."); 1942 1943 if (DIE *StaticMemberDIE = getDIE(DT)) 1944 return StaticMemberDIE; 1945 1946 DIE &StaticMemberDIE = createAndAddDIE(DT.getTag(), *ContextDIE, DT); 1947 1948 DIType Ty = resolve(DT.getTypeDerivedFrom()); 1949 1950 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName()); 1951 addType(StaticMemberDIE, Ty); 1952 addSourceLine(StaticMemberDIE, DT); 1953 addFlag(StaticMemberDIE, dwarf::DW_AT_external); 1954 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration); 1955 1956 // FIXME: We could omit private if the parent is a class_type, and 1957 // public if the parent is something else. 1958 if (DT.isProtected()) 1959 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1960 dwarf::DW_ACCESS_protected); 1961 else if (DT.isPrivate()) 1962 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1963 dwarf::DW_ACCESS_private); 1964 else 1965 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1966 dwarf::DW_ACCESS_public); 1967 1968 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant())) 1969 addConstantValue(StaticMemberDIE, CI, Ty); 1970 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant())) 1971 addConstantFPValue(StaticMemberDIE, CFP); 1972 1973 return &StaticMemberDIE; 1974} 1975 1976void DwarfUnit::emitHeader(const MCSymbol *ASectionSym) const { 1977 Asm->OutStreamer.AddComment("DWARF version number"); 1978 Asm->EmitInt16(DD->getDwarfVersion()); 1979 Asm->OutStreamer.AddComment("Offset Into Abbrev. Section"); 1980 // We share one abbreviations table across all units so it's always at the 1981 // start of the section. Use a relocatable offset where needed to ensure 1982 // linking doesn't invalidate that offset. 1983 if (ASectionSym) 1984 Asm->EmitSectionOffset(ASectionSym, ASectionSym); 1985 else 1986 // Use a constant value when no symbol is provided. 1987 Asm->EmitInt32(0); 1988 Asm->OutStreamer.AddComment("Address Size (in bytes)"); 1989 Asm->EmitInt8(Asm->getDataLayout().getPointerSize()); 1990} 1991 1992void DwarfUnit::addRange(RangeSpan Range) { 1993 // Only add a range for this unit if we're emitting full debug. 1994 if (getCUNode().getEmissionKind() == DIBuilder::FullDebug) { 1995 // If we have no current ranges just add the range and return, otherwise, 1996 // check the current section and CU against the previous section and CU we 1997 // emitted into and the subprogram was contained within. If these are the 1998 // same then extend our current range, otherwise add this as a new range. 1999 if (CURanges.size() == 0 || 2000 this != DD->getPrevCU() || 2001 Asm->getCurrentSection() != DD->getPrevSection()) { 2002 CURanges.push_back(Range); 2003 return; 2004 } 2005 2006 assert(&(CURanges.back().getEnd()->getSection()) == 2007 &(Range.getEnd()->getSection()) && 2008 "We can only append to a range in the same section!"); 2009 CURanges.back().setEnd(Range.getEnd()); 2010 } 2011} 2012 2013void DwarfCompileUnit::initStmtList(MCSymbol *DwarfLineSectionSym) { 2014 // Define start line table label for each Compile Unit. 2015 MCSymbol *LineTableStartSym = 2016 Asm->OutStreamer.getDwarfLineTableSymbol(getUniqueID()); 2017 2018 stmtListIndex = UnitDie.getValues().size(); 2019 2020 // DW_AT_stmt_list is a offset of line number information for this 2021 // compile unit in debug_line section. For split dwarf this is 2022 // left in the skeleton CU and so not included. 2023 // The line table entries are not always emitted in assembly, so it 2024 // is not okay to use line_table_start here. 2025 if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) 2026 addSectionLabel(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym); 2027 else 2028 addSectionDelta(UnitDie, dwarf::DW_AT_stmt_list, LineTableStartSym, 2029 DwarfLineSectionSym); 2030} 2031 2032void DwarfCompileUnit::applyStmtList(DIE &D) { 2033 D.addValue(dwarf::DW_AT_stmt_list, 2034 UnitDie.getAbbrev().getData()[stmtListIndex].getForm(), 2035 UnitDie.getValues()[stmtListIndex]); 2036} 2037 2038void DwarfTypeUnit::emitHeader(const MCSymbol *ASectionSym) const { 2039 DwarfUnit::emitHeader(ASectionSym); 2040 Asm->OutStreamer.AddComment("Type Signature"); 2041 Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature)); 2042 Asm->OutStreamer.AddComment("Type DIE Offset"); 2043 // In a skeleton type unit there is no type DIE so emit a zero offset. 2044 Asm->OutStreamer.EmitIntValue(Ty ? Ty->getOffset() : 0, 2045 sizeof(Ty->getOffset())); 2046} 2047 2048void DwarfTypeUnit::initSection(const MCSection *Section) { 2049 assert(!this->Section); 2050 this->Section = Section; 2051 // Since each type unit is contained in its own COMDAT section, the begin 2052 // label and the section label are the same. Using the begin label emission in 2053 // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but 2054 // the only other alternative of lazily constructing start-of-section labels 2055 // and storing a mapping in DwarfDebug (or AsmPrinter). 2056 this->SectionSym = this->LabelBegin = 2057 Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID()); 2058 this->LabelEnd = 2059 Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID()); 2060} 2061