DwarfCompileUnit.cpp revision 201e6cdc39d5dca4e70cdd331f6f5055b3af3534
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 "DwarfCompileUnit.h" 17#include "DwarfDebug.h" 18#include "llvm/Constants.h" 19#include "llvm/Analysis/DIBuilder.h" 20#include "llvm/Target/TargetData.h" 21#include "llvm/Target/TargetFrameLowering.h" 22#include "llvm/Target/TargetMachine.h" 23#include "llvm/Target/TargetRegisterInfo.h" 24#include "llvm/ADT/APFloat.h" 25#include "llvm/Support/ErrorHandling.h" 26 27using namespace llvm; 28 29/// CompileUnit - Compile unit constructor. 30CompileUnit::CompileUnit(unsigned I, DIE *D, AsmPrinter *A, DwarfDebug *DW) 31 : ID(I), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) { 32 DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1); 33} 34 35/// ~CompileUnit - Destructor for compile unit. 36CompileUnit::~CompileUnit() { 37 for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j) 38 DIEBlocks[j]->~DIEBlock(); 39} 40 41/// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug 42/// information entry. 43DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) { 44 DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry); 45 return Value; 46} 47 48/// addUInt - Add an unsigned integer attribute data and value. 49/// 50void CompileUnit::addUInt(DIE *Die, unsigned Attribute, 51 unsigned Form, uint64_t Integer) { 52 if (!Form) Form = DIEInteger::BestForm(false, Integer); 53 DIEValue *Value = Integer == 1 ? 54 DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer); 55 Die->addValue(Attribute, Form, Value); 56} 57 58/// addSInt - Add an signed integer attribute data and value. 59/// 60void CompileUnit::addSInt(DIE *Die, unsigned Attribute, 61 unsigned Form, int64_t Integer) { 62 if (!Form) Form = DIEInteger::BestForm(true, Integer); 63 DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer); 64 Die->addValue(Attribute, Form, Value); 65} 66 67/// addString - Add a string attribute data and value. DIEString only 68/// keeps string reference. 69void CompileUnit::addString(DIE *Die, unsigned Attribute, unsigned Form, 70 StringRef String) { 71 DIEValue *Value = new (DIEValueAllocator) DIEString(String); 72 Die->addValue(Attribute, Form, Value); 73} 74 75/// addLabel - Add a Dwarf label attribute data and value. 76/// 77void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form, 78 const MCSymbol *Label) { 79 DIEValue *Value = new (DIEValueAllocator) DIELabel(Label); 80 Die->addValue(Attribute, Form, Value); 81} 82 83/// addDelta - Add a label delta attribute data and value. 84/// 85void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form, 86 const MCSymbol *Hi, const MCSymbol *Lo) { 87 DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo); 88 Die->addValue(Attribute, Form, Value); 89} 90 91/// addDIEEntry - Add a DIE attribute data and value. 92/// 93void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form, 94 DIE *Entry) { 95 Die->addValue(Attribute, Form, createDIEEntry(Entry)); 96} 97 98 99/// addBlock - Add block data. 100/// 101void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form, 102 DIEBlock *Block) { 103 Block->ComputeSize(Asm); 104 DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on. 105 Die->addValue(Attribute, Block->BestForm(), Block); 106} 107 108/// addSourceLine - Add location information to specified debug information 109/// entry. 110void CompileUnit::addSourceLine(DIE *Die, DIVariable V) { 111 // Verify variable. 112 if (!V.Verify()) 113 return; 114 115 unsigned Line = V.getLineNumber(); 116 if (Line == 0) 117 return; 118 unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(), 119 V.getContext().getDirectory()); 120 assert(FileID && "Invalid file id"); 121 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 122 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 123} 124 125/// addSourceLine - Add location information to specified debug information 126/// entry. 127void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) { 128 // Verify global variable. 129 if (!G.Verify()) 130 return; 131 132 unsigned Line = G.getLineNumber(); 133 if (Line == 0) 134 return; 135 unsigned FileID = DD->GetOrCreateSourceID(G.getContext().getFilename(), 136 G.getContext().getDirectory()); 137 assert(FileID && "Invalid file id"); 138 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 139 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 140} 141 142/// addSourceLine - Add location information to specified debug information 143/// entry. 144void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) { 145 // Verify subprogram. 146 if (!SP.Verify()) 147 return; 148 // If the line number is 0, don't add it. 149 if (SP.getLineNumber() == 0) 150 return; 151 152 unsigned Line = SP.getLineNumber(); 153 if (!SP.getContext().Verify()) 154 return; 155 unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(), SP.getDirectory()); 156 assert(FileID && "Invalid file id"); 157 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 158 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 159} 160 161/// addSourceLine - Add location information to specified debug information 162/// entry. 163void CompileUnit::addSourceLine(DIE *Die, DIType Ty) { 164 // Verify type. 165 if (!Ty.Verify()) 166 return; 167 168 unsigned Line = Ty.getLineNumber(); 169 if (Line == 0 || !Ty.getContext().Verify()) 170 return; 171 unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(), Ty.getDirectory()); 172 assert(FileID && "Invalid file id"); 173 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 174 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 175} 176 177/// addSourceLine - Add location information to specified debug information 178/// entry. 179void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) { 180 // Verify namespace. 181 if (!NS.Verify()) 182 return; 183 184 unsigned Line = NS.getLineNumber(); 185 if (Line == 0) 186 return; 187 StringRef FN = NS.getFilename(); 188 189 unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory()); 190 assert(FileID && "Invalid file id"); 191 addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID); 192 addUInt(Die, dwarf::DW_AT_decl_line, 0, Line); 193} 194 195/// addVariableAddress - Add DW_AT_location attribute for a 196/// DbgVariable based on provided MachineLocation. 197void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die, 198 MachineLocation Location) { 199 if (DV->variableHasComplexAddress()) 200 addComplexAddress(DV, Die, dwarf::DW_AT_location, Location); 201 else if (DV->isBlockByrefVariable()) 202 addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location); 203 else 204 addAddress(Die, dwarf::DW_AT_location, Location); 205} 206 207/// addRegisterOp - Add register operand. 208void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) { 209 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 210 unsigned DWReg = RI->getDwarfRegNum(Reg, false); 211 if (DWReg < 32) 212 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg); 213 else { 214 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 215 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg); 216 } 217} 218 219/// addRegisterOffset - Add register offset. 220void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg, 221 int64_t Offset) { 222 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 223 unsigned DWReg = RI->getDwarfRegNum(Reg, false); 224 const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo(); 225 if (Reg == TRI->getFrameRegister(*Asm->MF)) 226 // If variable offset is based in frame register then use fbreg. 227 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg); 228 else if (DWReg < 32) 229 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg); 230 else { 231 addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 232 addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg); 233 } 234 addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset); 235} 236 237/// addAddress - Add an address attribute to a die based on the location 238/// provided. 239void CompileUnit::addAddress(DIE *Die, unsigned Attribute, 240 const MachineLocation &Location) { 241 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 242 243 if (Location.isReg()) 244 addRegisterOp(Block, Location.getReg()); 245 else 246 addRegisterOffset(Block, Location.getReg(), Location.getOffset()); 247 248 // Now attach the location information to the DIE. 249 addBlock(Die, Attribute, 0, Block); 250} 251 252/// addComplexAddress - Start with the address based on the location provided, 253/// and generate the DWARF information necessary to find the actual variable 254/// given the extra address information encoded in the DIVariable, starting from 255/// the starting location. Add the DWARF information to the die. 256/// 257void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die, 258 unsigned Attribute, 259 const MachineLocation &Location) { 260 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 261 unsigned N = DV->getNumAddrElements(); 262 unsigned i = 0; 263 if (Location.isReg()) { 264 if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) { 265 // If first address element is OpPlus then emit 266 // DW_OP_breg + Offset instead of DW_OP_reg + Offset. 267 addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1)); 268 i = 2; 269 } else 270 addRegisterOp(Block, Location.getReg()); 271 } 272 else 273 addRegisterOffset(Block, Location.getReg(), Location.getOffset()); 274 275 for (;i < N; ++i) { 276 uint64_t Element = DV->getAddrElement(i); 277 if (Element == DIBuilder::OpPlus) { 278 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 279 addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i)); 280 } else if (Element == DIBuilder::OpDeref) { 281 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 282 } else llvm_unreachable("unknown DIBuilder Opcode"); 283 } 284 285 // Now attach the location information to the DIE. 286 addBlock(Die, Attribute, 0, Block); 287} 288 289/* Byref variables, in Blocks, are declared by the programmer as "SomeType 290 VarName;", but the compiler creates a __Block_byref_x_VarName struct, and 291 gives the variable VarName either the struct, or a pointer to the struct, as 292 its type. This is necessary for various behind-the-scenes things the 293 compiler needs to do with by-reference variables in Blocks. 294 295 However, as far as the original *programmer* is concerned, the variable 296 should still have type 'SomeType', as originally declared. 297 298 The function getBlockByrefType dives into the __Block_byref_x_VarName 299 struct to find the original type of the variable, which is then assigned to 300 the variable's Debug Information Entry as its real type. So far, so good. 301 However now the debugger will expect the variable VarName to have the type 302 SomeType. So we need the location attribute for the variable to be an 303 expression that explains to the debugger how to navigate through the 304 pointers and struct to find the actual variable of type SomeType. 305 306 The following function does just that. We start by getting 307 the "normal" location for the variable. This will be the location 308 of either the struct __Block_byref_x_VarName or the pointer to the 309 struct __Block_byref_x_VarName. 310 311 The struct will look something like: 312 313 struct __Block_byref_x_VarName { 314 ... <various fields> 315 struct __Block_byref_x_VarName *forwarding; 316 ... <various other fields> 317 SomeType VarName; 318 ... <maybe more fields> 319 }; 320 321 If we are given the struct directly (as our starting point) we 322 need to tell the debugger to: 323 324 1). Add the offset of the forwarding field. 325 326 2). Follow that pointer to get the real __Block_byref_x_VarName 327 struct to use (the real one may have been copied onto the heap). 328 329 3). Add the offset for the field VarName, to find the actual variable. 330 331 If we started with a pointer to the struct, then we need to 332 dereference that pointer first, before the other steps. 333 Translating this into DWARF ops, we will need to append the following 334 to the current location description for the variable: 335 336 DW_OP_deref -- optional, if we start with a pointer 337 DW_OP_plus_uconst <forward_fld_offset> 338 DW_OP_deref 339 DW_OP_plus_uconst <varName_fld_offset> 340 341 That is what this function does. */ 342 343/// addBlockByrefAddress - Start with the address based on the location 344/// provided, and generate the DWARF information necessary to find the 345/// actual Block variable (navigating the Block struct) based on the 346/// starting location. Add the DWARF information to the die. For 347/// more information, read large comment just above here. 348/// 349void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die, 350 unsigned Attribute, 351 const MachineLocation &Location) { 352 DIType Ty = DV->getType(); 353 DIType TmpTy = Ty; 354 unsigned Tag = Ty.getTag(); 355 bool isPointer = false; 356 357 StringRef varName = DV->getName(); 358 359 if (Tag == dwarf::DW_TAG_pointer_type) { 360 DIDerivedType DTy = DIDerivedType(Ty); 361 TmpTy = DTy.getTypeDerivedFrom(); 362 isPointer = true; 363 } 364 365 DICompositeType blockStruct = DICompositeType(TmpTy); 366 367 // Find the __forwarding field and the variable field in the __Block_byref 368 // struct. 369 DIArray Fields = blockStruct.getTypeArray(); 370 DIDescriptor varField = DIDescriptor(); 371 DIDescriptor forwardingField = DIDescriptor(); 372 373 for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) { 374 DIDescriptor Element = Fields.getElement(i); 375 DIDerivedType DT = DIDerivedType(Element); 376 StringRef fieldName = DT.getName(); 377 if (fieldName == "__forwarding") 378 forwardingField = Element; 379 else if (fieldName == varName) 380 varField = Element; 381 } 382 383 // Get the offsets for the forwarding field and the variable field. 384 unsigned forwardingFieldOffset = 385 DIDerivedType(forwardingField).getOffsetInBits() >> 3; 386 unsigned varFieldOffset = 387 DIDerivedType(varField).getOffsetInBits() >> 3; 388 389 // Decode the original location, and use that as the start of the byref 390 // variable's location. 391 const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo(); 392 unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false); 393 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 394 395 if (Location.isReg()) { 396 if (Reg < 32) 397 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg); 398 else { 399 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx); 400 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 401 } 402 } else { 403 if (Reg < 32) 404 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg); 405 else { 406 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx); 407 addUInt(Block, 0, dwarf::DW_FORM_udata, Reg); 408 } 409 410 addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset()); 411 } 412 413 // If we started with a pointer to the __Block_byref... struct, then 414 // the first thing we need to do is dereference the pointer (DW_OP_deref). 415 if (isPointer) 416 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 417 418 // Next add the offset for the '__forwarding' field: 419 // DW_OP_plus_uconst ForwardingFieldOffset. Note there's no point in 420 // adding the offset if it's 0. 421 if (forwardingFieldOffset > 0) { 422 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 423 addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset); 424 } 425 426 // Now dereference the __forwarding field to get to the real __Block_byref 427 // struct: DW_OP_deref. 428 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 429 430 // Now that we've got the real __Block_byref... struct, add the offset 431 // for the variable's field to get to the location of the actual variable: 432 // DW_OP_plus_uconst varFieldOffset. Again, don't add if it's 0. 433 if (varFieldOffset > 0) { 434 addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 435 addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset); 436 } 437 438 // Now attach the location information to the DIE. 439 addBlock(Die, Attribute, 0, Block); 440} 441 442/// addConstantValue - Add constant value entry in variable DIE. 443bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO) { 444 assert (MO.isImm() && "Invalid machine operand!"); 445 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 446 unsigned Imm = MO.getImm(); 447 addUInt(Block, 0, dwarf::DW_FORM_udata, Imm); 448 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 449 return true; 450} 451 452/// addConstantFPValue - Add constant value entry in variable DIE. 453bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) { 454 assert (MO.isFPImm() && "Invalid machine operand!"); 455 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 456 APFloat FPImm = MO.getFPImm()->getValueAPF(); 457 458 // Get the raw data form of the floating point. 459 const APInt FltVal = FPImm.bitcastToAPInt(); 460 const char *FltPtr = (const char*)FltVal.getRawData(); 461 462 int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte. 463 bool LittleEndian = Asm->getTargetData().isLittleEndian(); 464 int Incr = (LittleEndian ? 1 : -1); 465 int Start = (LittleEndian ? 0 : NumBytes - 1); 466 int Stop = (LittleEndian ? NumBytes : -1); 467 468 // Output the constant to DWARF one byte at a time. 469 for (; Start != Stop; Start += Incr) 470 addUInt(Block, 0, dwarf::DW_FORM_data1, 471 (unsigned char)0xFF & FltPtr[Start]); 472 473 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 474 return true; 475} 476 477/// addConstantValue - Add constant value entry in variable DIE. 478bool CompileUnit::addConstantValue(DIE *Die, ConstantInt *CI, 479 bool Unsigned) { 480 if (CI->getBitWidth() <= 64) { 481 if (Unsigned) 482 addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata, 483 CI->getZExtValue()); 484 else 485 addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, 486 CI->getSExtValue()); 487 return true; 488 } 489 490 DIEBlock *Block = new (DIEValueAllocator) DIEBlock(); 491 492 // Get the raw data form of the large APInt. 493 const APInt Val = CI->getValue(); 494 const char *Ptr = (const char*)Val.getRawData(); 495 496 int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte. 497 bool LittleEndian = Asm->getTargetData().isLittleEndian(); 498 int Incr = (LittleEndian ? 1 : -1); 499 int Start = (LittleEndian ? 0 : NumBytes - 1); 500 int Stop = (LittleEndian ? NumBytes : -1); 501 502 // Output the constant to DWARF one byte at a time. 503 for (; Start != Stop; Start += Incr) 504 addUInt(Block, 0, dwarf::DW_FORM_data1, 505 (unsigned char)0xFF & Ptr[Start]); 506 507 addBlock(Die, dwarf::DW_AT_const_value, 0, Block); 508 return true; 509} 510 511/// addTemplateParams - Add template parameters in buffer. 512void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) { 513 // Add template parameters. 514 for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) { 515 DIDescriptor Element = TParams.getElement(i); 516 if (Element.isTemplateTypeParameter()) 517 Buffer.addChild(getOrCreateTemplateTypeParameterDIE( 518 DITemplateTypeParameter(Element))); 519 else if (Element.isTemplateValueParameter()) 520 Buffer.addChild(getOrCreateTemplateValueParameterDIE( 521 DITemplateValueParameter(Element))); 522 } 523 524} 525/// addToContextOwner - Add Die into the list of its context owner's children. 526void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) { 527 if (Context.isType()) { 528 DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context)); 529 ContextDIE->addChild(Die); 530 } else if (Context.isNameSpace()) { 531 DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context)); 532 ContextDIE->addChild(Die); 533 } else if (Context.isSubprogram()) { 534 DIE *ContextDIE = DD->createSubprogramDIE(DISubprogram(Context)); 535 ContextDIE->addChild(Die); 536 } else if (DIE *ContextDIE = getDIE(Context)) 537 ContextDIE->addChild(Die); 538 else 539 addDie(Die); 540} 541 542/// getOrCreateTypeDIE - Find existing DIE or create new DIE for the 543/// given DIType. 544DIE *CompileUnit::getOrCreateTypeDIE(DIType Ty) { 545 DIE *TyDIE = getDIE(Ty); 546 if (TyDIE) 547 return TyDIE; 548 549 // Create new type. 550 TyDIE = new DIE(dwarf::DW_TAG_base_type); 551 insertDIE(Ty, TyDIE); 552 if (Ty.isBasicType()) 553 constructTypeDIE(*TyDIE, DIBasicType(Ty)); 554 else if (Ty.isCompositeType()) 555 constructTypeDIE(*TyDIE, DICompositeType(Ty)); 556 else { 557 assert(Ty.isDerivedType() && "Unknown kind of DIType"); 558 constructTypeDIE(*TyDIE, DIDerivedType(Ty)); 559 } 560 561 addToContextOwner(TyDIE, Ty.getContext()); 562 return TyDIE; 563} 564 565/// addType - Add a new type attribute to the specified entity. 566void CompileUnit::addType(DIE *Entity, DIType Ty) { 567 if (!Ty.Verify()) 568 return; 569 570 // Check for pre-existence. 571 DIEEntry *Entry = getDIEEntry(Ty); 572 // If it exists then use the existing value. 573 if (Entry) { 574 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 575 return; 576 } 577 578 // Construct type. 579 DIE *Buffer = getOrCreateTypeDIE(Ty); 580 581 // Set up proxy. 582 Entry = createDIEEntry(Buffer); 583 insertDIEEntry(Ty, Entry); 584 585 Entity->addValue(dwarf::DW_AT_type, dwarf::DW_FORM_ref4, Entry); 586} 587 588/// addPubTypes - Add type for pubtypes section. 589void CompileUnit::addPubTypes(DISubprogram SP) { 590 DICompositeType SPTy = SP.getType(); 591 unsigned SPTag = SPTy.getTag(); 592 if (SPTag != dwarf::DW_TAG_subroutine_type) 593 return; 594 595 DIArray Args = SPTy.getTypeArray(); 596 for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) { 597 DIType ATy(Args.getElement(i)); 598 if (!ATy.Verify()) 599 continue; 600 DICompositeType CATy = getDICompositeType(ATy); 601 if (DIDescriptor(CATy).Verify() && !CATy.getName().empty() 602 && !CATy.isForwardDecl()) { 603 if (DIEEntry *Entry = getDIEEntry(CATy)) 604 addGlobalType(CATy.getName(), Entry->getEntry()); 605 } 606 } 607} 608 609/// constructTypeDIE - Construct basic type die from DIBasicType. 610void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) { 611 // Get core information. 612 StringRef Name = BTy.getName(); 613 Buffer.setTag(dwarf::DW_TAG_base_type); 614 addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 615 BTy.getEncoding()); 616 617 // Add name if not anonymous or intermediate type. 618 if (!Name.empty()) 619 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 620 uint64_t Size = BTy.getSizeInBits() >> 3; 621 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 622} 623 624/// constructTypeDIE - Construct derived type die from DIDerivedType. 625void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) { 626 // Get core information. 627 StringRef Name = DTy.getName(); 628 uint64_t Size = DTy.getSizeInBits() >> 3; 629 unsigned Tag = DTy.getTag(); 630 631 // FIXME - Workaround for templates. 632 if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type; 633 634 Buffer.setTag(Tag); 635 636 // Map to main type, void will not have a type. 637 DIType FromTy = DTy.getTypeDerivedFrom(); 638 addType(&Buffer, FromTy); 639 640 // Add name if not anonymous or intermediate type. 641 if (!Name.empty()) 642 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 643 644 // Add size if non-zero (derived types might be zero-sized.) 645 if (Size) 646 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 647 648 // Add source line info if available and TyDesc is not a forward declaration. 649 if (!DTy.isForwardDecl()) 650 addSourceLine(&Buffer, DTy); 651} 652 653/// constructTypeDIE - Construct type DIE from DICompositeType. 654void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) { 655 // Get core information. 656 StringRef Name = CTy.getName(); 657 658 uint64_t Size = CTy.getSizeInBits() >> 3; 659 unsigned Tag = CTy.getTag(); 660 Buffer.setTag(Tag); 661 662 switch (Tag) { 663 case dwarf::DW_TAG_vector_type: 664 case dwarf::DW_TAG_array_type: 665 constructArrayTypeDIE(Buffer, &CTy); 666 break; 667 case dwarf::DW_TAG_enumeration_type: { 668 DIArray Elements = CTy.getTypeArray(); 669 670 // Add enumerators to enumeration type. 671 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 672 DIE *ElemDie = NULL; 673 DIDescriptor Enum(Elements.getElement(i)); 674 if (Enum.isEnumerator()) { 675 ElemDie = constructEnumTypeDIE(DIEnumerator(Enum)); 676 Buffer.addChild(ElemDie); 677 } 678 } 679 } 680 break; 681 case dwarf::DW_TAG_subroutine_type: { 682 // Add return type. 683 DIArray Elements = CTy.getTypeArray(); 684 DIDescriptor RTy = Elements.getElement(0); 685 addType(&Buffer, DIType(RTy)); 686 687 bool isPrototyped = true; 688 // Add arguments. 689 for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) { 690 DIDescriptor Ty = Elements.getElement(i); 691 if (Ty.isUnspecifiedParameter()) { 692 DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters); 693 Buffer.addChild(Arg); 694 isPrototyped = false; 695 } else { 696 DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter); 697 addType(Arg, DIType(Ty)); 698 Buffer.addChild(Arg); 699 } 700 } 701 // Add prototype flag. 702 if (isPrototyped) 703 addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1); 704 } 705 break; 706 case dwarf::DW_TAG_structure_type: 707 case dwarf::DW_TAG_union_type: 708 case dwarf::DW_TAG_class_type: { 709 // Add elements to structure type. 710 DIArray Elements = CTy.getTypeArray(); 711 712 // A forward struct declared type may not have elements available. 713 unsigned N = Elements.getNumElements(); 714 if (N == 0) 715 break; 716 717 // Add elements to structure type. 718 for (unsigned i = 0; i < N; ++i) { 719 DIDescriptor Element = Elements.getElement(i); 720 DIE *ElemDie = NULL; 721 if (Element.isSubprogram()) { 722 DISubprogram SP(Element); 723 ElemDie = DD->createSubprogramDIE(DISubprogram(Element)); 724 if (SP.isProtected()) 725 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 726 dwarf::DW_ACCESS_protected); 727 else if (SP.isPrivate()) 728 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 729 dwarf::DW_ACCESS_private); 730 else 731 addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 732 dwarf::DW_ACCESS_public); 733 if (SP.isExplicit()) 734 addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1); 735 } 736 else if (Element.isVariable()) { 737 DIVariable DV(Element); 738 ElemDie = new DIE(dwarf::DW_TAG_variable); 739 addString(ElemDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, 740 DV.getName()); 741 addType(ElemDie, DV.getType()); 742 addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 743 addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1); 744 addSourceLine(ElemDie, DV); 745 } else if (Element.isDerivedType()) 746 ElemDie = createMemberDIE(DIDerivedType(Element)); 747 else 748 continue; 749 Buffer.addChild(ElemDie); 750 } 751 752 if (CTy.isAppleBlockExtension()) 753 addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1); 754 755 unsigned RLang = CTy.getRunTimeLang(); 756 if (RLang) 757 addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class, 758 dwarf::DW_FORM_data1, RLang); 759 760 DICompositeType ContainingType = CTy.getContainingType(); 761 if (DIDescriptor(ContainingType).isCompositeType()) 762 addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, 763 getOrCreateTypeDIE(DIType(ContainingType))); 764 else { 765 DIDescriptor Context = CTy.getContext(); 766 addToContextOwner(&Buffer, Context); 767 } 768 769 if (CTy.isObjcClassComplete()) 770 addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type, 771 dwarf::DW_FORM_flag, 1); 772 773 if (Tag == dwarf::DW_TAG_class_type) 774 addTemplateParams(Buffer, CTy.getTemplateParams()); 775 776 break; 777 } 778 default: 779 break; 780 } 781 782 // Add name if not anonymous or intermediate type. 783 if (!Name.empty()) 784 addString(&Buffer, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 785 786 if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type 787 || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type) 788 { 789 // Add size if non-zero (derived types might be zero-sized.) 790 if (Size) 791 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size); 792 else { 793 // Add zero size if it is not a forward declaration. 794 if (CTy.isForwardDecl()) 795 addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1); 796 else 797 addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0); 798 } 799 800 // Add source line info if available. 801 if (!CTy.isForwardDecl()) 802 addSourceLine(&Buffer, CTy); 803 } 804} 805 806/// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE 807/// for the given DITemplateTypeParameter. 808DIE * 809CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) { 810 DIE *ParamDIE = getDIE(TP); 811 if (ParamDIE) 812 return ParamDIE; 813 814 ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter); 815 addType(ParamDIE, TP.getType()); 816 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TP.getName()); 817 return ParamDIE; 818} 819 820/// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE 821/// for the given DITemplateValueParameter. 822DIE * 823CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) { 824 DIE *ParamDIE = getDIE(TPV); 825 if (ParamDIE) 826 return ParamDIE; 827 828 ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter); 829 addType(ParamDIE, TPV.getType()); 830 if (!TPV.getName().empty()) 831 addString(ParamDIE, dwarf::DW_AT_name, dwarf::DW_FORM_string, TPV.getName()); 832 addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata, 833 TPV.getValue()); 834 return ParamDIE; 835} 836 837/// getOrCreateNameSpace - Create a DIE for DINameSpace. 838DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) { 839 DIE *NDie = getDIE(NS); 840 if (NDie) 841 return NDie; 842 NDie = new DIE(dwarf::DW_TAG_namespace); 843 insertDIE(NS, NDie); 844 if (!NS.getName().empty()) 845 addString(NDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, NS.getName()); 846 addSourceLine(NDie, NS); 847 addToContextOwner(NDie, NS.getContext()); 848 return NDie; 849} 850 851/// constructSubrangeDIE - Construct subrange DIE from DISubrange. 852void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){ 853 DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type); 854 addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy); 855 int64_t L = SR.getLo(); 856 int64_t H = SR.getHi(); 857 858 // The L value defines the lower bounds which is typically zero for C/C++. The 859 // H value is the upper bounds. Values are 64 bit. H - L + 1 is the size 860 // of the array. If L > H then do not emit DW_AT_lower_bound and 861 // DW_AT_upper_bound attributes. If L is zero and H is also zero then the 862 // array has one element and in such case do not emit lower bound. 863 864 if (L > H) { 865 Buffer.addChild(DW_Subrange); 866 return; 867 } 868 if (L) 869 addSInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L); 870 addSInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H); 871 Buffer.addChild(DW_Subrange); 872} 873 874/// constructArrayTypeDIE - Construct array type DIE from DICompositeType. 875void CompileUnit::constructArrayTypeDIE(DIE &Buffer, 876 DICompositeType *CTy) { 877 Buffer.setTag(dwarf::DW_TAG_array_type); 878 if (CTy->getTag() == dwarf::DW_TAG_vector_type) 879 addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1); 880 881 // Emit derived type. 882 addType(&Buffer, CTy->getTypeDerivedFrom()); 883 DIArray Elements = CTy->getTypeArray(); 884 885 // Get an anonymous type for index type. 886 DIE *IdxTy = getIndexTyDie(); 887 if (!IdxTy) { 888 // Construct an anonymous type for index type. 889 IdxTy = new DIE(dwarf::DW_TAG_base_type); 890 addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t)); 891 addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, 892 dwarf::DW_ATE_signed); 893 addDie(IdxTy); 894 setIndexTyDie(IdxTy); 895 } 896 897 // Add subranges to array type. 898 for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) { 899 DIDescriptor Element = Elements.getElement(i); 900 if (Element.getTag() == dwarf::DW_TAG_subrange_type) 901 constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy); 902 } 903} 904 905/// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator. 906DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) { 907 DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator); 908 StringRef Name = ETy.getName(); 909 addString(Enumerator, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 910 int64_t Value = ETy.getEnumValue(); 911 addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value); 912 return Enumerator; 913} 914 915/// createMemberDIE - Create new member DIE. 916DIE *CompileUnit::createMemberDIE(DIDerivedType DT) { 917 DIE *MemberDie = new DIE(DT.getTag()); 918 StringRef Name = DT.getName(); 919 if (!Name.empty()) 920 addString(MemberDie, dwarf::DW_AT_name, dwarf::DW_FORM_string, Name); 921 922 addType(MemberDie, DT.getTypeDerivedFrom()); 923 924 addSourceLine(MemberDie, DT); 925 926 DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock(); 927 addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst); 928 929 uint64_t Size = DT.getSizeInBits(); 930 uint64_t FieldSize = DT.getOriginalTypeSize(); 931 932 if (Size != FieldSize) { 933 // Handle bitfield. 934 addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3); 935 addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits()); 936 937 uint64_t Offset = DT.getOffsetInBits(); 938 uint64_t AlignMask = ~(DT.getAlignInBits() - 1); 939 uint64_t HiMark = (Offset + FieldSize) & AlignMask; 940 uint64_t FieldOffset = (HiMark - FieldSize); 941 Offset -= FieldOffset; 942 943 // Maybe we need to work from the other end. 944 if (Asm->getTargetData().isLittleEndian()) 945 Offset = FieldSize - (Offset + Size); 946 addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset); 947 948 // Here WD_AT_data_member_location points to the anonymous 949 // field that includes this bit field. 950 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3); 951 952 } else 953 // This is not a bitfield. 954 addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3); 955 956 if (DT.getTag() == dwarf::DW_TAG_inheritance 957 && DT.isVirtual()) { 958 959 // For C++, virtual base classes are not at fixed offset. Use following 960 // expression to extract appropriate offset from vtable. 961 // BaseAddr = ObAddr + *((*ObAddr) - Offset) 962 963 DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock(); 964 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup); 965 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 966 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu); 967 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits()); 968 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus); 969 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref); 970 addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus); 971 972 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, 973 VBaseLocationDie); 974 } else 975 addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie); 976 977 if (DT.isProtected()) 978 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 979 dwarf::DW_ACCESS_protected); 980 else if (DT.isPrivate()) 981 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 982 dwarf::DW_ACCESS_private); 983 // Otherwise C++ member and base classes are considered public. 984 else if (DT.getCompileUnit().getLanguage() == dwarf::DW_LANG_C_plus_plus) 985 addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_flag, 986 dwarf::DW_ACCESS_public); 987 if (DT.isVirtual()) 988 addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_flag, 989 dwarf::DW_VIRTUALITY_virtual); 990 991 // Objective-C properties. 992 StringRef PropertyName = DT.getObjCPropertyName(); 993 if (!PropertyName.empty()) { 994 addString(MemberDie, dwarf::DW_AT_APPLE_property_name, dwarf::DW_FORM_string, 995 PropertyName); 996 StringRef GetterName = DT.getObjCPropertyGetterName(); 997 if (!GetterName.empty()) 998 addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, 999 dwarf::DW_FORM_string, GetterName); 1000 StringRef SetterName = DT.getObjCPropertySetterName(); 1001 if (!SetterName.empty()) 1002 addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, 1003 dwarf::DW_FORM_string, SetterName); 1004 unsigned PropertyAttributes = 0; 1005 if (DT.isReadOnlyObjCProperty()) 1006 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly; 1007 if (DT.isReadWriteObjCProperty()) 1008 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite; 1009 if (DT.isAssignObjCProperty()) 1010 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign; 1011 if (DT.isRetainObjCProperty()) 1012 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain; 1013 if (DT.isCopyObjCProperty()) 1014 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy; 1015 if (DT.isNonAtomicObjCProperty()) 1016 PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic; 1017 if (PropertyAttributes) 1018 addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0, 1019 PropertyAttributes); 1020 } 1021 return MemberDie; 1022} 1023