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