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