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