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