1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===// 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 #define DEBUG_TYPE "dwarfdebug" 15 16 #include "DwarfCompileUnit.h" 17 #include "DwarfAccelTable.h" 18 #include "DwarfDebug.h" 19 #include "llvm/ADT/APFloat.h" 20 #include "llvm/DIBuilder.h" 21 #include "llvm/IR/Constants.h" 22 #include "llvm/IR/DataLayout.h" 23 #include "llvm/IR/GlobalVariable.h" 24 #include "llvm/IR/Instructions.h" 25 #include "llvm/Support/Debug.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include "llvm/Target/Mangler.h" 28 #include "llvm/Target/TargetFrameLowering.h" 29 #include "llvm/Target/TargetMachine.h" 30 #include "llvm/Target/TargetRegisterInfo.h" 31 32 using namespace llvm; 33 34 /// CompileUnit - Compile unit constructor. 35 CompileUnit::CompileUnit(unsigned UID, unsigned L, DIE *D, AsmPrinter *A, 36 DwarfDebug *DW, DwarfUnits *DWU) 37 : UniqueID(UID), Language(L), CUDie(D), Asm(A), DD(DW), DU(DWU), 38 IndexTyDie(0), DebugInfoOffset(0) { 39 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1); 40 } 41 42 /// ~CompileUnit - Destructor for compile unit. 43 CompileUnit::~CompileUnit() { 44 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 45 DIEBlocks[j]->~DIEBlock(); 46 } 47 48 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 49 /// information entry. 50 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) { 51 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry); 52 return Value; 53 } 54 55 /// getDefaultLowerBound - Return the default lower bound for an array. If the 56 /// DWARF version doesn't handle the language, return -1. 57 int64_t CompileUnit::getDefaultLowerBound() const { 58 switch (Language) { 59 default: 60 break; 61 62 case dwarf::DW_LANG_C89: 63 case dwarf::DW_LANG_C99: 64 case dwarf::DW_LANG_C: 65 case dwarf::DW_LANG_C_plus_plus: 66 case dwarf::DW_LANG_ObjC: 67 case dwarf::DW_LANG_ObjC_plus_plus: 68 return 0; 69 70 case dwarf::DW_LANG_Fortran77: 71 case dwarf::DW_LANG_Fortran90: 72 case dwarf::DW_LANG_Fortran95: 73 return 1; 74 75 // The languages below have valid values only if the DWARF version >= 4. 76 case dwarf::DW_LANG_Java: 77 case dwarf::DW_LANG_Python: 78 case dwarf::DW_LANG_UPC: 79 case dwarf::DW_LANG_D: 80 if (dwarf::DWARF_VERSION >= 4) 81 return 0; 82 break; 83 84 case dwarf::DW_LANG_Ada83: 85 case dwarf::DW_LANG_Ada95: 86 case dwarf::DW_LANG_Cobol74: 87 case dwarf::DW_LANG_Cobol85: 88 case dwarf::DW_LANG_Modula2: 89 case dwarf::DW_LANG_Pascal83: 90 case dwarf::DW_LANG_PLI: 91 if (dwarf::DWARF_VERSION >= 4) 92 return 1; 93 break; 94 } 95 96 return -1; 97 } 98 99 /// addFlag - Add a flag that is true. 100 void CompileUnit::addFlag(DIE *Die, unsigned Attribute) { 101 if (!DD->useDarwinGDBCompat()) 102 Die->addValue(Attribute, dwarf::DW_FORM_flag_present, 103 DIEIntegerOne); 104 else 105 addUInt(Die, Attribute, dwarf::DW_FORM_flag, 1); 106 } 107 108 /// addUInt - Add an unsigned integer attribute data and value. 109 /// 110 void CompileUnit::addUInt(DIE *Die, unsigned Attribute, 111 unsigned Form, uint64_t Integer) { 112 if (!Form) Form = DIEInteger::BestForm(false, Integer); 113 DIEValue *Value = Integer == 1 ? 114 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer); 115 Die->addValue(Attribute, Form, Value); 116 } 117 118 /// addSInt - Add an signed integer attribute data and value. 119 /// 120 void CompileUnit::addSInt(DIE *Die, unsigned Attribute, 121 unsigned Form, int64_t Integer) { 122 if (!Form) Form = DIEInteger::BestForm(true, Integer); 123 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 124 Die->addValue(Attribute, Form, Value); 125 } 126 127 /// addString - Add a string attribute data and value. We always emit a 128 /// reference to the string pool instead of immediate strings so that DIEs have 129 /// more predictable sizes. In the case of split dwarf we emit an index 130 /// into another table which gets us the static offset into the string 131 /// table. 132 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) { 133 if (!DD->useSplitDwarf()) { 134 MCSymbol *Symb = DU->getStringPoolEntry(String); 135 DIEValue *Value; 136 if (Asm->needsRelocationsForDwarfStringPool()) 137 Value = new (DIEValueAllocator) DIELabel(Symb); 138 else { 139 MCSymbol *StringPool = DU->getStringPoolSym(); 140 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool); 141 } 142 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value); 143 } else { 144 unsigned idx = DU->getStringPoolIndex(String); 145 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx); 146 Die->addValue(Attribute, dwarf::DW_FORM_GNU_str_index, Value); 147 } 148 } 149 150 /// addLocalString - Add a string attribute data and value. This is guaranteed 151 /// to be in the local string pool instead of indirected. 152 void CompileUnit::addLocalString(DIE *Die, unsigned Attribute, 153 StringRef String) { 154 MCSymbol *Symb = DU->getStringPoolEntry(String); 155 DIEValue *Value; 156 if (Asm->needsRelocationsForDwarfStringPool()) 157 Value = new (DIEValueAllocator) DIELabel(Symb); 158 else { 159 MCSymbol *StringPool = DU->getStringPoolSym(); 160 Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool); 161 } 162 Die->addValue(Attribute, dwarf::DW_FORM_strp, Value); 163 } 164 165 /// addLabel - Add a Dwarf label attribute data and value. 166 /// 167 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form, 168 const MCSymbol *Label) { 169 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 170 Die->addValue(Attribute, Form, Value); 171 } 172 173 /// addLabelAddress - Add a dwarf label attribute data and value using 174 /// DW_FORM_addr or DW_FORM_GNU_addr_index. 175 /// 176 void CompileUnit::addLabelAddress(DIE *Die, unsigned Attribute, 177 MCSymbol *Label) { 178 if (!DD->useSplitDwarf()) { 179 if (Label != NULL) { 180 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 181 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value); 182 } else { 183 DIEValue *Value = new (DIEValueAllocator) DIEInteger(0); 184 Die->addValue(Attribute, dwarf::DW_FORM_addr, Value); 185 } 186 } else { 187 unsigned idx = DU->getAddrPoolIndex(Label); 188 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx); 189 Die->addValue(Attribute, dwarf::DW_FORM_GNU_addr_index, Value); 190 } 191 } 192 193 /// addOpAddress - Add a dwarf op address data and value using the 194 /// form given and an op of either DW_FORM_addr or DW_FORM_GNU_addr_index. 195 /// 196 void CompileUnit::addOpAddress(DIE *Die, MCSymbol *Sym) { 197 198 if (!DD->useSplitDwarf()) { 199 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr); 200 addLabel(Die, 0, dwarf::DW_FORM_udata, Sym); 201 } else { 202 unsigned idx = DU->getAddrPoolIndex(Sym); 203 DIEValue *Value = new (DIEValueAllocator) DIEInteger(idx); 204 addUInt(Die, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index); 205 Die->addValue(0, dwarf::DW_FORM_GNU_addr_index, Value); 206 } 207 } 208 209 /// addDelta - Add a label delta attribute data and value. 210 /// 211 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form, 212 const MCSymbol *Hi, const MCSymbol *Lo) { 213 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 214 Die->addValue(Attribute, Form, Value); 215 } 216 217 /// addDIEEntry - Add a DIE attribute data and value. 218 /// 219 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form, 220 DIE *Entry) { 221 Die->addValue(Attribute, Form, createDIEEntry(Entry)); 222 } 223 224 /// addBlock - Add block data. 225 /// 226 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form, 227 DIEBlock *Block) { 228 Block->ComputeSize(Asm); 229 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 230 Die->addValue(Attribute, Block->BestForm(), Block); 231 } 232 233 /// addSourceLine - Add location information to specified debug information 234 /// entry. 235 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) { 236 // Verify variable. 237 if (!V.Verify()) 238 return; 239 240 unsigned Line = V.getLineNumber(); 241 if (Line == 0) 242 return; 243 unsigned FileID = DD->getOrCreateSourceID(V.getContext().getFilename(), 244 V.getContext().getDirectory(), 245 getUniqueID()); 246 assert(FileID && "Invalid file id"); 247 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 248 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 249 } 250 251 /// addSourceLine - Add location information to specified debug information 252 /// entry. 253 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) { 254 // Verify global variable. 255 if (!G.Verify()) 256 return; 257 258 unsigned Line = G.getLineNumber(); 259 if (Line == 0) 260 return; 261 unsigned FileID = DD->getOrCreateSourceID(G.getFilename(), G.getDirectory(), 262 getUniqueID()); 263 assert(FileID && "Invalid file id"); 264 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 265 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 266 } 267 268 /// addSourceLine - Add location information to specified debug information 269 /// entry. 270 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) { 271 // Verify subprogram. 272 if (!SP.Verify()) 273 return; 274 275 // If the line number is 0, don't add it. 276 unsigned Line = SP.getLineNumber(); 277 if (Line == 0) 278 return; 279 280 unsigned FileID = DD->getOrCreateSourceID(SP.getFilename(), 281 SP.getDirectory(), getUniqueID()); 282 assert(FileID && "Invalid file id"); 283 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 284 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 285 } 286 287 /// addSourceLine - Add location information to specified debug information 288 /// entry. 289 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) { 290 // Verify type. 291 if (!Ty.Verify()) 292 return; 293 294 unsigned Line = Ty.getLineNumber(); 295 if (Line == 0) 296 return; 297 unsigned FileID = DD->getOrCreateSourceID(Ty.getFilename(), 298 Ty.getDirectory(), getUniqueID()); 299 assert(FileID && "Invalid file id"); 300 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 301 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 302 } 303 304 /// addSourceLine - Add location information to specified debug information 305 /// entry. 306 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) { 307 // Verify type. 308 if (!Ty.Verify()) 309 return; 310 311 unsigned Line = Ty.getLineNumber(); 312 if (Line == 0) 313 return; 314 DIFile File = Ty.getFile(); 315 unsigned FileID = DD->getOrCreateSourceID(File.getFilename(), 316 File.getDirectory(), getUniqueID()); 317 assert(FileID && "Invalid file id"); 318 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 319 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 320 } 321 322 /// addSourceLine - Add location information to specified debug information 323 /// entry. 324 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) { 325 // Verify namespace. 326 if (!NS.Verify()) 327 return; 328 329 unsigned Line = NS.getLineNumber(); 330 if (Line == 0) 331 return; 332 StringRef FN = NS.getFilename(); 333 334 unsigned FileID = DD->getOrCreateSourceID(FN, NS.getDirectory(), 335 getUniqueID()); 336 assert(FileID && "Invalid file id"); 337 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 338 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 339 } 340 341 /// addVariableAddress - Add DW_AT_location attribute for a 342 /// DbgVariable based on provided MachineLocation. 343 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die, 344 MachineLocation Location) { 345 if (DV->variableHasComplexAddress()) 346 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); 347 else if (DV->isBlockByrefVariable()) 348 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location); 349 else 350 addAddress(Die, dwarf::DW_AT_location, Location); 351 } 352 353 /// addRegisterOp - Add register operand. 354 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) { 355 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 356 unsigned DWReg = RI->getDwarfRegNum(Reg, false); 357 if (DWReg < 32) 358 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg); 359 else { 360 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 361 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg); 362 } 363 } 364 365 /// addRegisterOffset - Add register offset. 366 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg, 367 int64_t Offset) { 368 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 369 unsigned DWReg = RI->getDwarfRegNum(Reg, false); 370 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 371 if (Reg == TRI->getFrameRegister(*Asm->MF)) 372 // If variable offset is based in frame register then use fbreg. 373 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg); 374 else if (DWReg < 32) 375 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg); 376 else { 377 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 378 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg); 379 } 380 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset); 381 } 382 383 /// addAddress - Add an address attribute to a die based on the location 384 /// provided. 385 void CompileUnit::addAddress(DIE *Die, unsigned Attribute, 386 const MachineLocation &Location) { 387 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 388 389 if (Location.isReg()) 390 addRegisterOp(Block, Location.getReg()); 391 else 392 addRegisterOffset(Block, Location.getReg(), Location.getOffset()); 393 394 // Now attach the location information to the DIE. 395 addBlock(Die, Attribute, 0, Block); 396 } 397 398 /// addComplexAddress - Start with the address based on the location provided, 399 /// and generate the DWARF information necessary to find the actual variable 400 /// given the extra address information encoded in the DIVariable, starting from 401 /// the starting location. Add the DWARF information to the die. 402 /// 403 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die, 404 unsigned Attribute, 405 const MachineLocation &Location) { 406 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 407 unsigned N = DV->getNumAddrElements(); 408 unsigned i = 0; 409 if (Location.isReg()) { 410 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) { 411 // If first address element is OpPlus then emit 412 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 413 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1)); 414 i = 2; 415 } else 416 addRegisterOp(Block, Location.getReg()); 417 } 418 else 419 addRegisterOffset(Block, Location.getReg(), Location.getOffset()); 420 421 for (;i < N; ++i) { 422 uint64_t Element = DV->getAddrElement(i); 423 if (Element == DIBuilder::OpPlus) { 424 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 425 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i)); 426 } else if (Element == DIBuilder::OpDeref) { 427 if (!Location.isReg()) 428 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 429 } else llvm_unreachable("unknown DIBuilder Opcode"); 430 } 431 432 // Now attach the location information to the DIE. 433 addBlock(Die, Attribute, 0, Block); 434 } 435 436 /* Byref variables, in Blocks, are declared by the programmer as "SomeType 437 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and 438 gives the variable VarName either the struct, or a pointer to the struct, as 439 its type. This is necessary for various behind-the-scenes things the 440 compiler needs to do with by-reference variables in Blocks. 441 442 However, as far as the original *programmer* is concerned, the variable 443 should still have type 'SomeType', as originally declared. 444 445 The function getBlockByrefType dives into the __Block_byref_x_VarName 446 struct to find the original type of the variable, which is then assigned to 447 the variable's Debug Information Entry as its real type. So far, so good. 448 However now the debugger will expect the variable VarName to have the type 449 SomeType. So we need the location attribute for the variable to be an 450 expression that explains to the debugger how to navigate through the 451 pointers and struct to find the actual variable of type SomeType. 452 453 The following function does just that. We start by getting 454 the "normal" location for the variable. This will be the location 455 of either the struct __Block_byref_x_VarName or the pointer to the 456 struct __Block_byref_x_VarName. 457 458 The struct will look something like: 459 460 struct __Block_byref_x_VarName { 461 ... <various fields> 462 struct __Block_byref_x_VarName *forwarding; 463 ... <various other fields> 464 SomeType VarName; 465 ... <maybe more fields> 466 }; 467 468 If we are given the struct directly (as our starting point) we 469 need to tell the debugger to: 470 471 1). Add the offset of the forwarding field. 472 473 2). Follow that pointer to get the real __Block_byref_x_VarName 474 struct to use (the real one may have been copied onto the heap). 475 476 3). Add the offset for the field VarName, to find the actual variable. 477 478 If we started with a pointer to the struct, then we need to 479 dereference that pointer first, before the other steps. 480 Translating this into DWARF ops, we will need to append the following 481 to the current location description for the variable: 482 483 DW_OP_deref -- optional, if we start with a pointer 484 DW_OP_plus_uconst <forward_fld_offset> 485 DW_OP_deref 486 DW_OP_plus_uconst <varName_fld_offset> 487 488 That is what this function does. */ 489 490 /// addBlockByrefAddress - Start with the address based on the location 491 /// provided, and generate the DWARF information necessary to find the 492 /// actual Block variable (navigating the Block struct) based on the 493 /// starting location. Add the DWARF information to the die. For 494 /// more information, read large comment just above here. 495 /// 496 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die, 497 unsigned Attribute, 498 const MachineLocation &Location) { 499 DIType Ty = DV->getType(); 500 DIType TmpTy = Ty; 501 unsigned Tag = Ty.getTag(); 502 bool isPointer = false; 503 504 StringRef varName = DV->getName(); 505 506 if (Tag == dwarf::DW_TAG_pointer_type) { 507 DIDerivedType DTy = DIDerivedType(Ty); 508 TmpTy = DTy.getTypeDerivedFrom(); 509 isPointer = true; 510 } 511 512 DICompositeType blockStruct = DICompositeType(TmpTy); 513 514 // Find the __forwarding field and the variable field in the __Block_byref 515 // struct. 516 DIArray Fields = blockStruct.getTypeArray(); 517 DIDescriptor varField = DIDescriptor(); 518 DIDescriptor forwardingField = DIDescriptor(); 519 520 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) { 521 DIDescriptor Element = Fields.getElement(i); 522 DIDerivedType DT = DIDerivedType(Element); 523 StringRef fieldName = DT.getName(); 524 if (fieldName == "__forwarding") 525 forwardingField = Element; 526 else if (fieldName == varName) 527 varField = Element; 528 } 529 530 // Get the offsets for the forwarding field and the variable field. 531 unsigned forwardingFieldOffset = 532 DIDerivedType(forwardingField).getOffsetInBits() >> 3; 533 unsigned varFieldOffset = 534 DIDerivedType(varField).getOffsetInBits() >> 3; 535 536 // Decode the original location, and use that as the start of the byref 537 // variable's location. 538 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 539 540 if (Location.isReg()) 541 addRegisterOp(Block, Location.getReg()); 542 else 543 addRegisterOffset(Block, Location.getReg(), Location.getOffset()); 544 545 // If we started with a pointer to the __Block_byref... struct, then 546 // the first thing we need to do is dereference the pointer (DW_OP_deref). 547 if (isPointer) 548 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 549 550 // Next add the offset for the '__forwarding' field: 551 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in 552 // adding the offset if it's 0. 553 if (forwardingFieldOffset > 0) { 554 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 555 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset); 556 } 557 558 // Now dereference the __forwarding field to get to the real __Block_byref 559 // struct: DW_OP_deref. 560 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 561 562 // Now that we've got the real __Block_byref... struct, add the offset 563 // for the variable's field to get to the location of the actual variable: 564 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0. 565 if (varFieldOffset > 0) { 566 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 567 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset); 568 } 569 570 // Now attach the location information to the DIE. 571 addBlock(Die, Attribute, 0, Block); 572 } 573 574 /// isTypeSigned - Return true if the type is signed. 575 static bool isTypeSigned(DIType Ty, int *SizeInBits) { 576 if (Ty.isDerivedType()) 577 return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits); 578 if (Ty.isBasicType()) 579 if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed 580 || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) { 581 *SizeInBits = Ty.getSizeInBits(); 582 return true; 583 } 584 return false; 585 } 586 587 /// addConstantValue - Add constant value entry in variable DIE. 588 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO, 589 DIType Ty) { 590 assert(MO.isImm() && "Invalid machine operand!"); 591 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 592 int SizeInBits = -1; 593 bool SignedConstant = isTypeSigned(Ty, &SizeInBits); 594 unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata; 595 switch (SizeInBits) { 596 case 8: Form = dwarf::DW_FORM_data1; break; 597 case 16: Form = dwarf::DW_FORM_data2; break; 598 case 32: Form = dwarf::DW_FORM_data4; break; 599 case 64: Form = dwarf::DW_FORM_data8; break; 600 default: break; 601 } 602 SignedConstant ? addSInt(Block, 0, Form, MO.getImm()) 603 : addUInt(Block, 0, Form, MO.getImm()); 604 605 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 606 return true; 607 } 608 609 /// addConstantFPValue - Add constant value entry in variable DIE. 610 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) { 611 assert (MO.isFPImm() && "Invalid machine operand!"); 612 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 613 APFloat FPImm = MO.getFPImm()->getValueAPF(); 614 615 // Get the raw data form of the floating point. 616 const APInt FltVal = FPImm.bitcastToAPInt(); 617 const char *FltPtr = (const char*)FltVal.getRawData(); 618 619 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte. 620 bool LittleEndian = Asm->getDataLayout().isLittleEndian(); 621 int Incr = (LittleEndian ? 1 : -1); 622 int Start = (LittleEndian ? 0 : NumBytes - 1); 623 int Stop = (LittleEndian ? NumBytes : -1); 624 625 // Output the constant to DWARF one byte at a time. 626 for (; Start != Stop; Start += Incr) 627 addUInt(Block, 0, dwarf::DW_FORM_data1, 628 (unsigned char)0xFF & FltPtr[Start]); 629 630 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 631 return true; 632 } 633 634 /// addConstantFPValue - Add constant value entry in variable DIE. 635 bool CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) { 636 return addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), false); 637 } 638 639 /// addConstantValue - Add constant value entry in variable DIE. 640 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI, 641 bool Unsigned) { 642 return addConstantValue(Die, CI->getValue(), Unsigned); 643 } 644 645 // addConstantValue - Add constant value entry in variable DIE. 646 bool CompileUnit::addConstantValue(DIE *Die, const APInt &Val, 647 bool Unsigned) { 648 unsigned CIBitWidth = Val.getBitWidth(); 649 if (CIBitWidth <= 64) { 650 unsigned form = 0; 651 switch (CIBitWidth) { 652 case 8: form = dwarf::DW_FORM_data1; break; 653 case 16: form = dwarf::DW_FORM_data2; break; 654 case 32: form = dwarf::DW_FORM_data4; break; 655 case 64: form = dwarf::DW_FORM_data8; break; 656 default: 657 form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata; 658 } 659 if (Unsigned) 660 addUInt(Die, dwarf::DW_AT_const_value, form, Val.getZExtValue()); 661 else 662 addSInt(Die, dwarf::DW_AT_const_value, form, Val.getSExtValue()); 663 return true; 664 } 665 666 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 667 668 // Get the raw data form of the large APInt. 669 const uint64_t *Ptr64 = Val.getRawData(); 670 671 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte. 672 bool LittleEndian = Asm->getDataLayout().isLittleEndian(); 673 674 // Output the constant to DWARF one byte at a time. 675 for (int i = 0; i < NumBytes; i++) { 676 uint8_t c; 677 if (LittleEndian) 678 c = Ptr64[i / 8] >> (8 * (i & 7)); 679 else 680 c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7)); 681 addUInt(Block, 0, dwarf::DW_FORM_data1, c); 682 } 683 684 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 685 return true; 686 } 687 688 /// addTemplateParams - Add template parameters in buffer. 689 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) { 690 // Add template parameters. 691 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) { 692 DIDescriptor Element = TParams.getElement(i); 693 if (Element.isTemplateTypeParameter()) 694 Buffer.addChild(getOrCreateTemplateTypeParameterDIE( 695 DITemplateTypeParameter(Element))); 696 else if (Element.isTemplateValueParameter()) 697 Buffer.addChild(getOrCreateTemplateValueParameterDIE( 698 DITemplateValueParameter(Element))); 699 } 700 } 701 702 /// getOrCreateContextDIE - Get context owner's DIE. 703 DIE *CompileUnit::getOrCreateContextDIE(DIDescriptor Context) { 704 if (Context.isType()) 705 return getOrCreateTypeDIE(DIType(Context)); 706 else if (Context.isNameSpace()) 707 return getOrCreateNameSpace(DINameSpace(Context)); 708 else if (Context.isSubprogram()) 709 return getOrCreateSubprogramDIE(DISubprogram(Context)); 710 else 711 return getDIE(Context); 712 } 713 714 /// addToContextOwner - Add Die into the list of its context owner's children. 715 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) { 716 if (DIE *ContextDIE = getOrCreateContextDIE(Context)) 717 ContextDIE->addChild(Die); 718 else 719 addDie(Die); 720 } 721 722 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 723 /// given DIType. 724 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) { 725 DIType Ty(TyNode); 726 if (!Ty.Verify()) 727 return NULL; 728 DIE *TyDIE = getDIE(Ty); 729 if (TyDIE) 730 return TyDIE; 731 732 // Create new type. 733 TyDIE = new DIE(dwarf::DW_TAG_base_type); 734 insertDIE(Ty, TyDIE); 735 if (Ty.isBasicType()) 736 constructTypeDIE(*TyDIE, DIBasicType(Ty)); 737 else if (Ty.isCompositeType()) 738 constructTypeDIE(*TyDIE, DICompositeType(Ty)); 739 else { 740 assert(Ty.isDerivedType() && "Unknown kind of DIType"); 741 constructTypeDIE(*TyDIE, DIDerivedType(Ty)); 742 } 743 // If this is a named finished type then include it in the list of types 744 // for the accelerator tables. 745 if (!Ty.getName().empty() && !Ty.isForwardDecl()) { 746 bool IsImplementation = 0; 747 if (Ty.isCompositeType()) { 748 DICompositeType CT(Ty); 749 // A runtime language of 0 actually means C/C++ and that any 750 // non-negative value is some version of Objective-C/C++. 751 IsImplementation = (CT.getRunTimeLang() == 0) || 752 CT.isObjcClassComplete(); 753 } 754 unsigned Flags = IsImplementation ? 755 DwarfAccelTable::eTypeFlagClassIsImplementation : 0; 756 addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags)); 757 } 758 759 addToContextOwner(TyDIE, Ty.getContext()); 760 return TyDIE; 761 } 762 763 /// addType - Add a new type attribute to the specified entity. 764 void CompileUnit::addType(DIE *Entity, DIType Ty, unsigned Attribute) { 765 if (!Ty.Verify()) 766 return; 767 768 // Check for pre-existence. 769 DIEEntry *Entry = getDIEEntry(Ty); 770 // If it exists then use the existing value. 771 if (Entry) { 772 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry); 773 return; 774 } 775 776 // Construct type. 777 DIE *Buffer = getOrCreateTypeDIE(Ty); 778 779 // Set up proxy. 780 Entry = createDIEEntry(Buffer); 781 insertDIEEntry(Ty, Entry); 782 Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry); 783 784 // If this is a complete composite type then include it in the 785 // list of global types. 786 addGlobalType(Ty); 787 } 788 789 /// addGlobalType - Add a new global type to the compile unit. 790 /// 791 void CompileUnit::addGlobalType(DIType Ty) { 792 DIDescriptor Context = Ty.getContext(); 793 if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl() 794 && (!Context || Context.isCompileUnit() || Context.isFile() 795 || Context.isNameSpace())) 796 if (DIEEntry *Entry = getDIEEntry(Ty)) 797 GlobalTypes[Ty.getName()] = Entry->getEntry(); 798 } 799 800 /// addPubTypes - Add type for pubtypes section. 801 void CompileUnit::addPubTypes(DISubprogram SP) { 802 DICompositeType SPTy = SP.getType(); 803 unsigned SPTag = SPTy.getTag(); 804 if (SPTag != dwarf::DW_TAG_subroutine_type) 805 return; 806 807 DIArray Args = SPTy.getTypeArray(); 808 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) { 809 DIType ATy(Args.getElement(i)); 810 if (!ATy.Verify()) 811 continue; 812 addGlobalType(ATy); 813 } 814 } 815 816 /// constructTypeDIE - Construct basic type die from DIBasicType. 817 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 818 // Get core information. 819 StringRef Name = BTy.getName(); 820 // Add name if not anonymous or intermediate type. 821 if (!Name.empty()) 822 addString(&Buffer, dwarf::DW_AT_name, Name); 823 824 if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) { 825 Buffer.setTag(dwarf::DW_TAG_unspecified_type); 826 // Unspecified types has only name, nothing else. 827 return; 828 } 829 830 Buffer.setTag(dwarf::DW_TAG_base_type); 831 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 832 BTy.getEncoding()); 833 834 uint64_t Size = BTy.getSizeInBits() >> 3; 835 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 836 } 837 838 /// constructTypeDIE - Construct derived type die from DIDerivedType. 839 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 840 // Get core information. 841 StringRef Name = DTy.getName(); 842 uint64_t Size = DTy.getSizeInBits() >> 3; 843 unsigned Tag = DTy.getTag(); 844 845 // FIXME - Workaround for templates. 846 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type; 847 848 Buffer.setTag(Tag); 849 850 // Map to main type, void will not have a type. 851 DIType FromTy = DTy.getTypeDerivedFrom(); 852 addType(&Buffer, FromTy); 853 854 // Add name if not anonymous or intermediate type. 855 if (!Name.empty()) 856 addString(&Buffer, dwarf::DW_AT_name, Name); 857 858 // Add size if non-zero (derived types might be zero-sized.) 859 if (Size && Tag != dwarf::DW_TAG_pointer_type) 860 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 861 862 if (Tag == dwarf::DW_TAG_ptr_to_member_type) 863 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 864 getOrCreateTypeDIE(DTy.getClassType())); 865 // Add source line info if available and TyDesc is not a forward declaration. 866 if (!DTy.isForwardDecl()) 867 addSourceLine(&Buffer, DTy); 868 } 869 870 /// constructTypeDIE - Construct type DIE from DICompositeType. 871 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 872 // Get core information. 873 StringRef Name = CTy.getName(); 874 875 uint64_t Size = CTy.getSizeInBits() >> 3; 876 unsigned Tag = CTy.getTag(); 877 Buffer.setTag(Tag); 878 879 switch (Tag) { 880 case dwarf::DW_TAG_array_type: 881 constructArrayTypeDIE(Buffer, &CTy); 882 break; 883 case dwarf::DW_TAG_enumeration_type: { 884 DIArray Elements = CTy.getTypeArray(); 885 886 // Add enumerators to enumeration type. 887 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 888 DIE *ElemDie = NULL; 889 DIDescriptor Enum(Elements.getElement(i)); 890 if (Enum.isEnumerator()) { 891 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum)); 892 Buffer.addChild(ElemDie); 893 } 894 } 895 DIType DTy = CTy.getTypeDerivedFrom(); 896 if (DTy.Verify()) { 897 addType(&Buffer, DTy); 898 addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1); 899 } 900 } 901 break; 902 case dwarf::DW_TAG_subroutine_type: { 903 // Add return type. 904 DIArray Elements = CTy.getTypeArray(); 905 DIDescriptor RTy = Elements.getElement(0); 906 addType(&Buffer, DIType(RTy)); 907 908 bool isPrototyped = true; 909 // Add arguments. 910 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) { 911 DIDescriptor Ty = Elements.getElement(i); 912 if (Ty.isUnspecifiedParameter()) { 913 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters); 914 Buffer.addChild(Arg); 915 isPrototyped = false; 916 } else { 917 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 918 addType(Arg, DIType(Ty)); 919 if (DIType(Ty).isArtificial()) 920 addFlag(Arg, dwarf::DW_AT_artificial); 921 Buffer.addChild(Arg); 922 } 923 } 924 // Add prototype flag if we're dealing with a C language and the 925 // function has been prototyped. 926 if (isPrototyped && 927 (Language == dwarf::DW_LANG_C89 || 928 Language == dwarf::DW_LANG_C99 || 929 Language == dwarf::DW_LANG_ObjC)) 930 addFlag(&Buffer, dwarf::DW_AT_prototyped); 931 } 932 break; 933 case dwarf::DW_TAG_structure_type: 934 case dwarf::DW_TAG_union_type: 935 case dwarf::DW_TAG_class_type: { 936 // Add elements to structure type. 937 DIArray Elements = CTy.getTypeArray(); 938 939 // A forward struct declared type may not have elements available. 940 unsigned N = Elements.getNumElements(); 941 if (N == 0) 942 break; 943 944 // Add elements to structure type. 945 for (unsigned i = 0; i < N; ++i) { 946 DIDescriptor Element = Elements.getElement(i); 947 DIE *ElemDie = NULL; 948 if (Element.isSubprogram()) { 949 DISubprogram SP(Element); 950 ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element)); 951 if (SP.isProtected()) 952 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 953 dwarf::DW_ACCESS_protected); 954 else if (SP.isPrivate()) 955 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 956 dwarf::DW_ACCESS_private); 957 else 958 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 959 dwarf::DW_ACCESS_public); 960 if (SP.isExplicit()) 961 addFlag(ElemDie, dwarf::DW_AT_explicit); 962 } else if (Element.isDerivedType()) { 963 DIDerivedType DDTy(Element); 964 if (DDTy.getTag() == dwarf::DW_TAG_friend) { 965 ElemDie = new DIE(dwarf::DW_TAG_friend); 966 addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend); 967 } else if (DDTy.isStaticMember()) 968 ElemDie = createStaticMemberDIE(DDTy); 969 else 970 ElemDie = createMemberDIE(DDTy); 971 } else if (Element.isObjCProperty()) { 972 DIObjCProperty Property(Element); 973 ElemDie = new DIE(Property.getTag()); 974 StringRef PropertyName = Property.getObjCPropertyName(); 975 addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName); 976 addType(ElemDie, Property.getType()); 977 addSourceLine(ElemDie, Property); 978 StringRef GetterName = Property.getObjCPropertyGetterName(); 979 if (!GetterName.empty()) 980 addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName); 981 StringRef SetterName = Property.getObjCPropertySetterName(); 982 if (!SetterName.empty()) 983 addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName); 984 unsigned PropertyAttributes = 0; 985 if (Property.isReadOnlyObjCProperty()) 986 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly; 987 if (Property.isReadWriteObjCProperty()) 988 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite; 989 if (Property.isAssignObjCProperty()) 990 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign; 991 if (Property.isRetainObjCProperty()) 992 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain; 993 if (Property.isCopyObjCProperty()) 994 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy; 995 if (Property.isNonAtomicObjCProperty()) 996 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic; 997 if (PropertyAttributes) 998 addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0, 999 PropertyAttributes); 1000 1001 DIEEntry *Entry = getDIEEntry(Element); 1002 if (!Entry) { 1003 Entry = createDIEEntry(ElemDie); 1004 insertDIEEntry(Element, Entry); 1005 } 1006 } else 1007 continue; 1008 Buffer.addChild(ElemDie); 1009 } 1010 1011 if (CTy.isAppleBlockExtension()) 1012 addFlag(&Buffer, dwarf::DW_AT_APPLE_block); 1013 1014 DICompositeType ContainingType = CTy.getContainingType(); 1015 if (DIDescriptor(ContainingType).isCompositeType()) 1016 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 1017 getOrCreateTypeDIE(DIType(ContainingType))); 1018 else { 1019 DIDescriptor Context = CTy.getContext(); 1020 addToContextOwner(&Buffer, Context); 1021 } 1022 1023 if (CTy.isObjcClassComplete()) 1024 addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type); 1025 1026 // Add template parameters to a class, structure or union types. 1027 // FIXME: The support isn't in the metadata for this yet. 1028 if (Tag == dwarf::DW_TAG_class_type || 1029 Tag == dwarf::DW_TAG_structure_type || 1030 Tag == dwarf::DW_TAG_union_type) 1031 addTemplateParams(Buffer, CTy.getTemplateParams()); 1032 1033 break; 1034 } 1035 default: 1036 break; 1037 } 1038 1039 // Add name if not anonymous or intermediate type. 1040 if (!Name.empty()) 1041 addString(&Buffer, dwarf::DW_AT_name, Name); 1042 1043 if (Tag == dwarf::DW_TAG_enumeration_type || 1044 Tag == dwarf::DW_TAG_class_type || 1045 Tag == dwarf::DW_TAG_structure_type || 1046 Tag == dwarf::DW_TAG_union_type) { 1047 // Add size if non-zero (derived types might be zero-sized.) 1048 // TODO: Do we care about size for enum forward declarations? 1049 if (Size) 1050 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 1051 else if (!CTy.isForwardDecl()) 1052 // Add zero size if it is not a forward declaration. 1053 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0); 1054 1055 // If we're a forward decl, say so. 1056 if (CTy.isForwardDecl()) 1057 addFlag(&Buffer, dwarf::DW_AT_declaration); 1058 1059 // Add source line info if available. 1060 if (!CTy.isForwardDecl()) 1061 addSourceLine(&Buffer, CTy); 1062 1063 // No harm in adding the runtime language to the declaration. 1064 unsigned RLang = CTy.getRunTimeLang(); 1065 if (RLang) 1066 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, 1067 dwarf::DW_FORM_data1, RLang); 1068 } 1069 } 1070 1071 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE 1072 /// for the given DITemplateTypeParameter. 1073 DIE * 1074 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) { 1075 DIE *ParamDIE = getDIE(TP); 1076 if (ParamDIE) 1077 return ParamDIE; 1078 1079 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter); 1080 addType(ParamDIE, TP.getType()); 1081 addString(ParamDIE, dwarf::DW_AT_name, TP.getName()); 1082 return ParamDIE; 1083 } 1084 1085 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE 1086 /// for the given DITemplateValueParameter. 1087 DIE * 1088 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV){ 1089 DIE *ParamDIE = getDIE(TPV); 1090 if (ParamDIE) 1091 return ParamDIE; 1092 1093 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter); 1094 addType(ParamDIE, TPV.getType()); 1095 if (!TPV.getName().empty()) 1096 addString(ParamDIE, dwarf::DW_AT_name, TPV.getName()); 1097 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata, 1098 TPV.getValue()); 1099 return ParamDIE; 1100 } 1101 1102 /// getOrCreateNameSpace - Create a DIE for DINameSpace. 1103 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) { 1104 DIE *NDie = getDIE(NS); 1105 if (NDie) 1106 return NDie; 1107 NDie = new DIE(dwarf::DW_TAG_namespace); 1108 insertDIE(NS, NDie); 1109 if (!NS.getName().empty()) { 1110 addString(NDie, dwarf::DW_AT_name, NS.getName()); 1111 addAccelNamespace(NS.getName(), NDie); 1112 } else 1113 addAccelNamespace("(anonymous namespace)", NDie); 1114 addSourceLine(NDie, NS); 1115 addToContextOwner(NDie, NS.getContext()); 1116 return NDie; 1117 } 1118 1119 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm 1120 /// printer to not emit usual symbol prefix before the symbol name is used then 1121 /// return linkage name after skipping this special LLVM prefix. 1122 static StringRef getRealLinkageName(StringRef LinkageName) { 1123 char One = '\1'; 1124 if (LinkageName.startswith(StringRef(&One, 1))) 1125 return LinkageName.substr(1); 1126 return LinkageName; 1127 } 1128 1129 /// getOrCreateSubprogramDIE - Create new DIE using SP. 1130 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) { 1131 DIE *SPDie = getDIE(SP); 1132 if (SPDie) 1133 return SPDie; 1134 1135 SPDie = new DIE(dwarf::DW_TAG_subprogram); 1136 1137 // DW_TAG_inlined_subroutine may refer to this DIE. 1138 insertDIE(SP, SPDie); 1139 1140 DISubprogram SPDecl = SP.getFunctionDeclaration(); 1141 DIE *DeclDie = NULL; 1142 if (SPDecl.isSubprogram()) { 1143 DeclDie = getOrCreateSubprogramDIE(SPDecl); 1144 } 1145 1146 // Add to context owner. 1147 addToContextOwner(SPDie, SP.getContext()); 1148 1149 // Add function template parameters. 1150 addTemplateParams(*SPDie, SP.getTemplateParams()); 1151 1152 // Unfortunately this code needs to stay here instead of below the 1153 // AT_specification code in order to work around a bug in older 1154 // gdbs that requires the linkage name to resolve multiple template 1155 // functions. 1156 // TODO: Remove this set of code when we get rid of the old gdb 1157 // compatibility. 1158 StringRef LinkageName = SP.getLinkageName(); 1159 if (!LinkageName.empty() && DD->useDarwinGDBCompat()) 1160 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, 1161 getRealLinkageName(LinkageName)); 1162 1163 // If this DIE is going to refer declaration info using AT_specification 1164 // then there is no need to add other attributes. 1165 if (DeclDie) { 1166 // Refer function declaration directly. 1167 addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4, 1168 DeclDie); 1169 1170 return SPDie; 1171 } 1172 1173 // Add the linkage name if we have one. 1174 if (!LinkageName.empty() && !DD->useDarwinGDBCompat()) 1175 addString(SPDie, dwarf::DW_AT_MIPS_linkage_name, 1176 getRealLinkageName(LinkageName)); 1177 1178 // Constructors and operators for anonymous aggregates do not have names. 1179 if (!SP.getName().empty()) 1180 addString(SPDie, dwarf::DW_AT_name, SP.getName()); 1181 1182 addSourceLine(SPDie, SP); 1183 1184 // Add the prototype if we have a prototype and we have a C like 1185 // language. 1186 if (SP.isPrototyped() && 1187 (Language == dwarf::DW_LANG_C89 || 1188 Language == dwarf::DW_LANG_C99 || 1189 Language == dwarf::DW_LANG_ObjC)) 1190 addFlag(SPDie, dwarf::DW_AT_prototyped); 1191 1192 // Add Return Type. 1193 DICompositeType SPTy = SP.getType(); 1194 DIArray Args = SPTy.getTypeArray(); 1195 unsigned SPTag = SPTy.getTag(); 1196 1197 if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type) 1198 addType(SPDie, SPTy); 1199 else 1200 addType(SPDie, DIType(Args.getElement(0))); 1201 1202 unsigned VK = SP.getVirtuality(); 1203 if (VK) { 1204 addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK); 1205 DIEBlock *Block = getDIEBlock(); 1206 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1207 addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex()); 1208 addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block); 1209 ContainingTypeMap.insert(std::make_pair(SPDie, 1210 SP.getContainingType())); 1211 } 1212 1213 if (!SP.isDefinition()) { 1214 addFlag(SPDie, dwarf::DW_AT_declaration); 1215 1216 // Add arguments. Do not add arguments for subprogram definition. They will 1217 // be handled while processing variables. 1218 DICompositeType SPTy = SP.getType(); 1219 DIArray Args = SPTy.getTypeArray(); 1220 unsigned SPTag = SPTy.getTag(); 1221 1222 if (SPTag == dwarf::DW_TAG_subroutine_type) 1223 for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) { 1224 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 1225 DIType ATy = DIType(Args.getElement(i)); 1226 addType(Arg, ATy); 1227 if (ATy.isArtificial()) 1228 addFlag(Arg, dwarf::DW_AT_artificial); 1229 SPDie->addChild(Arg); 1230 } 1231 } 1232 1233 if (SP.isArtificial()) 1234 addFlag(SPDie, dwarf::DW_AT_artificial); 1235 1236 if (!SP.isLocalToUnit()) 1237 addFlag(SPDie, dwarf::DW_AT_external); 1238 1239 if (SP.isOptimized()) 1240 addFlag(SPDie, dwarf::DW_AT_APPLE_optimized); 1241 1242 if (unsigned isa = Asm->getISAEncoding()) { 1243 addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa); 1244 } 1245 1246 return SPDie; 1247 } 1248 1249 // Return const expression if value is a GEP to access merged global 1250 // constant. e.g. 1251 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0) 1252 static const ConstantExpr *getMergedGlobalExpr(const Value *V) { 1253 const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V); 1254 if (!CE || CE->getNumOperands() != 3 || 1255 CE->getOpcode() != Instruction::GetElementPtr) 1256 return NULL; 1257 1258 // First operand points to a global struct. 1259 Value *Ptr = CE->getOperand(0); 1260 if (!isa<GlobalValue>(Ptr) || 1261 !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType())) 1262 return NULL; 1263 1264 // Second operand is zero. 1265 const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1)); 1266 if (!CI || !CI->isZero()) 1267 return NULL; 1268 1269 // Third operand is offset. 1270 if (!isa<ConstantInt>(CE->getOperand(2))) 1271 return NULL; 1272 1273 return CE; 1274 } 1275 1276 /// createGlobalVariableDIE - create global variable DIE. 1277 void CompileUnit::createGlobalVariableDIE(const MDNode *N) { 1278 // Check for pre-existence. 1279 if (getDIE(N)) 1280 return; 1281 1282 DIGlobalVariable GV(N); 1283 if (!GV.Verify()) 1284 return; 1285 1286 DIDescriptor GVContext = GV.getContext(); 1287 DIType GTy = GV.getType(); 1288 1289 // If this is a static data member definition, some attributes belong 1290 // to the declaration DIE. 1291 DIE *VariableDIE = NULL; 1292 bool IsStaticMember = false; 1293 DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration(); 1294 if (SDMDecl.Verify()) { 1295 assert(SDMDecl.isStaticMember() && "Expected static member decl"); 1296 // We need the declaration DIE that is in the static member's class. 1297 // But that class might not exist in the DWARF yet. 1298 // Creating the class will create the static member decl DIE. 1299 getOrCreateContextDIE(SDMDecl.getContext()); 1300 VariableDIE = getDIE(SDMDecl); 1301 assert(VariableDIE && "Static member decl has no context?"); 1302 IsStaticMember = true; 1303 } 1304 1305 // If this is not a static data member definition, create the variable 1306 // DIE and add the initial set of attributes to it. 1307 if (!VariableDIE) { 1308 VariableDIE = new DIE(GV.getTag()); 1309 // Add to map. 1310 insertDIE(N, VariableDIE); 1311 1312 // Add name and type. 1313 addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName()); 1314 addType(VariableDIE, GTy); 1315 1316 // Add scoping info. 1317 if (!GV.isLocalToUnit()) { 1318 addFlag(VariableDIE, dwarf::DW_AT_external); 1319 addGlobalName(GV.getName(), VariableDIE); 1320 } 1321 1322 // Add line number info. 1323 addSourceLine(VariableDIE, GV); 1324 // Add to context owner. 1325 addToContextOwner(VariableDIE, GVContext); 1326 } 1327 1328 // Add location. 1329 bool addToAccelTable = false; 1330 DIE *VariableSpecDIE = NULL; 1331 bool isGlobalVariable = GV.getGlobal() != NULL; 1332 if (isGlobalVariable) { 1333 addToAccelTable = true; 1334 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1335 addOpAddress(Block, Asm->Mang->getSymbol(GV.getGlobal())); 1336 // Do not create specification DIE if context is either compile unit 1337 // or a subprogram. 1338 if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() && 1339 !GVContext.isFile() && !isSubprogramContext(GVContext)) { 1340 // Create specification DIE. 1341 VariableSpecDIE = new DIE(dwarf::DW_TAG_variable); 1342 addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification, 1343 dwarf::DW_FORM_ref4, VariableDIE); 1344 addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block); 1345 // A static member's declaration is already flagged as such. 1346 if (!SDMDecl.Verify()) 1347 addFlag(VariableDIE, dwarf::DW_AT_declaration); 1348 addDie(VariableSpecDIE); 1349 } else { 1350 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 1351 } 1352 // Add linkage name. 1353 StringRef LinkageName = GV.getLinkageName(); 1354 if (!LinkageName.empty()) { 1355 // From DWARF4: DIEs to which DW_AT_linkage_name may apply include: 1356 // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and 1357 // TAG_variable. 1358 addString(IsStaticMember && VariableSpecDIE ? 1359 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name, 1360 getRealLinkageName(LinkageName)); 1361 // In compatibility mode with older gdbs we put the linkage name on both 1362 // the TAG_variable DIE and on the TAG_member DIE. 1363 if (IsStaticMember && VariableSpecDIE && DD->useDarwinGDBCompat()) 1364 addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name, 1365 getRealLinkageName(LinkageName)); 1366 } 1367 } else if (const ConstantInt *CI = 1368 dyn_cast_or_null<ConstantInt>(GV.getConstant())) { 1369 // AT_const_value was added when the static memeber was created. To avoid 1370 // emitting AT_const_value multiple times, we only add AT_const_value when 1371 // it is not a static member. 1372 if (!IsStaticMember) 1373 addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType()); 1374 } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) { 1375 addToAccelTable = true; 1376 // GV is a merged global. 1377 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 1378 Value *Ptr = CE->getOperand(0); 1379 addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr))); 1380 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1381 SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end()); 1382 addUInt(Block, 0, dwarf::DW_FORM_udata, 1383 Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx)); 1384 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1385 addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block); 1386 } 1387 1388 if (addToAccelTable) { 1389 DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE; 1390 addAccelName(GV.getName(), AddrDIE); 1391 1392 // If the linkage name is different than the name, go ahead and output 1393 // that as well into the name table. 1394 if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName()) 1395 addAccelName(GV.getLinkageName(), AddrDIE); 1396 } 1397 1398 return; 1399 } 1400 1401 /// constructSubrangeDIE - Construct subrange DIE from DISubrange. 1402 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, 1403 DIE *IndexTy) { 1404 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type); 1405 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy); 1406 1407 // The LowerBound value defines the lower bounds which is typically zero for 1408 // C/C++. The Count value is the number of elements. Values are 64 bit. If 1409 // Count == -1 then the array is unbounded and we do not emit 1410 // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and 1411 // Count == 0, then the array has zero elements in which case we do not emit 1412 // an upper bound. 1413 int64_t LowerBound = SR.getLo(); 1414 int64_t DefaultLowerBound = getDefaultLowerBound(); 1415 int64_t Count = SR.getCount(); 1416 1417 if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound) 1418 addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound); 1419 1420 if (Count != -1 && Count != 0) 1421 // FIXME: An unbounded array should reference the expression that defines 1422 // the array. 1423 addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1); 1424 1425 Buffer.addChild(DW_Subrange); 1426 } 1427 1428 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 1429 void CompileUnit::constructArrayTypeDIE(DIE &Buffer, 1430 DICompositeType *CTy) { 1431 Buffer.setTag(dwarf::DW_TAG_array_type); 1432 if (CTy->isVector()) 1433 addFlag(&Buffer, dwarf::DW_AT_GNU_vector); 1434 1435 // Emit derived type. 1436 addType(&Buffer, CTy->getTypeDerivedFrom()); 1437 DIArray Elements = CTy->getTypeArray(); 1438 1439 // Get an anonymous type for index type. 1440 // FIXME: This type should be passed down from the front end 1441 // as different languages may have different sizes for indexes. 1442 DIE *IdxTy = getIndexTyDie(); 1443 if (!IdxTy) { 1444 // Construct an anonymous type for index type. 1445 IdxTy = new DIE(dwarf::DW_TAG_base_type); 1446 addString(IdxTy, dwarf::DW_AT_name, "int"); 1447 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t)); 1448 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 1449 dwarf::DW_ATE_signed); 1450 addDie(IdxTy); 1451 setIndexTyDie(IdxTy); 1452 } 1453 1454 // Add subranges to array type. 1455 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 1456 DIDescriptor Element = Elements.getElement(i); 1457 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 1458 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy); 1459 } 1460 } 1461 1462 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 1463 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) { 1464 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator); 1465 StringRef Name = ETy.getName(); 1466 addString(Enumerator, dwarf::DW_AT_name, Name); 1467 int64_t Value = ETy.getEnumValue(); 1468 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value); 1469 return Enumerator; 1470 } 1471 1472 /// constructContainingTypeDIEs - Construct DIEs for types that contain 1473 /// vtables. 1474 void CompileUnit::constructContainingTypeDIEs() { 1475 for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(), 1476 CE = ContainingTypeMap.end(); CI != CE; ++CI) { 1477 DIE *SPDie = CI->first; 1478 const MDNode *N = CI->second; 1479 if (!N) continue; 1480 DIE *NDie = getDIE(N); 1481 if (!NDie) continue; 1482 addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie); 1483 } 1484 } 1485 1486 /// constructVariableDIE - Construct a DIE for the given DbgVariable. 1487 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) { 1488 StringRef Name = DV->getName(); 1489 1490 // Translate tag to proper Dwarf tag. 1491 unsigned Tag = DV->getTag(); 1492 1493 // Define variable debug information entry. 1494 DIE *VariableDie = new DIE(Tag); 1495 DbgVariable *AbsVar = DV->getAbstractVariable(); 1496 DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL; 1497 if (AbsDIE) 1498 addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin, 1499 dwarf::DW_FORM_ref4, AbsDIE); 1500 else { 1501 addString(VariableDie, dwarf::DW_AT_name, Name); 1502 addSourceLine(VariableDie, DV->getVariable()); 1503 addType(VariableDie, DV->getType()); 1504 } 1505 1506 if (DV->isArtificial()) 1507 addFlag(VariableDie, dwarf::DW_AT_artificial); 1508 1509 if (isScopeAbstract) { 1510 DV->setDIE(VariableDie); 1511 return VariableDie; 1512 } 1513 1514 // Add variable address. 1515 1516 unsigned Offset = DV->getDotDebugLocOffset(); 1517 if (Offset != ~0U) { 1518 addLabel(VariableDie, dwarf::DW_AT_location, 1519 dwarf::DW_FORM_data4, 1520 Asm->GetTempSymbol("debug_loc", Offset)); 1521 DV->setDIE(VariableDie); 1522 return VariableDie; 1523 } 1524 1525 // Check if variable is described by a DBG_VALUE instruction. 1526 if (const MachineInstr *DVInsn = DV->getMInsn()) { 1527 bool updated = false; 1528 if (DVInsn->getNumOperands() == 3) { 1529 if (DVInsn->getOperand(0).isReg()) { 1530 const MachineOperand RegOp = DVInsn->getOperand(0); 1531 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 1532 if (DVInsn->getOperand(1).isImm() && 1533 TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) { 1534 unsigned FrameReg = 0; 1535 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering(); 1536 int Offset = 1537 TFI->getFrameIndexReference(*Asm->MF, 1538 DVInsn->getOperand(1).getImm(), 1539 FrameReg); 1540 MachineLocation Location(FrameReg, Offset); 1541 addVariableAddress(DV, VariableDie, Location); 1542 1543 } else if (RegOp.getReg()) 1544 addVariableAddress(DV, VariableDie, 1545 MachineLocation(RegOp.getReg())); 1546 updated = true; 1547 } 1548 else if (DVInsn->getOperand(0).isImm()) 1549 updated = 1550 addConstantValue(VariableDie, DVInsn->getOperand(0), 1551 DV->getType()); 1552 else if (DVInsn->getOperand(0).isFPImm()) 1553 updated = 1554 addConstantFPValue(VariableDie, DVInsn->getOperand(0)); 1555 else if (DVInsn->getOperand(0).isCImm()) 1556 updated = 1557 addConstantValue(VariableDie, 1558 DVInsn->getOperand(0).getCImm(), 1559 DV->getType().isUnsignedDIType()); 1560 } else { 1561 addVariableAddress(DV, VariableDie, 1562 Asm->getDebugValueLocation(DVInsn)); 1563 updated = true; 1564 } 1565 if (!updated) { 1566 // If variableDie is not updated then DBG_VALUE instruction does not 1567 // have valid variable info. 1568 delete VariableDie; 1569 return NULL; 1570 } 1571 DV->setDIE(VariableDie); 1572 return VariableDie; 1573 } else { 1574 // .. else use frame index. 1575 int FI = DV->getFrameIndex(); 1576 if (FI != ~0) { 1577 unsigned FrameReg = 0; 1578 const TargetFrameLowering *TFI = Asm->TM.getFrameLowering(); 1579 int Offset = 1580 TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg); 1581 MachineLocation Location(FrameReg, Offset); 1582 addVariableAddress(DV, VariableDie, Location); 1583 } 1584 } 1585 1586 DV->setDIE(VariableDie); 1587 return VariableDie; 1588 } 1589 1590 /// createMemberDIE - Create new member DIE. 1591 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) { 1592 DIE *MemberDie = new DIE(DT.getTag()); 1593 StringRef Name = DT.getName(); 1594 if (!Name.empty()) 1595 addString(MemberDie, dwarf::DW_AT_name, Name); 1596 1597 addType(MemberDie, DT.getTypeDerivedFrom()); 1598 1599 addSourceLine(MemberDie, DT); 1600 1601 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock(); 1602 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 1603 1604 uint64_t Size = DT.getSizeInBits(); 1605 uint64_t FieldSize = DT.getOriginalTypeSize(); 1606 1607 if (Size != FieldSize) { 1608 // Handle bitfield. 1609 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3); 1610 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits()); 1611 1612 uint64_t Offset = DT.getOffsetInBits(); 1613 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 1614 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 1615 uint64_t FieldOffset = (HiMark - FieldSize); 1616 Offset -= FieldOffset; 1617 1618 // Maybe we need to work from the other end. 1619 if (Asm->getDataLayout().isLittleEndian()) 1620 Offset = FieldSize - (Offset + Size); 1621 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset); 1622 1623 // Here WD_AT_data_member_location points to the anonymous 1624 // field that includes this bit field. 1625 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3); 1626 1627 } else 1628 // This is not a bitfield. 1629 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3); 1630 1631 if (DT.getTag() == dwarf::DW_TAG_inheritance 1632 && DT.isVirtual()) { 1633 1634 // For C++, virtual base classes are not at fixed offset. Use following 1635 // expression to extract appropriate offset from vtable. 1636 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 1637 1638 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock(); 1639 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 1640 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1641 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 1642 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 1643 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 1644 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 1645 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 1646 1647 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, 1648 VBaseLocationDie); 1649 } else 1650 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie); 1651 1652 if (DT.isProtected()) 1653 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1654 dwarf::DW_ACCESS_protected); 1655 else if (DT.isPrivate()) 1656 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1657 dwarf::DW_ACCESS_private); 1658 // Otherwise C++ member and base classes are considered public. 1659 else 1660 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1661 dwarf::DW_ACCESS_public); 1662 if (DT.isVirtual()) 1663 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, 1664 dwarf::DW_VIRTUALITY_virtual); 1665 1666 // Objective-C properties. 1667 if (MDNode *PNode = DT.getObjCProperty()) 1668 if (DIEEntry *PropertyDie = getDIEEntry(PNode)) 1669 MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4, 1670 PropertyDie); 1671 1672 if (DT.isArtificial()) 1673 addFlag(MemberDie, dwarf::DW_AT_artificial); 1674 1675 return MemberDie; 1676 } 1677 1678 /// createStaticMemberDIE - Create new DIE for C++ static member. 1679 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) { 1680 if (!DT.Verify()) 1681 return NULL; 1682 1683 DIE *StaticMemberDIE = new DIE(DT.getTag()); 1684 DIType Ty = DT.getTypeDerivedFrom(); 1685 1686 addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName()); 1687 addType(StaticMemberDIE, Ty); 1688 addSourceLine(StaticMemberDIE, DT); 1689 addFlag(StaticMemberDIE, dwarf::DW_AT_external); 1690 addFlag(StaticMemberDIE, dwarf::DW_AT_declaration); 1691 1692 // FIXME: We could omit private if the parent is a class_type, and 1693 // public if the parent is something else. 1694 if (DT.isProtected()) 1695 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1696 dwarf::DW_ACCESS_protected); 1697 else if (DT.isPrivate()) 1698 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1699 dwarf::DW_ACCESS_private); 1700 else 1701 addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1, 1702 dwarf::DW_ACCESS_public); 1703 1704 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant())) 1705 addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType()); 1706 if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant())) 1707 addConstantFPValue(StaticMemberDIE, CFP); 1708 1709 insertDIE(DT, StaticMemberDIE); 1710 return StaticMemberDIE; 1711 } 1712