Home | History | Annotate | Download | only in AsmPrinter
      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, unsigned L, DIE *D, const MDNode *N,
     37                          AsmPrinter *A, DwarfDebug *DW, DwarfUnits *DWU)
     38   : UniqueID(UID), Language(L), CUDie(D), Asm(A), DD(DW), DU(DWU),
     39     IndexTyDie(0), 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 (Language) {
     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, unsigned 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, unsigned Attribute,
    113                           unsigned 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, unsigned Attribute,
    123                           unsigned 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, unsigned Attribute, StringRef String) {
    135   DIEValue *Value;
    136   unsigned 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, unsigned 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, unsigned Attribute, unsigned 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, unsigned Attribute, unsigned 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, unsigned 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, unsigned Attribute, unsigned 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, unsigned Attribute, unsigned 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, unsigned Attribute, unsigned 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, unsigned 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                                     unsigned 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                                        unsigned Attribute,
    513                                        const MachineLocation &Location) {
    514   DIType Ty = DV.getType();
    515   DIType TmpTy = Ty;
    516   unsigned 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   unsigned 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, unsigned Attribute) {
    779   if (!Ty.isType())
    780     return;
    781 
    782   // Check for pre-existence.
    783   DIEEntry *Entry = getDIEEntry(Ty);
    784   // If it exists then use the existing value.
    785   if (Entry) {
    786     Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
    787     return;
    788   }
    789 
    790   // Construct type.
    791   DIE *Buffer = getOrCreateTypeDIE(Ty);
    792 
    793   // Set up proxy.
    794   Entry = createDIEEntry(Buffer);
    795   insertDIEEntry(Ty, Entry);
    796   Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
    797 
    798   // If this is a complete composite type then include it in the
    799   // list of global types.
    800   addGlobalType(Ty);
    801 }
    802 
    803 /// addGlobalType - Add a new global type to the compile unit.
    804 ///
    805 void CompileUnit::addGlobalType(DIType Ty) {
    806   DIDescriptor Context = Ty.getContext();
    807   if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
    808       && (!Context || Context.isCompileUnit() || Context.isFile()
    809           || Context.isNameSpace()))
    810     if (DIEEntry *Entry = getDIEEntry(Ty))
    811       GlobalTypes[Ty.getName()] = Entry->getEntry();
    812 }
    813 
    814 /// addPubTypes - Add type for pubtypes section.
    815 void CompileUnit::addPubTypes(DISubprogram SP) {
    816   DICompositeType SPTy = SP.getType();
    817   unsigned SPTag = SPTy.getTag();
    818   if (SPTag != dwarf::DW_TAG_subroutine_type)
    819     return;
    820 
    821   DIArray Args = SPTy.getTypeArray();
    822   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
    823     DIType ATy(Args.getElement(i));
    824     if (!ATy.isType())
    825       continue;
    826     addGlobalType(ATy);
    827   }
    828 }
    829 
    830 /// constructTypeDIE - Construct basic type die from DIBasicType.
    831 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
    832   // Get core information.
    833   StringRef Name = BTy.getName();
    834   // Add name if not anonymous or intermediate type.
    835   if (!Name.empty())
    836     addString(&Buffer, dwarf::DW_AT_name, Name);
    837 
    838   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
    839     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
    840     // An unspecified type only has a name attribute.
    841     return;
    842   }
    843 
    844   Buffer.setTag(dwarf::DW_TAG_base_type);
    845   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
    846           BTy.getEncoding());
    847 
    848   uint64_t Size = BTy.getSizeInBits() >> 3;
    849   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
    850 }
    851 
    852 /// constructTypeDIE - Construct derived type die from DIDerivedType.
    853 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
    854   // Get core information.
    855   StringRef Name = DTy.getName();
    856   uint64_t Size = DTy.getSizeInBits() >> 3;
    857   unsigned Tag = DTy.getTag();
    858 
    859   // FIXME - Workaround for templates.
    860   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
    861 
    862   Buffer.setTag(Tag);
    863 
    864   // Map to main type, void will not have a type.
    865   DIType FromTy = DTy.getTypeDerivedFrom();
    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   unsigned 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   unsigned 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.isType()) {
    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.
    951     DIArray Elements = CTy.getTypeArray();
    952     DIDescriptor RTy = Elements.getElement(0);
    953     addType(&Buffer, DIType(RTy));
    954 
    955     bool isPrototyped = true;
    956     // Add arguments.
    957     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
    958       DIDescriptor Ty = Elements.getElement(i);
    959       if (Ty.isUnspecifiedParameter()) {
    960         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
    961         Buffer.addChild(Arg);
    962         isPrototyped = false;
    963       } else {
    964         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
    965         addType(Arg, DIType(Ty));
    966         if (DIType(Ty).isArtificial())
    967           addFlag(Arg, dwarf::DW_AT_artificial);
    968         Buffer.addChild(Arg);
    969       }
    970     }
    971     // Add prototype flag if we're dealing with a C language and the
    972     // function has been prototyped.
    973     if (isPrototyped &&
    974         (Language == dwarf::DW_LANG_C89 ||
    975          Language == dwarf::DW_LANG_C99 ||
    976          Language == dwarf::DW_LANG_ObjC))
    977       addFlag(&Buffer, dwarf::DW_AT_prototyped);
    978   }
    979     break;
    980   case dwarf::DW_TAG_structure_type:
    981   case dwarf::DW_TAG_union_type:
    982   case dwarf::DW_TAG_class_type: {
    983     if (CTy.isForwardDecl())
    984       break;
    985 
    986     // Add elements to structure type.
    987     DIArray Elements = CTy.getTypeArray();
    988     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
    989       DIDescriptor Element = Elements.getElement(i);
    990       DIE *ElemDie = NULL;
    991       if (Element.isSubprogram()) {
    992         DISubprogram SP(Element);
    993         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
    994         if (SP.isProtected())
    995           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    996                   dwarf::DW_ACCESS_protected);
    997         else if (SP.isPrivate())
    998           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    999                   dwarf::DW_ACCESS_private);
   1000         else
   1001           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
   1002             dwarf::DW_ACCESS_public);
   1003         if (SP.isExplicit())
   1004           addFlag(ElemDie, dwarf::DW_AT_explicit);
   1005       } else if (Element.isDerivedType()) {
   1006         DIDerivedType DDTy(Element);
   1007         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
   1008           ElemDie = new DIE(dwarf::DW_TAG_friend);
   1009           addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
   1010         } else if (DDTy.isStaticMember())
   1011           ElemDie = createStaticMemberDIE(DDTy);
   1012         else
   1013           ElemDie = createMemberDIE(DDTy);
   1014       } else if (Element.isObjCProperty()) {
   1015         DIObjCProperty Property(Element);
   1016         ElemDie = new DIE(Property.getTag());
   1017         StringRef PropertyName = Property.getObjCPropertyName();
   1018         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
   1019         addType(ElemDie, Property.getType());
   1020         addSourceLine(ElemDie, Property);
   1021         StringRef GetterName = Property.getObjCPropertyGetterName();
   1022         if (!GetterName.empty())
   1023           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
   1024         StringRef SetterName = Property.getObjCPropertySetterName();
   1025         if (!SetterName.empty())
   1026           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
   1027         unsigned PropertyAttributes = 0;
   1028         if (Property.isReadOnlyObjCProperty())
   1029           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
   1030         if (Property.isReadWriteObjCProperty())
   1031           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
   1032         if (Property.isAssignObjCProperty())
   1033           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
   1034         if (Property.isRetainObjCProperty())
   1035           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
   1036         if (Property.isCopyObjCProperty())
   1037           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
   1038         if (Property.isNonAtomicObjCProperty())
   1039           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
   1040         if (PropertyAttributes)
   1041           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
   1042                  PropertyAttributes);
   1043 
   1044         DIEEntry *Entry = getDIEEntry(Element);
   1045         if (!Entry) {
   1046           Entry = createDIEEntry(ElemDie);
   1047           insertDIEEntry(Element, Entry);
   1048         }
   1049       } else
   1050         continue;
   1051       Buffer.addChild(ElemDie);
   1052     }
   1053 
   1054     if (CTy.isAppleBlockExtension())
   1055       addFlag(&Buffer, dwarf::DW_AT_APPLE_block);
   1056 
   1057     DICompositeType ContainingType = CTy.getContainingType();
   1058     if (DIDescriptor(ContainingType).isCompositeType())
   1059       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
   1060                   getOrCreateTypeDIE(DIType(ContainingType)));
   1061     else
   1062       addToContextOwner(&Buffer, CTy.getContext());
   1063 
   1064     if (CTy.isObjcClassComplete())
   1065       addFlag(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
   1066 
   1067     // Add template parameters to a class, structure or union types.
   1068     // FIXME: The support isn't in the metadata for this yet.
   1069     if (Tag == dwarf::DW_TAG_class_type ||
   1070         Tag == dwarf::DW_TAG_structure_type ||
   1071         Tag == dwarf::DW_TAG_union_type)
   1072       addTemplateParams(Buffer, CTy.getTemplateParams());
   1073 
   1074     break;
   1075   }
   1076   default:
   1077     break;
   1078   }
   1079 
   1080   // Add name if not anonymous or intermediate type.
   1081   if (!Name.empty())
   1082     addString(&Buffer, dwarf::DW_AT_name, Name);
   1083 
   1084   if (Tag == dwarf::DW_TAG_enumeration_type ||
   1085       Tag == dwarf::DW_TAG_class_type ||
   1086       Tag == dwarf::DW_TAG_structure_type ||
   1087       Tag == dwarf::DW_TAG_union_type) {
   1088     // Add size if non-zero (derived types might be zero-sized.)
   1089     // TODO: Do we care about size for enum forward declarations?
   1090     if (Size)
   1091       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
   1092     else if (!CTy.isForwardDecl())
   1093       // Add zero size if it is not a forward declaration.
   1094       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
   1095 
   1096     // If we're a forward decl, say so.
   1097     if (CTy.isForwardDecl())
   1098       addFlag(&Buffer, dwarf::DW_AT_declaration);
   1099 
   1100     // Add source line info if available.
   1101     if (!CTy.isForwardDecl())
   1102       addSourceLine(&Buffer, CTy);
   1103 
   1104     // No harm in adding the runtime language to the declaration.
   1105     unsigned RLang = CTy.getRunTimeLang();
   1106     if (RLang)
   1107       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
   1108               dwarf::DW_FORM_data1, RLang);
   1109   }
   1110   // If this is a type applicable to a type unit it then add it to the
   1111   // list of types we'll compute a hash for later.
   1112   if (shouldCreateTypeUnit(CTy))
   1113     DD->addTypeUnitType(&Buffer);
   1114 }
   1115 
   1116 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
   1117 /// for the given DITemplateTypeParameter.
   1118 DIE *
   1119 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
   1120   DIE *ParamDIE = getDIE(TP);
   1121   if (ParamDIE)
   1122     return ParamDIE;
   1123 
   1124   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
   1125   addType(ParamDIE, TP.getType());
   1126   if (!TP.getName().empty())
   1127     addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
   1128   return ParamDIE;
   1129 }
   1130 
   1131 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
   1132 /// for the given DITemplateValueParameter.
   1133 DIE *
   1134 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV){
   1135   DIE *ParamDIE = getDIE(TPV);
   1136   if (ParamDIE)
   1137     return ParamDIE;
   1138 
   1139   ParamDIE = new DIE(TPV.getTag());
   1140   addType(ParamDIE, TPV.getType());
   1141   if (!TPV.getName().empty())
   1142     addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
   1143   if (Value *Val = TPV.getValue()) {
   1144     if (ConstantInt *CI = dyn_cast<ConstantInt>(Val))
   1145       addConstantValue(ParamDIE, CI, TPV.getType().isUnsignedDIType());
   1146     else if (GlobalValue *GV = dyn_cast<GlobalValue>(Val)) {
   1147       // For declaration non-type template parameters (such as global values and
   1148       // functions)
   1149       DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   1150       addOpAddress(Block, Asm->Mang->getSymbol(GV));
   1151       // Emit DW_OP_stack_value to use the address as the immediate value of the
   1152       // parameter, rather than a pointer to it.
   1153       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
   1154       addBlock(ParamDIE, dwarf::DW_AT_location, 0, Block);
   1155     } else if (TPV.getTag() == dwarf::DW_TAG_GNU_template_template_param) {
   1156       assert(isa<MDString>(Val));
   1157       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
   1158                 cast<MDString>(Val)->getString());
   1159     } else if (TPV.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
   1160       assert(isa<MDNode>(Val));
   1161       DIArray A(cast<MDNode>(Val));
   1162       addTemplateParams(*ParamDIE, A);
   1163     }
   1164   }
   1165 
   1166   return ParamDIE;
   1167 }
   1168 
   1169 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
   1170 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
   1171   DIE *NDie = getDIE(NS);
   1172   if (NDie)
   1173     return NDie;
   1174   NDie = new DIE(dwarf::DW_TAG_namespace);
   1175   insertDIE(NS, NDie);
   1176   if (!NS.getName().empty()) {
   1177     addString(NDie, dwarf::DW_AT_name, NS.getName());
   1178     addAccelNamespace(NS.getName(), NDie);
   1179   } else
   1180     addAccelNamespace("(anonymous namespace)", NDie);
   1181   addSourceLine(NDie, NS);
   1182   addToContextOwner(NDie, NS.getContext());
   1183   return NDie;
   1184 }
   1185 
   1186 /// getOrCreateSubprogramDIE - Create new DIE using SP.
   1187 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
   1188   DIE *SPDie = getDIE(SP);
   1189   if (SPDie)
   1190     return SPDie;
   1191 
   1192   SPDie = new DIE(dwarf::DW_TAG_subprogram);
   1193 
   1194   // DW_TAG_inlined_subroutine may refer to this DIE.
   1195   insertDIE(SP, SPDie);
   1196 
   1197   DISubprogram SPDecl = SP.getFunctionDeclaration();
   1198   DIE *DeclDie = NULL;
   1199   if (SPDecl.isSubprogram()) {
   1200     DeclDie = getOrCreateSubprogramDIE(SPDecl);
   1201   }
   1202 
   1203   // Add to context owner.
   1204   addToContextOwner(SPDie, SP.getContext());
   1205 
   1206   // Add function template parameters.
   1207   addTemplateParams(*SPDie, SP.getTemplateParams());
   1208 
   1209   // Unfortunately this code needs to stay here instead of below the
   1210   // AT_specification code in order to work around a bug in older
   1211   // gdbs that requires the linkage name to resolve multiple template
   1212   // functions.
   1213   // TODO: Remove this set of code when we get rid of the old gdb
   1214   // compatibility.
   1215   StringRef LinkageName = SP.getLinkageName();
   1216   if (!LinkageName.empty() && DD->useDarwinGDBCompat())
   1217     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
   1218               GlobalValue::getRealLinkageName(LinkageName));
   1219 
   1220   // If this DIE is going to refer declaration info using AT_specification
   1221   // then there is no need to add other attributes.
   1222   if (DeclDie) {
   1223     // Refer function declaration directly.
   1224     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
   1225                 DeclDie);
   1226 
   1227     return SPDie;
   1228   }
   1229 
   1230   // Add the linkage name if we have one.
   1231   if (!LinkageName.empty() && !DD->useDarwinGDBCompat())
   1232     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
   1233               GlobalValue::getRealLinkageName(LinkageName));
   1234 
   1235   // Constructors and operators for anonymous aggregates do not have names.
   1236   if (!SP.getName().empty())
   1237     addString(SPDie, dwarf::DW_AT_name, SP.getName());
   1238 
   1239   addSourceLine(SPDie, SP);
   1240 
   1241   // Add the prototype if we have a prototype and we have a C like
   1242   // language.
   1243   if (SP.isPrototyped() &&
   1244       (Language == dwarf::DW_LANG_C89 ||
   1245        Language == dwarf::DW_LANG_C99 ||
   1246        Language == dwarf::DW_LANG_ObjC))
   1247     addFlag(SPDie, dwarf::DW_AT_prototyped);
   1248 
   1249   // Add Return Type.
   1250   DICompositeType SPTy = SP.getType();
   1251   assert(SPTy.getTag() == dwarf::DW_TAG_subroutine_type &&
   1252          "the type of a subprogram should be a subroutine");
   1253 
   1254   DIArray Args = SPTy.getTypeArray();
   1255   addType(SPDie, DIType(Args.getElement(0)));
   1256 
   1257   unsigned VK = SP.getVirtuality();
   1258   if (VK) {
   1259     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
   1260     DIEBlock *Block = getDIEBlock();
   1261     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
   1262     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
   1263     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
   1264     ContainingTypeMap.insert(std::make_pair(SPDie,
   1265                                             SP.getContainingType()));
   1266   }
   1267 
   1268   if (!SP.isDefinition()) {
   1269     addFlag(SPDie, dwarf::DW_AT_declaration);
   1270 
   1271     // Add arguments. Do not add arguments for subprogram definition. They will
   1272     // be handled while processing variables.
   1273     for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
   1274       DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
   1275       DIType ATy = DIType(Args.getElement(i));
   1276       addType(Arg, ATy);
   1277       if (ATy.isArtificial())
   1278         addFlag(Arg, dwarf::DW_AT_artificial);
   1279       SPDie->addChild(Arg);
   1280     }
   1281   }
   1282 
   1283   if (SP.isArtificial())
   1284     addFlag(SPDie, dwarf::DW_AT_artificial);
   1285 
   1286   if (!SP.isLocalToUnit())
   1287     addFlag(SPDie, dwarf::DW_AT_external);
   1288 
   1289   if (SP.isOptimized())
   1290     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
   1291 
   1292   if (unsigned isa = Asm->getISAEncoding()) {
   1293     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
   1294   }
   1295 
   1296   return SPDie;
   1297 }
   1298 
   1299 // Return const expression if value is a GEP to access merged global
   1300 // constant. e.g.
   1301 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
   1302 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
   1303   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
   1304   if (!CE || CE->getNumOperands() != 3 ||
   1305       CE->getOpcode() != Instruction::GetElementPtr)
   1306     return NULL;
   1307 
   1308   // First operand points to a global struct.
   1309   Value *Ptr = CE->getOperand(0);
   1310   if (!isa<GlobalValue>(Ptr) ||
   1311       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
   1312     return NULL;
   1313 
   1314   // Second operand is zero.
   1315   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
   1316   if (!CI || !CI->isZero())
   1317     return NULL;
   1318 
   1319   // Third operand is offset.
   1320   if (!isa<ConstantInt>(CE->getOperand(2)))
   1321     return NULL;
   1322 
   1323   return CE;
   1324 }
   1325 
   1326 /// createGlobalVariableDIE - create global variable DIE.
   1327 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
   1328   // Check for pre-existence.
   1329   if (getDIE(N))
   1330     return;
   1331 
   1332   DIGlobalVariable GV(N);
   1333   if (!GV.isGlobalVariable())
   1334     return;
   1335 
   1336   DIDescriptor GVContext = GV.getContext();
   1337   DIType GTy = GV.getType();
   1338 
   1339   // If this is a static data member definition, some attributes belong
   1340   // to the declaration DIE.
   1341   DIE *VariableDIE = NULL;
   1342   bool IsStaticMember = false;
   1343   DIDerivedType SDMDecl = GV.getStaticDataMemberDeclaration();
   1344   if (SDMDecl.Verify()) {
   1345     assert(SDMDecl.isStaticMember() && "Expected static member decl");
   1346     // We need the declaration DIE that is in the static member's class.
   1347     // But that class might not exist in the DWARF yet.
   1348     // Creating the class will create the static member decl DIE.
   1349     getOrCreateContextDIE(SDMDecl.getContext());
   1350     VariableDIE = getDIE(SDMDecl);
   1351     assert(VariableDIE && "Static member decl has no context?");
   1352     IsStaticMember = true;
   1353   }
   1354 
   1355   // If this is not a static data member definition, create the variable
   1356   // DIE and add the initial set of attributes to it.
   1357   if (!VariableDIE) {
   1358     VariableDIE = new DIE(GV.getTag());
   1359     // Add to map.
   1360     insertDIE(N, VariableDIE);
   1361 
   1362     // Add name and type.
   1363     addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
   1364     addType(VariableDIE, GTy);
   1365 
   1366     // Add scoping info.
   1367     if (!GV.isLocalToUnit()) {
   1368       addFlag(VariableDIE, dwarf::DW_AT_external);
   1369       addGlobalName(GV.getName(), VariableDIE);
   1370     }
   1371 
   1372     // Add line number info.
   1373     addSourceLine(VariableDIE, GV);
   1374     // Add to context owner.
   1375     addToContextOwner(VariableDIE, GVContext);
   1376   }
   1377 
   1378   // Add location.
   1379   bool addToAccelTable = false;
   1380   DIE *VariableSpecDIE = NULL;
   1381   bool isGlobalVariable = GV.getGlobal() != NULL;
   1382   if (isGlobalVariable) {
   1383     addToAccelTable = true;
   1384     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   1385     const MCSymbol *Sym = Asm->Mang->getSymbol(GV.getGlobal());
   1386     if (GV.getGlobal()->isThreadLocal()) {
   1387       // FIXME: Make this work with -gsplit-dwarf.
   1388       unsigned PointerSize = Asm->getDataLayout().getPointerSize();
   1389       assert((PointerSize == 4 || PointerSize == 8) &&
   1390              "Add support for other sizes if necessary");
   1391       const MCExpr *Expr =
   1392           Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym);
   1393       // Based on GCC's support for TLS:
   1394       if (!DD->useSplitDwarf()) {
   1395         // 1) Start with a constNu of the appropriate pointer size
   1396         addUInt(Block, 0, dwarf::DW_FORM_data1,
   1397                 PointerSize == 4 ? dwarf::DW_OP_const4u : dwarf::DW_OP_const8u);
   1398         // 2) containing the (relocated) address of the TLS variable
   1399         addExpr(Block, 0, dwarf::DW_FORM_udata, Expr);
   1400       } else {
   1401         addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
   1402         addUInt(Block, 0, dwarf::DW_FORM_udata, DU->getAddrPoolIndex(Expr));
   1403       }
   1404       // 3) followed by a custom OP to tell the debugger about TLS (presumably)
   1405       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_lo_user);
   1406     } else
   1407       addOpAddress(Block, Sym);
   1408     // Do not create specification DIE if context is either compile unit
   1409     // or a subprogram.
   1410     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
   1411         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
   1412       // Create specification DIE.
   1413       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
   1414       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
   1415                   dwarf::DW_FORM_ref4, VariableDIE);
   1416       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
   1417       // A static member's declaration is already flagged as such.
   1418       if (!SDMDecl.Verify())
   1419         addFlag(VariableDIE, dwarf::DW_AT_declaration);
   1420       addDie(VariableSpecDIE);
   1421     } else {
   1422       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
   1423     }
   1424     // Add linkage name.
   1425     StringRef LinkageName = GV.getLinkageName();
   1426     if (!LinkageName.empty()) {
   1427       // From DWARF4: DIEs to which DW_AT_linkage_name may apply include:
   1428       // TAG_common_block, TAG_constant, TAG_entry_point, TAG_subprogram and
   1429       // TAG_variable.
   1430       addString(IsStaticMember && VariableSpecDIE ?
   1431                 VariableSpecDIE : VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
   1432                 GlobalValue::getRealLinkageName(LinkageName));
   1433       // In compatibility mode with older gdbs we put the linkage name on both
   1434       // the TAG_variable DIE and on the TAG_member DIE.
   1435       if (IsStaticMember && VariableSpecDIE && DD->useDarwinGDBCompat())
   1436         addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
   1437                   GlobalValue::getRealLinkageName(LinkageName));
   1438     }
   1439   } else if (const ConstantInt *CI =
   1440              dyn_cast_or_null<ConstantInt>(GV.getConstant())) {
   1441     // AT_const_value was added when the static member was created. To avoid
   1442     // emitting AT_const_value multiple times, we only add AT_const_value when
   1443     // it is not a static member.
   1444     if (!IsStaticMember)
   1445       addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
   1446   } else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
   1447     addToAccelTable = true;
   1448     // GV is a merged global.
   1449     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
   1450     Value *Ptr = CE->getOperand(0);
   1451     addOpAddress(Block, Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
   1452     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
   1453     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
   1454     addUInt(Block, 0, dwarf::DW_FORM_udata,
   1455                    Asm->getDataLayout().getIndexedOffset(Ptr->getType(), Idx));
   1456     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
   1457     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
   1458   }
   1459 
   1460   if (addToAccelTable) {
   1461     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
   1462     addAccelName(GV.getName(), AddrDIE);
   1463 
   1464     // If the linkage name is different than the name, go ahead and output
   1465     // that as well into the name table.
   1466     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
   1467       addAccelName(GV.getLinkageName(), AddrDIE);
   1468   }
   1469 }
   1470 
   1471 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
   1472 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR,
   1473                                        DIE *IndexTy) {
   1474   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
   1475   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
   1476 
   1477   // The LowerBound value defines the lower bounds which is typically zero for
   1478   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
   1479   // Count == -1 then the array is unbounded and we do not emit
   1480   // DW_AT_lower_bound and DW_AT_upper_bound attributes. If LowerBound == 0 and
   1481   // Count == 0, then the array has zero elements in which case we do not emit
   1482   // an upper bound.
   1483   int64_t LowerBound = SR.getLo();
   1484   int64_t DefaultLowerBound = getDefaultLowerBound();
   1485   int64_t Count = SR.getCount();
   1486 
   1487   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
   1488     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, LowerBound);
   1489 
   1490   if (Count != -1 && Count != 0)
   1491     // FIXME: An unbounded array should reference the expression that defines
   1492     // the array.
   1493     addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, LowerBound + Count - 1);
   1494 
   1495   Buffer.addChild(DW_Subrange);
   1496 }
   1497 
   1498 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
   1499 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
   1500                                         DICompositeType *CTy) {
   1501   Buffer.setTag(dwarf::DW_TAG_array_type);
   1502   if (CTy->isVector())
   1503     addFlag(&Buffer, dwarf::DW_AT_GNU_vector);
   1504 
   1505   // Emit derived type.
   1506   addType(&Buffer, CTy->getTypeDerivedFrom());
   1507   DIArray Elements = CTy->getTypeArray();
   1508 
   1509   // Get an anonymous type for index type.
   1510   // FIXME: This type should be passed down from the front end
   1511   // as different languages may have different sizes for indexes.
   1512   DIE *IdxTy = getIndexTyDie();
   1513   if (!IdxTy) {
   1514     // Construct an anonymous type for index type.
   1515     IdxTy = new DIE(dwarf::DW_TAG_base_type);
   1516     addString(IdxTy, dwarf::DW_AT_name, "int");
   1517     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
   1518     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
   1519             dwarf::DW_ATE_signed);
   1520     addDie(IdxTy);
   1521     setIndexTyDie(IdxTy);
   1522   }
   1523 
   1524   // Add subranges to array type.
   1525   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
   1526     DIDescriptor Element = Elements.getElement(i);
   1527     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
   1528       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
   1529   }
   1530 }
   1531 
   1532 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
   1533 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
   1534   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
   1535   StringRef Name = ETy.getName();
   1536   addString(Enumerator, dwarf::DW_AT_name, Name);
   1537   int64_t Value = ETy.getEnumValue();
   1538   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
   1539   return Enumerator;
   1540 }
   1541 
   1542 /// constructContainingTypeDIEs - Construct DIEs for types that contain
   1543 /// vtables.
   1544 void CompileUnit::constructContainingTypeDIEs() {
   1545   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
   1546          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
   1547     DIE *SPDie = CI->first;
   1548     const MDNode *N = CI->second;
   1549     if (!N) continue;
   1550     DIE *NDie = getDIE(N);
   1551     if (!NDie) continue;
   1552     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
   1553   }
   1554 }
   1555 
   1556 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
   1557 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV,
   1558                                        bool isScopeAbstract) {
   1559   StringRef Name = DV->getName();
   1560 
   1561   // Translate tag to proper Dwarf tag.
   1562   unsigned Tag = DV->getTag();
   1563 
   1564   // Define variable debug information entry.
   1565   DIE *VariableDie = new DIE(Tag);
   1566   DbgVariable *AbsVar = DV->getAbstractVariable();
   1567   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
   1568   if (AbsDIE)
   1569     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
   1570                             dwarf::DW_FORM_ref4, AbsDIE);
   1571   else {
   1572     addString(VariableDie, dwarf::DW_AT_name, Name);
   1573     addSourceLine(VariableDie, DV->getVariable());
   1574     addType(VariableDie, DV->getType());
   1575   }
   1576 
   1577   if (DV->isArtificial())
   1578     addFlag(VariableDie, dwarf::DW_AT_artificial);
   1579 
   1580   if (isScopeAbstract) {
   1581     DV->setDIE(VariableDie);
   1582     return VariableDie;
   1583   }
   1584 
   1585   // Add variable address.
   1586 
   1587   unsigned Offset = DV->getDotDebugLocOffset();
   1588   if (Offset != ~0U) {
   1589     addLabel(VariableDie, dwarf::DW_AT_location, dwarf::DW_FORM_data4,
   1590              Asm->GetTempSymbol("debug_loc", Offset));
   1591     DV->setDIE(VariableDie);
   1592     return VariableDie;
   1593   }
   1594 
   1595   // Check if variable is described by a DBG_VALUE instruction.
   1596   if (const MachineInstr *DVInsn = DV->getMInsn()) {
   1597     assert(DVInsn->getNumOperands() == 3);
   1598     if (DVInsn->getOperand(0).isReg()) {
   1599       const MachineOperand RegOp = DVInsn->getOperand(0);
   1600       // If the second operand is an immediate, this is an indirect value.
   1601       if (DVInsn->getOperand(1).isImm()) {
   1602         MachineLocation Location(RegOp.getReg(), DVInsn->getOperand(1).getImm());
   1603         addVariableAddress(*DV, VariableDie, Location);
   1604       } else if (RegOp.getReg())
   1605         addVariableAddress(*DV, VariableDie, MachineLocation(RegOp.getReg()));
   1606     } else if (DVInsn->getOperand(0).isImm())
   1607       addConstantValue(VariableDie, DVInsn->getOperand(0), DV->getType());
   1608     else if (DVInsn->getOperand(0).isFPImm())
   1609       addConstantFPValue(VariableDie, DVInsn->getOperand(0));
   1610     else if (DVInsn->getOperand(0).isCImm())
   1611       addConstantValue(VariableDie, DVInsn->getOperand(0).getCImm(),
   1612                        DV->getType().isUnsignedDIType());
   1613 
   1614     DV->setDIE(VariableDie);
   1615     return VariableDie;
   1616   } else {
   1617     // .. else use frame index.
   1618     int FI = DV->getFrameIndex();
   1619     if (FI != ~0) {
   1620       unsigned FrameReg = 0;
   1621       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
   1622       int Offset =
   1623         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
   1624       MachineLocation Location(FrameReg, Offset);
   1625       addVariableAddress(*DV, VariableDie, Location);
   1626     }
   1627   }
   1628 
   1629   DV->setDIE(VariableDie);
   1630   return VariableDie;
   1631 }
   1632 
   1633 /// createMemberDIE - Create new member DIE.
   1634 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
   1635   DIE *MemberDie = new DIE(DT.getTag());
   1636   StringRef Name = DT.getName();
   1637   if (!Name.empty())
   1638     addString(MemberDie, dwarf::DW_AT_name, Name);
   1639 
   1640   addType(MemberDie, DT.getTypeDerivedFrom());
   1641 
   1642   addSourceLine(MemberDie, DT);
   1643 
   1644   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
   1645   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
   1646 
   1647   uint64_t Size = DT.getSizeInBits();
   1648   uint64_t FieldSize = DT.getOriginalTypeSize();
   1649 
   1650   if (Size != FieldSize) {
   1651     // Handle bitfield.
   1652     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
   1653     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
   1654 
   1655     uint64_t Offset = DT.getOffsetInBits();
   1656     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
   1657     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
   1658     uint64_t FieldOffset = (HiMark - FieldSize);
   1659     Offset -= FieldOffset;
   1660 
   1661     // Maybe we need to work from the other end.
   1662     if (Asm->getDataLayout().isLittleEndian())
   1663       Offset = FieldSize - (Offset + Size);
   1664     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
   1665 
   1666     // Here WD_AT_data_member_location points to the anonymous
   1667     // field that includes this bit field.
   1668     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
   1669 
   1670   } else
   1671     // This is not a bitfield.
   1672     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
   1673 
   1674   if (DT.getTag() == dwarf::DW_TAG_inheritance
   1675       && DT.isVirtual()) {
   1676 
   1677     // For C++, virtual base classes are not at fixed offset. Use following
   1678     // expression to extract appropriate offset from vtable.
   1679     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
   1680 
   1681     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
   1682     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
   1683     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
   1684     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
   1685     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
   1686     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
   1687     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
   1688     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
   1689 
   1690     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
   1691              VBaseLocationDie);
   1692   } else
   1693     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
   1694 
   1695   if (DT.isProtected())
   1696     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
   1697             dwarf::DW_ACCESS_protected);
   1698   else if (DT.isPrivate())
   1699     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
   1700             dwarf::DW_ACCESS_private);
   1701   // Otherwise C++ member and base classes are considered public.
   1702   else
   1703     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
   1704             dwarf::DW_ACCESS_public);
   1705   if (DT.isVirtual())
   1706     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
   1707             dwarf::DW_VIRTUALITY_virtual);
   1708 
   1709   // Objective-C properties.
   1710   if (MDNode *PNode = DT.getObjCProperty())
   1711     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
   1712       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
   1713                           PropertyDie);
   1714 
   1715   if (DT.isArtificial())
   1716     addFlag(MemberDie, dwarf::DW_AT_artificial);
   1717 
   1718   return MemberDie;
   1719 }
   1720 
   1721 /// createStaticMemberDIE - Create new DIE for C++ static member.
   1722 DIE *CompileUnit::createStaticMemberDIE(const DIDerivedType DT) {
   1723   if (!DT.Verify())
   1724     return NULL;
   1725 
   1726   DIE *StaticMemberDIE = new DIE(DT.getTag());
   1727   DIType Ty = DT.getTypeDerivedFrom();
   1728 
   1729   addString(StaticMemberDIE, dwarf::DW_AT_name, DT.getName());
   1730   addType(StaticMemberDIE, Ty);
   1731   addSourceLine(StaticMemberDIE, DT);
   1732   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
   1733   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
   1734 
   1735   // FIXME: We could omit private if the parent is a class_type, and
   1736   // public if the parent is something else.
   1737   if (DT.isProtected())
   1738     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
   1739             dwarf::DW_ACCESS_protected);
   1740   else if (DT.isPrivate())
   1741     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
   1742             dwarf::DW_ACCESS_private);
   1743   else
   1744     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
   1745             dwarf::DW_ACCESS_public);
   1746 
   1747   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT.getConstant()))
   1748     addConstantValue(StaticMemberDIE, CI, Ty.isUnsignedDIType());
   1749   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT.getConstant()))
   1750     addConstantFPValue(StaticMemberDIE, CFP);
   1751 
   1752   insertDIE(DT, StaticMemberDIE);
   1753   return StaticMemberDIE;
   1754 }
   1755