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   int SizeInBits = -1;
 610   bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
 611   uint16_t Form;
 612
 613   // If we're a signed constant definitely use sdata.
 614   if (SignedConstant) {
 615     addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, MO.getImm());
 616     return;
 617   }
 618
 619   // Else use data for now unless it's larger than we can deal with.
 620   switch (SizeInBits) {
 621   case 8:
 622     Form = dwarf::DW_FORM_data1;
 623     break;
 624   case 16:
 625     Form = dwarf::DW_FORM_data2;
 626     break;
 627   case 32:
 628     Form = dwarf::DW_FORM_data4;
 629     break;
 630   case 64:
 631     Form = dwarf::DW_FORM_data8;
 632     break;
 633   default:
 634     Form = dwarf::DW_FORM_udata;
 635     addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
 636     return;
 637   }
 638   addUInt(Die, dwarf::DW_AT_const_value, Form, MO.getImm());
 639 }
 640
 641 /// addConstantFPValue - Add constant value entry in variable DIE.
 642 void CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
 643   assert (MO.isFPImm() && "Invalid machine operand!");
 644   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 645   APFloat FPImm = MO.getFPImm()->getValueAPF();
 646
 647   // Get the raw data form of the floating point.
 648   const APInt FltVal = FPImm.bitcastToAPInt();
 649   const char *FltPtr = (const char*)FltVal.getRawData();
 650
 651   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 652   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 653   int Incr = (LittleEndian ? 1 : -1);
 654   int Start = (LittleEndian ? 0 : NumBytes - 1);
 655   int Stop = (LittleEndian ? NumBytes : -1);
 656
 657   // Output the constant to DWARF one byte at a time.
 658   for (; Start != Stop; Start += Incr)
 659     addUInt(Block, 0, dwarf::DW_FORM_data1,
 660             (unsigned char)0xFF & FltPtr[Start]);
 661
 662   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 663 }
 664
 665 /// addConstantFPValue - Add constant value entry in variable DIE.
 666 void CompileUnit::addConstantFPValue(DIE *Die, const ConstantFP *CFP) {
 667   // Pass this down to addConstantValue as an unsigned bag of bits.
 668   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 669 }
 670
 671 /// addConstantValue - Add constant value entry in variable DIE.
 672 void CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
 673                                    bool Unsigned) {
 674   addConstantValue(Die, CI->getValue(), Unsigned);
 675 }
 676
 677 // addConstantValue - Add constant value entry in variable DIE.
 678 void CompileUnit::addConstantValue(DIE *Die, const APInt &Val, bool Unsigned) {
 679   unsigned CIBitWidth = Val.getBitWidth();
 680   if (CIBitWidth <= 64) {
 681     // If we're a signed constant definitely use sdata.
 682     if (!Unsigned) {
 683       addSInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
 684               Val.getSExtValue());
 685       return;
 686     }
 687
 688     // Else use data for now unless it's larger than we can deal with.
 689     uint16_t Form;
 690     switch (CIBitWidth) {
 691     case 8:
 692       Form = dwarf::DW_FORM_data1;
 693       break;
 694     case 16:
 695       Form = dwarf::DW_FORM_data2;
 696       break;
 697     case 32:
 698       Form = dwarf::DW_FORM_data4;
 699       break;
 700     case 64:
 701       Form = dwarf::DW_FORM_data8;
 702       break;
 703     default:
 704       addUInt(Die, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 705               Val.getZExtValue());
 706       return;
 707     }
 708     addUInt(Die, dwarf::DW_AT_const_value, Form, Val.getZExtValue());
 709     return;
 710   }
 711
 712   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 713
 714   // Get the raw data form of the large APInt.
 715   const uint64_t *Ptr64 = Val.getRawData();
 716
 717   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 718   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 719
 720   // Output the constant to DWARF one byte at a time.
 721   for (int i = 0; i < NumBytes; i++) {
 722     uint8_t c;
 723     if (LittleEndian)
 724       c = Ptr64[i / 8] >> (8 * (i & 7));
 725     else
 726       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 727     addUInt(Block, 0, dwarf::DW_FORM_data1, c);
 728   }
 729
 730   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 731 }
 732
 733 /// addTemplateParams - Add template parameters into buffer.
 734 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 735   // Add template parameters.
 736   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 737     DIDescriptor Element = TParams.getElement(i);
 738     if (Element.isTemplateTypeParameter())
 739       Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
 740                         DITemplateTypeParameter(Element)));
 741     else if (Element.isTemplateValueParameter())
 742       Buffer.addChild(getOrCreateTemplateValueParameterDIE(
 743                         DITemplateValueParameter(Element)));
 744   }
 745 }
 746
 747 /// getOrCreateContextDIE - Get context owner's DIE.
 748 DIE *CompileUnit::getOrCreateContextDIE(DIDescriptor Context) {
 749   if (Context.isType())
 750     return getOrCreateTypeDIE(DIType(Context));
 751   else if (Context.isNameSpace())
 752     return getOrCreateNameSpace(DINameSpace(Context));
 753   else if (Context.isSubprogram())
 754     return getOrCreateSubprogramDIE(DISubprogram(Context));
 755   else
 756     return getDIE(Context);
 757 }
 758
 759 /// addToContextOwner - Add Die into the list of its context owner's children.
 760 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
 761   if (DIE *ContextDIE = getOrCreateContextDIE(Context))
 762     ContextDIE->addChild(Die);
 763   else
 764     addDie(Die);
 765 }
 766
 767 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 768 /// given DIType.
 769 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 770   DIType Ty(TyNode);
 771   if (!Ty.isType())
 772     return NULL;
 773   DIE *TyDIE = getDIE(Ty);
 774   if (TyDIE)
 775     return TyDIE;
 776
 777   // Create new type.
 778   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 779   insertDIE(Ty, TyDIE);
 780   if (Ty.isBasicType())
 781     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 782   else if (Ty.isCompositeType())
 783     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 784   else {
 785     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 786     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 787   }
 788   // If this is a named finished type then include it in the list of types
 789   // for the accelerator tables.
 790   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 791     bool IsImplementation = 0;
 792     if (Ty.isCompositeType()) {
 793       DICompositeType CT(Ty);
 794       // A runtime language of 0 actually means C/C++ and that any
 795       // non-negative value is some version of Objective-C/C++.
 796       IsImplementation = (CT.getRunTimeLang() == 0) ||
 797         CT.isObjcClassComplete();
 798     }
 799     unsigned Flags = IsImplementation ?
 800                      DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
 801     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
 802   }
 803
 804   addToContextOwner(TyDIE, Ty.getContext());
 805   return TyDIE;
 806 }
 807
 808 /// addType - Add a new type attribute to the specified entity.
 809 void CompileUnit::addType(DIE *Entity, DIType Ty, uint16_t Attribute) {
 810   assert(Ty && "Trying to add a type that doesn't exist?");
 811
 812   // Check for pre-existence.
 813   DIEEntry *Entry = getDIEEntry(Ty);
 814   // If it exists then use the existing value.
 815   if (Entry) {
 816     Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
 817     return;
 818   }
 819
 820   // Construct type.
 821   DIE *Buffer = getOrCreateTypeDIE(Ty);
 822
 823   // Set up proxy.
 824   Entry = createDIEEntry(Buffer);
 825   insertDIEEntry(Ty, Entry);
 826   Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
 827
 828   // If this is a complete composite type then include it in the
 829   // list of global types.
 830   addGlobalType(Ty);
 831 }
 832
 833 /// addGlobalType - Add a new global type to the compile unit.
 834 ///
 835 void CompileUnit::addGlobalType(DIType Ty) {
 836   DIDescriptor Context = Ty.getContext();
 837   if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
 838       && (!Context || Context.isCompileUnit() || Context.isFile()
 839           || Context.isNameSpace()))
 840     if (DIEEntry *Entry = getDIEEntry(Ty))
 841       GlobalTypes[Ty.getName()] = Entry->getEntry();
 842 }
 843
 844 /// addPubTypes - Add type for pubtypes section.
 845 void CompileUnit::addPubTypes(DISubprogram SP) {
 846   DICompositeType SPTy = SP.getType();
 847   uint16_t SPTag = SPTy.getTag();
 848   if (SPTag != dwarf::DW_TAG_subroutine_type)
 849     return;
 850
 851   DIArray Args = SPTy.getTypeArray();
 852   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 853     DIType ATy(Args.getElement(i));
 854     if (!ATy.isType())
 855       continue;
 856     addGlobalType(ATy);
 857   }
 858 }
 859
 860 /// constructTypeDIE - Construct basic type die from DIBasicType.
 861 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 862   // Get core information.
 863   StringRef Name = BTy.getName();
 864   // Add name if not anonymous or intermediate type.
 865   if (!Name.empty())
 866     addString(&Buffer, dwarf::DW_AT_name, Name);
 867
 868   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
 869     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
 870     // An unspecified type only has a name attribute.
 871     return;
 872   }
 873
 874   Buffer.setTag(dwarf::DW_TAG_base_type);
 875   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 876           BTy.getEncoding());
 877
 878   uint64_t Size = BTy.getSizeInBits() >> 3;
 879   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 880 }
 881
 882 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 883 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 884   // Get core information.
 885   StringRef Name = DTy.getName();
 886   uint64_t Size = DTy.getSizeInBits() >> 3;
 887   uint16_t Tag = DTy.getTag();
 888
 889   // FIXME - Workaround for templates.
 890   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 891
 892   Buffer.setTag(Tag);
 893
 894   // Map to main type, void will not have a type.
 895   DIType FromTy = DTy.getTypeDerivedFrom();
 896   if (FromTy)
 897     addType(&Buffer, FromTy);
 898
 899   // Add name if not anonymous or intermediate type.
 900   if (!Name.empty())
 901     addString(&Buffer, dwarf::DW_AT_name, Name);
 902
 903   // Add size if non-zero (derived types might be zero-sized.)
 904   if (Size && Tag != dwarf::DW_TAG_pointer_type)
 905     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 906
 907   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 908       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 909                   getOrCreateTypeDIE(DTy.getClassType()));
 910   // Add source line info if available and TyDesc is not a forward declaration.
 911   if (!DTy.isForwardDecl())
 912     addSourceLine(&Buffer, DTy);
 913 }
 914
 915 /// Return true if the type is appropriately scoped to be contained inside
 916 /// its own type unit.
 917 static bool isTypeUnitScoped(DIType Ty) {
 918   DIScope Parent = Ty.getContext();
 919   while (Parent) {
 920     // Don't generate a hash for anything scoped inside a function.
 921     if (Parent.isSubprogram())
 922       return false;
 923     Parent = Parent.getContext();
 924   }
 925   return true;
 926 }
 927
 928 /// Return true if the type should be split out into a type unit.
 929 static bool shouldCreateTypeUnit(DICompositeType CTy) {
 930   uint16_t Tag = CTy.getTag();
 931
 932   switch (Tag) {
 933   case dwarf::DW_TAG_structure_type:
 934   case dwarf::DW_TAG_union_type:
 935   case dwarf::DW_TAG_enumeration_type:
 936   case dwarf::DW_TAG_class_type:
 937     // If this is a class, structure, union, or enumeration type
 938     // that is not a declaration, is a type definition, and not scoped
 939     // inside a function then separate this out as a type unit.
 940     if (CTy.isForwardDecl() || !isTypeUnitScoped(CTy))
 941       return 0;
 942     return 1;
 943   default:
 944     return 0;
 945   }
 946 }
 947
 948 /// constructTypeDIE - Construct type DIE from DICompositeType.
 949 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 950   // Get core information.
 951   StringRef Name = CTy.getName();
 952
 953   uint64_t Size = CTy.getSizeInBits() >> 3;
 954   uint16_t Tag = CTy.getTag();
 955   Buffer.setTag(Tag);
 956
 957   switch (Tag) {
 958   case dwarf::DW_TAG_array_type:
 959     constructArrayTypeDIE(Buffer, &CTy);
 960     break;
 961   case dwarf::DW_TAG_enumeration_type: {
 962     DIArray Elements = CTy.getTypeArray();
 963
 964     // Add enumerators to enumeration type.
 965     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 966       DIE *ElemDie = NULL;
 967       DIDescriptor Enum(Elements.getElement(i));
 968       if (Enum.isEnumerator()) {
 969         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 970         Buffer.addChild(ElemDie);
 971       }
 972     }
 973     DIType DTy = CTy.getTypeDerivedFrom();
 974     if (DTy) {
 975       addType(&Buffer, DTy);
 976       addUInt(&Buffer, dwarf::DW_AT_enum_class, dwarf::DW_FORM_flag, 1);
 977     }
 978   }
 979     break;
 980   case dwarf::DW_TAG_subroutine_type: {
 981     // Add return type. A void return won't have a type.
 982     DIArray Elements = CTy.getTypeArray();
 983     DIDescriptor RTy = Elements.getElement(0);
 984     if (RTy)
 985       addType(&Buffer, DIType(RTy));
 986
 987     bool isPrototyped = true;
 988     // Add arguments.
 989     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 990       DIDescriptor Ty = Elements.getElement(i);
 991       if (Ty.isUnspecifiedParameter()) {
 992         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
 993         Buffer.addChild(Arg);
 994         isPrototyped = false;
 995       } else {
 996         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 997         addType(Arg, DIType(Ty));
 998         if (DIType(Ty).isArtificial())
 999           addFlag(Arg, dwarf::DW_AT_artificial);
1000         Buffer.addChild(Arg);
1001       }
1002     }
1003     // Add prototype flag if we're dealing with a C language and the
1004     // function has been prototyped.
1005     uint16_t Language = DICompileUnit(Node).getLanguage();
1006     if (isPrototyped &&
1007         (Language == dwarf::DW_LANG_C89 ||
1008          Language == dwarf::DW_LANG_C99 ||
1009          Language == dwarf::DW_LANG_ObjC))
1010       addFlag(&Buffer, dwarf::DW_AT_prototyped);
1011   }
1012     break;
1013   case dwarf::DW_TAG_structure_type:
1014   case dwarf::DW_TAG_union_type:
1015   case dwarf::DW_TAG_class_type: {
1016     // Add elements to structure type.
1017     DIArray Elements = CTy.getTypeArray();
1018     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1019       DIDescriptor Element = Elements.getElement(i);
1020       DIE *ElemDie = NULL;
1021       if (Element.isSubprogram()) {
1022         DISubprogram SP(Element);
1023         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
1024         if (SP.isProtected())
1025           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1026                   dwarf::DW_ACCESS_protected);
1027         else if (SP.isPrivate())
1028           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1029                   dwarf::DW_ACCESS_private);
1030         else
1031           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1032             dwarf::DW_ACCESS_public);
1033         if (SP.isExplicit())
1034           addFlag(ElemDie, dwarf::DW_AT_explicit);
1035       } else if (Element.isDerivedType()) {
1036         DIDerivedType DDTy(Element);
1037         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
1038           ElemDie = new DIE(dwarf::DW_TAG_friend);
1039           addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
1040         } else if (DDTy.isStaticMember())
1041           ElemDie = createStaticMemberDIE(DDTy);
1042         else
1043           ElemDie = createMemberDIE(DDTy);
1044       } else if (Element.isObjCProperty()) {
1045         DIObjCProperty Property(Element);
1046         ElemDie = new DIE(Property.getTag());
1047         StringRef PropertyName = Property.getObjCPropertyName();
1048         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1049         addType(ElemDie, Property.getType());
1050         addSourceLine(ElemDie, Property);
1051         StringRef GetterName = Property.getObjCPropertyGetterName();
1052         if (!GetterName.empty())
1053           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1054         StringRef SetterName = Property.getObjCPropertySetterName();
1055         if (!SetterName.empty())
1056           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1057         unsigned PropertyAttributes = 0;
1058         if (Property.isReadOnlyObjCProperty())
1059           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1060         if (Property.isReadWriteObjCProperty())
1061           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1062         if (Property.isAssignObjCProperty())
1063           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1064         if (Property.isRetainObjCProperty())
1065           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1066         if (Property.isCopyObjCProperty())
1067           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1068         if (Property.isNonAtomicObjCProperty())
1069           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1070         if (PropertyAttributes)
1071           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1072                  PropertyAttributes);
1073
1074         DIEEntry *Entry = getDIEEntry(Element);
1075         if (!Entry) {
1076           Entry = createDIEEntry(ElemDie);
1077           insertDIEEntry(Element, Entry);
1078         }
1079       } else
1080         continue;
1081       Buffer.addChild(ElemDie);
1082     }
1083
1084     if (CTy.isAppleBlockExtension())
1085       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
1086
1087     DICompositeType ContainingType = CTy.getContainingType();
1088     if (DIDescriptor(ContainingType).isCompositeType())
1089       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
1090                   getOrCreateTypeDIE(DIType(ContainingType)));
1091     else
1092       addToContextOwner(&Buffer, CTy.getContext());
1093
1094     if (CTy.isObjcClassComplete())
1095       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
1096
1097     // Add template parameters to a class, structure or union types.
1098     // FIXME: The support isn't in the metadata for this yet.
1099     if (Tag == dwarf::DW_TAG_class_type ||
1100         Tag == dwarf::DW_TAG_structure_type ||
1101         Tag == dwarf::DW_TAG_union_type)
1102       addTemplateParams(Buffer, CTy.getTemplateParams());
1103
1104     break;
1105   }
1106   default:
1107     break;
1108   }
1109
1110   // Add name if not anonymous or intermediate type.
1111   if (!Name.empty())
1112     addString(&Buffer, dwarf::DW_AT_name, Name);
1113
1114   if (Tag == dwarf::DW_TAG_enumeration_type ||
1115       Tag == dwarf::DW_TAG_class_type ||
1116       Tag == dwarf::DW_TAG_structure_type ||
1117       Tag == dwarf::DW_TAG_union_type) {
1118     // Add size if non-zero (derived types might be zero-sized.)
1119     // TODO: Do we care about size for enum forward declarations?
1120     if (Size)
1121       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
1122     else if (!CTy.isForwardDecl())
1123       // Add zero size if it is not a forward declaration.
1124       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
1125
1126     // If we're a forward decl, say so.
1127     if (CTy.isForwardDecl())
1128       addFlag(&Buffer, dwarf::DW_AT_declaration);
1129
1130     // Add source line info if available.
1131     if (!CTy.isForwardDecl())
1132       addSourceLine(&Buffer, CTy);
1133
1134     // No harm in adding the runtime language to the declaration.
1135     unsigned RLang = CTy.getRunTimeLang();
1136     if (RLang)
1137       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
1138               dwarf::DW_FORM_data1, RLang);
1139   }
1140   // If this is a type applicable to a type unit it then add it to the
1141   // list of types we'll compute a hash for later.
1142   if (shouldCreateTypeUnit(CTy))
1143     DD->addTypeUnitType(&Buffer);
1144 }
1145
1146 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
1147 /// for the given DITemplateTypeParameter.
1148 DIE *
1149 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
1150   DIE *ParamDIE = getDIE(TP);
1151   if (ParamDIE)
1152     return ParamDIE;
1153
1154   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
1155   // Add the type if it exists, it could be void and therefore no type.
1156   if (TP.getType())
1157     addType(ParamDIE, TP.getType());
1158   if (!TP.getName().empty())
1159     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
1160   return ParamDIE;
1161 }
1162
1163 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
1164 /// for the given DITemplateValueParameter.
1165 DIE *
1166 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter VP) {
1167   DIE *ParamDIE = getDIE(VP);
1168   if (ParamDIE)
1169     return ParamDIE;
1170
1171   ParamDIE = new DIE(VP.getTag());
1172
1173   // Add the type if there is one, template template and template parameter
1174   // packs will not have a type.
1175   if (VP.getType())
1176     addType(ParamDIE, VP.getType());
1177   if (!VP.getName().empty())
1178     addString(ParamDIE, dwarf::DW_AT_name, VP.getName());
1179   if (Value *Val = VP.getValue()) {
1180     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
1181       addConstantValue(ParamDIE, CI, VP.getType().isUnsignedDIType());
1182     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
1183       // For declaration non-type template parameters (such as global values and
1184       // functions)
1185       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1186       addOpAddress(Block, Asm->Mang->getSymbol(GV));
1187       // Emit DW_OP_stack_value to use the address as the immediate value of the
1188       // parameter, rather than a pointer to it.
1189       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1190       addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
1191     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1192       assert(isa<MDString>(Val));
1193       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1194                 cast<MDString>(Val)->getString());
1195     } else if (VP.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1196       assert(isa<MDNode>(Val));
1197       DIArray A(cast<MDNode>(Val));
1198       addTemplateParams(*ParamDIE, A);
1199     }
1200   }
1201
1202   return ParamDIE;
1203 }
1204
1205 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
1206 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
1207   DIE *NDie = getDIE(NS);
1208   if (NDie)
1209     return NDie;
1210   NDie = new DIE(dwarf::DW_TAG_namespace);
1211   insertDIE(NS, NDie);
1212   if (!NS.getName().empty()) {
1213     addString(NDie, dwarf::DW_AT_name, NS.getName());
1214     addAccelNamespace(NS.getName(), NDie);
1215   } else
1216     addAccelNamespace("(anonymous namespace)", NDie);
1217   addSourceLine(NDie, NS);
1218   addToContextOwner(NDie, NS.getContext());
1219   return NDie;
1220 }
1221
1222 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1223 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1224   DIE *SPDie = getDIE(SP);
1225   if (SPDie)
1226     return SPDie;
1227
1228   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1229
1230   // DW_TAG_inlined_subroutine may refer to this DIE.
1231   insertDIE(SP, SPDie);
1232
1233   DISubprogram SPDecl = SP.getFunctionDeclaration();
1234   DIE *DeclDie = NULL;
1235   if (SPDecl.isSubprogram()) {
1236     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1237   }
1238
1239   // Add to context owner.
1240   addToContextOwner(SPDie, SP.getContext());
1241
1242   // Add function template parameters.
1243   addTemplateParams(*SPDie, SP.getTemplateParams());
1244
1245   // Unfortunately this code needs to stay here instead of below the
1246   // AT_specification code in order to work around a bug in older
1247   // gdbs that requires the linkage name to resolve multiple template
1248   // functions.
1249   // TODO: Remove this set of code when we get rid of the old gdb
1250   // compatibility.
1251   StringRef LinkageName = SP.getLinkageName();
1252   if (!LinkageName.empty() && DD->useDarwinGDBCompat())
1253     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1254               GlobalValue::getRealLinkageName(LinkageName));
1255
1256   // If this DIE is going to refer declaration info using AT_specification
1257   // then there is no need to add other attributes.
1258   if (DeclDie) {
1259     // Refer function declaration directly.
1260     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1261                 DeclDie);
1262
1263     return SPDie;
1264   }
1265
1266   // Add the linkage name if we have one.
1267   if (!LinkageName.empty() && !DD->useDarwinGDBCompat())
1268     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1269               GlobalValue::getRealLinkageName(LinkageName));
1270
1271   // Constructors and operators for anonymous aggregates do not have names.
1272   if (!SP.getName().empty())
1273     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1274
1275   addSourceLine(SPDie, SP);
1276
1277   // Add the prototype if we have a prototype and we have a C like
1278   // language.
1279   uint16_t Language = DICompileUnit(Node).getLanguage();
1280   if (SP.isPrototyped() &&
1281       (Language == dwarf::DW_LANG_C89 ||
1282        Language == dwarf::DW_LANG_C99 ||
1283        Language == dwarf::DW_LANG_ObjC))
1284     addFlag(SPDie, dwarf::DW_AT_prototyped);
1285
1286   // Add Return Type. A void return type will not have a type.
1287   DICompositeType SPTy = SP.getType();
1288   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
1289          "the type of a subprogram should be a subroutine");
1290
1291   DIArray Args = SPTy.getTypeArray();
1292   if (Args.getElement(0))
1293     addType(SPDie, DIType(Args.getElement(0)));
1294
1295   unsigned VK = SP.getVirtuality();
1296   if (VK) {
1297     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1298     DIEBlock *Block = getDIEBlock();
1299     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1300     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1301     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1302     ContainingTypeMap.insert(std::make_pair(SPDie,
1303                                             SP.getContainingType()));
1304   }
1305
1306   if (!SP.isDefinition()) {
1307     addFlag(SPDie, dwarf::DW_AT_declaration);
1308
1309     // Add arguments. Do not add arguments for subprogram definition. They will
1310     // be handled while processing variables.
1311     for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1312       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1313       DIType ATy = DIType(Args.getElement(i));
1314       addType(Arg, ATy);
1315       if (ATy.isArtificial())
1316         addFlag(Arg, dwarf::DW_AT_artificial);
1317       SPDie->addChild(Arg);
1318     }
1319   }
1320
1321   if (SP.isArtificial())
1322     addFlag(SPDie, dwarf::DW_AT_artificial);
1323
1324   if (!SP.isLocalToUnit())
1325     addFlag(SPDie, dwarf::DW_AT_external);
1326
1327   if (SP.isOptimized())
1328     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1329
1330   if (unsigned isa = Asm->getISAEncoding()) {
1331     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1332   }
1333
1334   return SPDie;
1335 }
1336
1337 // Return const expression if value is a GEP to access merged global
1338 // constant. e.g.
1339 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1340 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1341   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1342   if (!CE || CE->getNumOperands() != 3 ||
1343       CE->getOpcode() != Instruction::GetElementPtr)
1344     return NULL;
1345
1346   // First operand points to a global struct.
1347   Value *Ptr = CE->getOperand(0);
1348   if (!isa<GlobalValue>(Ptr) ||
1349       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1350     return NULL;
1351
1352   // Second operand is zero.
1353   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1354   if (!CI || !CI->isZero())
1355     return NULL;
1356
1357   // Third operand is offset.
1358   if (!isa<ConstantInt>(CE->getOperand(2)))
1359     return NULL;
1360
1361   return CE;
1362 }
1363
1364 /// createGlobalVariableDIE - create global variable DIE.
1365 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1366   // Check for pre-existence.
1367   if (getDIE(N))
1368     return;
1369
1370   DIGlobalVariable GV(N);
1371   if (!GV.isGlobalVariable())
1372     return;
1373
1374   DIDescriptor GVContext = GV.getContext();
1375   DIType GTy = GV.getType();
1376
1377   // If this is a static data member definition, some attributes belong
1378   // to the declaration DIE.
1379   DIE *VariableDIE = NULL;
1380   bool IsStaticMember = false;
1381   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
1382   if (SDMDecl.Verify()) {
1383     assert(SDMDecl.isStaticMember() && "Expected static member decl");
1384     // We need the declaration DIE that is in the static member's class.
1385     // But that class might not exist in the DWARF yet.
1386     // Creating the class will create the static member decl DIE.
1387     getOrCreateContextDIE(SDMDecl.getContext());
1388     VariableDIE = getDIE(SDMDecl);
1389     assert(VariableDIE && "Static member decl has no context?");
1390     IsStaticMember = true;
1391   }
1392
1393   // If this is not a static data member definition, create the variable
1394   // DIE and add the initial set of attributes to it.
1395   if (!VariableDIE) {
1396     VariableDIE = new DIE(GV.getTag());
1397     // Add to map.
1398     insertDIE(N, VariableDIE);
1399
1400     // Add name and type.
1401     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1402     addType(VariableDIE, GTy);
1403
1404     // Add scoping info.
1405     if (!GV.isLocalToUnit()) {
1406       addFlag(VariableDIE, dwarf::DW_AT_external);
1407       addGlobalName(GV.getName(), VariableDIE);
1408     }
1409
1410     // Add line number info.
1411     addSourceLine(VariableDIE, GV);
1412     // Add to context owner.
1413     addToContextOwner(VariableDIE, GVContext);
1414   }
1415
1416   // Add location.
1417   bool addToAccelTable = false;
1418   DIE *VariableSpecDIE = NULL;
1419   bool isGlobalVariable = GV.getGlobal() != NULL;
1420   if (isGlobalVariable) {
1421     addToAccelTable = true;
1422     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1423     const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
1424     if (GV.getGlobal()->isThreadLocal()) {
1425       // FIXME: Make this work with -gsplit-dwarf.
1426       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
1427       assert((PointerSize == 4 || PointerSize == 8) &&
1428              "Add support for other sizes if necessary");
1429       const MCExpr *Expr =
1430           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
1431       // Based on GCC's support for TLS:
1432       if (!DD->useSplitDwarf()) {
1433         // 1) Start with a constNu of the appropriate pointer size
1434         addUInt(Block, 0, dwarf::DW_FORM_data1,
1435                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
1436         // 2) containing the (relocated) address of the TLS variable
1437         addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
1438       } else {
1439         addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
1440         addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
1441       }
1442       // 3) followed by a custom OP to tell the debugger about TLS (presumably)
1443       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
1444     } else
1445       addOpAddress(Block, Sym);
1446     // Do not create specification DIE if context is either compile unit
1447     // or a subprogram.
1448     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1449         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1450       // Create specification DIE.
1451       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1452       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1453                   dwarf::DW_FORM_ref4, VariableDIE);
1454       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1455       // A static member's declaration is already flagged as such.
1456       if (!SDMDecl.Verify())
1457         addFlag(VariableDIE, dwarf::DW_AT_declaration);
1458       addDie(VariableSpecDIE);
1459     } else {
1460       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1461     }
1462     // Add linkage name.
1463     StringRef LinkageName = GV.getLinkageName();
1464     if (!LinkageName.empty()) {
1465       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
1466       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
1467       // TAG_variable.
1468       addString(IsStaticMember && VariableSpecDIE ?
1469                 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1470                 GlobalValue::getRealLinkageName(LinkageName));
1471       // In compatibility mode with older gdbs we put the linkage name on both
1472       // the TAG_variable DIE and on the TAG_member DIE.
1473       if (IsStaticMember && VariableSpecDIE && DD->useDarwinGDBCompat())
1474         addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1475                   GlobalValue::getRealLinkageName(LinkageName));
1476     }
1477   } else if (const ConstantInt *CI =
1478              dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
1479     // AT_const_value was added when the static member was created. To avoid
1480     // emitting AT_const_value multiple times, we only add AT_const_value when
1481     // it is not a static member.
1482     if (!IsStaticMember)
1483       addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1484   } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1485     addToAccelTable = true;
1486     // GV is a merged global.
1487     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1488     Value *Ptr = CE->getOperand(0);
1489     addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1490     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1491     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1492     addUInt(Block, 0, dwarf::DW_FORM_udata,
1493                    Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
1494     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1495     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1496   }
1497
1498   if (addToAccelTable) {
1499     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1500     addAccelName(GV.getName(), AddrDIE);
1501
1502     // If the linkage name is different than the name, go ahead and output
1503     // that as well into the name table.
1504     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1505       addAccelName(GV.getLinkageName(), AddrDIE);
1506   }
1507 }
1508
1509 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1510 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
1511                                        DIE *IndexTy) {
1512   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1513   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1514
1515   // The LowerBound value defines the lower bounds which is typically zero for
1516   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1517   // Count == -1 then the array is unbounded and we do not emit
1518   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
1519   // Count == 0, then the array has zero elements in which case we do not emit
1520   // an upper bound.
1521   int64_t LowerBound = SR.getLo();
1522   int64_t DefaultLowerBound = getDefaultLowerBound();
1523   int64_t Count = SR.getCount();
1524
1525   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1526     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
1527
1528   if (Count != -1 && Count != 0)
1529     // FIXME: An unbounded array should reference the expression that defines
1530     // the array.
1531     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
1532
1533   Buffer.addChild(DW_Subrange);
1534 }
1535
1536 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1537 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1538                                         DICompositeType *CTy) {
1539   Buffer.setTag(dwarf::DW_TAG_array_type);
1540   if (CTy->isVector())
1541     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
1542
1543   // Emit the element type.
1544   addType(&Buffer, CTy->getTypeDerivedFrom());
1545
1546   // Get an anonymous type for index type.
1547   // FIXME: This type should be passed down from the front end
1548   // as different languages may have different sizes for indexes.
1549   DIE *IdxTy = getIndexTyDie();
1550   if (!IdxTy) {
1551     // Construct an anonymous type for index type.
1552     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1553     addString(IdxTy, dwarf::DW_AT_name, "int");
1554     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1555     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1556             dwarf::DW_ATE_signed);
1557     addDie(IdxTy);
1558     setIndexTyDie(IdxTy);
1559   }
1560
1561   // Add subranges to array type.
1562   DIArray Elements = CTy->getTypeArray();
1563   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1564     DIDescriptor Element = Elements.getElement(i);
1565     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1566       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1567   }
1568 }
1569
1570 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1571 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1572   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1573   StringRef Name = ETy.getName();
1574   addString(Enumerator, dwarf::DW_AT_name, Name);
1575   int64_t Value = ETy.getEnumValue();
1576   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1577   return Enumerator;
1578 }
1579
1580 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1581 /// vtables.
1582 void CompileUnit::constructContainingTypeDIEs() {
1583   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1584          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1585     DIE *SPDie = CI->first;
1586     const MDNode *N = CI->second;
1587     if (!N) continue;
1588     DIE *NDie = getDIE(N);
1589     if (!NDie) continue;
1590     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1591   }
1592 }
1593
1594 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1595 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
1596                                        bool isScopeAbstract) {
1597   StringRef Name = DV->getName();
1598
1599   // Translate tag to proper Dwarf tag.
1600   uint16_t Tag = DV->getTag();
1601
1602   // Define variable debug information entry.
1603   DIE *VariableDie = new DIE(Tag);
1604   DbgVariable *AbsVar = DV->getAbstractVariable();
1605   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1606   if (AbsDIE)
1607     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1608                             dwarf::DW_FORM_ref4, AbsDIE);
1609   else {
1610     if (!Name.empty())
1611       addString(VariableDie, dwarf::DW_AT_name, Name);
1612     addSourceLine(VariableDie, DV->getVariable());
1613     addType(VariableDie, DV->getType());
1614   }
1615
1616   if (DV->isArtificial())
1617     addFlag(VariableDie, dwarf::DW_AT_artificial);
1618
1619   if (isScopeAbstract) {
1620     DV->setDIE(VariableDie);
1621     return VariableDie;
1622   }
1623
1624   // Add variable address.
1625
1626   unsigned Offset = DV->getDotDebugLocOffset();
1627   if (Offset != ~0U) {
1628     addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
1629              Asm->GetTempSymbol("debug_loc", Offset));
1630     DV->setDIE(VariableDie);
1631     return VariableDie;
1632   }
1633
1634   // Check if variable is described by a DBG_VALUE instruction.
1635   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1636     assert(DVInsn->getNumOperands() == 3);
1637     if (DVInsn->getOperand(0).isReg()) {
1638       const MachineOperand RegOp = DVInsn->getOperand(0);
1639       // If the second operand is an immediate, this is an indirect value.
1640       if (DVInsn->getOperand(1).isImm()) {
1641         MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
1642         addVariableAddress(*DV, VariableDie, Location);
1643       } else if (RegOp.getReg())
1644         addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
1645     } else if (DVInsn->getOperand(0).isImm())
1646       addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
1647     else if (DVInsn->getOperand(0).isFPImm())
1648       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1649     else if (DVInsn->getOperand(0).isCImm())
1650       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
1651                        DV->getType().isUnsignedDIType());
1652
1653     DV->setDIE(VariableDie);
1654     return VariableDie;
1655   } else {
1656     // .. else use frame index.
1657     int FI = DV->getFrameIndex();
1658     if (FI != ~0) {
1659       unsigned FrameReg = 0;
1660       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1661       int Offset =
1662         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1663       MachineLocation Location(FrameReg, Offset);
1664       addVariableAddress(*DV, VariableDie, Location);
1665     }
1666   }
1667
1668   DV->setDIE(VariableDie);
1669   return VariableDie;
1670 }
1671
1672 /// createMemberDIE - Create new member DIE.
1673 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1674   DIE *MemberDie = new DIE(DT.getTag());
1675   StringRef Name = DT.getName();
1676   if (!Name.empty())
1677     addString(MemberDie, dwarf::DW_AT_name, Name);
1678
1679   addType(MemberDie, DT.getTypeDerivedFrom());
1680
1681   addSourceLine(MemberDie, DT);
1682
1683   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1684   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1685
1686   uint64_t Size = DT.getSizeInBits();
1687   uint64_t FieldSize = DT.getOriginalTypeSize();
1688
1689   if (Size != FieldSize) {
1690     // Handle bitfield.
1691     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1692     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1693
1694     uint64_t Offset = DT.getOffsetInBits();
1695     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1696     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1697     uint64_t FieldOffset = (HiMark - FieldSize);
1698     Offset -= FieldOffset;
1699
1700     // Maybe we need to work from the other end.
1701     if (Asm->getDataLayout().isLittleEndian())
1702       Offset = FieldSize - (Offset + Size);
1703     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1704
1705     // Here WD_AT_data_member_location points to the anonymous
1706     // field that includes this bit field.
1707     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1708
1709   } else
1710     // This is not a bitfield.
1711     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1712
1713   if (DT.getTag() == dwarf::DW_TAG_inheritance
1714       && DT.isVirtual()) {
1715
1716     // For C++, virtual base classes are not at fixed offset. Use following
1717     // expression to extract appropriate offset from vtable.
1718     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1719
1720     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1721     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1722     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1723     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1724     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1725     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1726     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1727     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1728
1729     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1730              VBaseLocationDie);
1731   } else
1732     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1733
1734   if (DT.isProtected())
1735     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1736             dwarf::DW_ACCESS_protected);
1737   else if (DT.isPrivate())
1738     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1739             dwarf::DW_ACCESS_private);
1740   // Otherwise C++ member and base classes are considered public.
1741   else
1742     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1743             dwarf::DW_ACCESS_public);
1744   if (DT.isVirtual())
1745     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1746             dwarf::DW_VIRTUALITY_virtual);
1747
1748   // Objective-C properties.
1749   if (MDNode *PNode = DT.getObjCProperty())
1750     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1751       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1752                           PropertyDie);
1753
1754   if (DT.isArtificial())
1755     addFlag(MemberDie, dwarf::DW_AT_artificial);
1756
1757   return MemberDie;
1758 }
1759
1760 /// createStaticMemberDIE - Create new DIE for C++ static member.
1761 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
1762   if (!DT.Verify())
1763     return NULL;
1764
1765   DIE *StaticMemberDIE = new DIE(DT.getTag());
1766   DIType Ty = DT.getTypeDerivedFrom();
1767
1768   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
1769   addType(StaticMemberDIE, Ty);
1770   addSourceLine(StaticMemberDIE, DT);
1771   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1772   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1773
1774   // FIXME: We could omit private if the parent is a class_type, and
1775   // public if the parent is something else.
1776   if (DT.isProtected())
1777     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1778             dwarf::DW_ACCESS_protected);
1779   else if (DT.isPrivate())
1780     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1781             dwarf::DW_ACCESS_private);
1782   else
1783     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1784             dwarf::DW_ACCESS_public);
1785
1786   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
1787     addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
1788   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
1789     addConstantFPValue(StaticMemberDIE, CFP);
1790
1791   insertDIE(DT, StaticMemberDIE);
1792   return StaticMemberDIE;
1793 }