lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

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