lib/CodeGen/AsmPrinter/DwarfUnit.cpp

   1 //===-- llvm/CodeGen/DwarfUnit.cpp - Dwarf Type and Compile Units ---------===//
   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 #include "DwarfUnit.h"
  15 #include "DwarfAccelTable.h"
  16 #include "DwarfCompileUnit.h"
  17 #include "DwarfDebug.h"
  18 #include "DwarfExpression.h"
  19 #include "llvm/ADT/APFloat.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/IR/Constants.h"
  22 #include "llvm/IR/DIBuilder.h"
  23 #include "llvm/IR/DataLayout.h"
  24 #include "llvm/IR/GlobalVariable.h"
  25 #include "llvm/IR/Instructions.h"
  26 #include "llvm/IR/Mangler.h"
  27 #include "llvm/MC/MCAsmInfo.h"
  28 #include "llvm/MC/MCContext.h"
  29 #include "llvm/MC/MCSection.h"
  30 #include "llvm/MC/MCStreamer.h"
  31 #include "llvm/Support/CommandLine.h"
  32 #include "llvm/Target/TargetFrameLowering.h"
  33 #include "llvm/Target/TargetLoweringObjectFile.h"
  34 #include "llvm/Target/TargetMachine.h"
  35 #include "llvm/Target/TargetRegisterInfo.h"
  36 #include "llvm/Target/TargetSubtargetInfo.h"
  37
  38 using namespace llvm;
  39
  40 #define DEBUG_TYPE "dwarfdebug"
  41
  42 static cl::opt<bool>
  43 GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
  44                        cl::desc("Generate DWARF4 type units."),
  45                        cl::init(false));
  46
  47 DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
  48                                        DIELoc &DIE)
  49     : DwarfExpression(*AP.MF->getSubtarget().getRegisterInfo(),
  50                       AP.getDwarfDebug()->getDwarfVersion()),
  51       AP(AP), DU(DU), DIE(DIE) {}
  52
  53 void DIEDwarfExpression::EmitOp(uint8_t Op, const char* Comment) {
  54   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
  55 }
  56 void DIEDwarfExpression::EmitSigned(int64_t Value) {
  57   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
  58 }
  59 void DIEDwarfExpression::EmitUnsigned(uint64_t Value) {
  60   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
  61 }
  62 bool DIEDwarfExpression::isFrameRegister(unsigned MachineReg) {
  63   return MachineReg == TRI.getFrameRegister(*AP.MF);
  64 }
  65
  66 DwarfUnit::DwarfUnit(unsigned UID, dwarf::Tag UnitTag,
  67                      const DICompileUnit *Node, AsmPrinter *A, DwarfDebug *DW,
  68                      DwarfFile *DWU)
  69     : UniqueID(UID), CUNode(Node), UnitDie(UnitTag), DebugInfoOffset(0), Asm(A),
  70       DD(DW), DU(DWU), IndexTyDie(nullptr), Section(nullptr) {
  71   assert(UnitTag == dwarf::DW_TAG_compile_unit ||
  72          UnitTag == dwarf::DW_TAG_type_unit);
  73 }
  74
  75 DwarfTypeUnit::DwarfTypeUnit(unsigned UID, DwarfCompileUnit &CU, AsmPrinter *A,
  76                              DwarfDebug *DW, DwarfFile *DWU,
  77                              MCDwarfDwoLineTable *SplitLineTable)
  78     : DwarfUnit(UID, dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU),
  79       CU(CU), SplitLineTable(SplitLineTable) {
  80   if (SplitLineTable)
  81     addSectionOffset(UnitDie, dwarf::DW_AT_stmt_list, 0);
  82 }
  83
  84 DwarfUnit::~DwarfUnit() {
  85   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  86     DIEBlocks[j]->~DIEBlock();
  87   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
  88     DIELocs[j]->~DIELoc();
  89 }
  90
  91 int64_t DwarfUnit::getDefaultLowerBound() const {
  92   switch (getLanguage()) {
  93   default:
  94     break;
  95
  96   case dwarf::DW_LANG_C89:
  97   case dwarf::DW_LANG_C99:
  98   case dwarf::DW_LANG_C:
  99   case dwarf::DW_LANG_C_plus_plus:
 100   case dwarf::DW_LANG_ObjC:
 101   case dwarf::DW_LANG_ObjC_plus_plus:
 102     return 0;
 103
 104   case dwarf::DW_LANG_Fortran77:
 105   case dwarf::DW_LANG_Fortran90:
 106   case dwarf::DW_LANG_Fortran95:
 107     return 1;
 108
 109   // The languages below have valid values only if the DWARF version >= 4.
 110   case dwarf::DW_LANG_Java:
 111   case dwarf::DW_LANG_Python:
 112   case dwarf::DW_LANG_UPC:
 113   case dwarf::DW_LANG_D:
 114     if (dwarf::DWARF_VERSION >= 4)
 115       return 0;
 116     break;
 117
 118   case dwarf::DW_LANG_Ada83:
 119   case dwarf::DW_LANG_Ada95:
 120   case dwarf::DW_LANG_Cobol74:
 121   case dwarf::DW_LANG_Cobol85:
 122   case dwarf::DW_LANG_Modula2:
 123   case dwarf::DW_LANG_Pascal83:
 124   case dwarf::DW_LANG_PLI:
 125     if (dwarf::DWARF_VERSION >= 4)
 126       return 1;
 127     break;
 128
 129   // The languages below have valid values only if the DWARF version >= 5.
 130   case dwarf::DW_LANG_OpenCL:
 131   case dwarf::DW_LANG_Go:
 132   case dwarf::DW_LANG_Haskell:
 133   case dwarf::DW_LANG_C_plus_plus_03:
 134   case dwarf::DW_LANG_C_plus_plus_11:
 135   case dwarf::DW_LANG_OCaml:
 136   case dwarf::DW_LANG_Rust:
 137   case dwarf::DW_LANG_C11:
 138   case dwarf::DW_LANG_Swift:
 139   case dwarf::DW_LANG_Dylan:
 140   case dwarf::DW_LANG_C_plus_plus_14:
 141     if (dwarf::DWARF_VERSION >= 5)
 142       return 0;
 143     break;
 144
 145   case dwarf::DW_LANG_Modula3:
 146   case dwarf::DW_LANG_Julia:
 147   case dwarf::DW_LANG_Fortran03:
 148   case dwarf::DW_LANG_Fortran08:
 149     if (dwarf::DWARF_VERSION >= 5)
 150       return 1;
 151     break;
 152   }
 153
 154   return -1;
 155 }
 156
 157 /// Check whether the DIE for this MDNode can be shared across CUs.
 158 static bool isShareableAcrossCUs(const DINode *D) {
 159   // When the MDNode can be part of the type system, the DIE can be shared
 160   // across CUs.
 161   // Combining type units and cross-CU DIE sharing is lower value (since
 162   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
 163   // level already) but may be implementable for some value in projects
 164   // building multiple independent libraries with LTO and then linking those
 165   // together.
 166   return (isa<DIType>(D) ||
 167           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
 168          !GenerateDwarfTypeUnits;
 169 }
 170
 171 DIE *DwarfUnit::getDIE(const DINode *D) const {
 172   if (isShareableAcrossCUs(D))
 173     return DU->getDIE(D);
 174   return MDNodeToDieMap.lookup(D);
 175 }
 176
 177 void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
 178   if (isShareableAcrossCUs(Desc)) {
 179     DU->insertDIE(Desc, D);
 180     return;
 181   }
 182   MDNodeToDieMap.insert(std::make_pair(Desc, D));
 183 }
 184
 185 void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
 186   if (DD->getDwarfVersion() >= 4)
 187     Die.addValue(Attribute, dwarf::DW_FORM_flag_present, DIEInteger(1));
 188   else
 189     Die.addValue(Attribute, dwarf::DW_FORM_flag, DIEInteger(1));
 190 }
 191
 192 void DwarfUnit::addUInt(DIE &Die, dwarf::Attribute Attribute,
 193                         Optional<dwarf::Form> Form, uint64_t Integer) {
 194   if (!Form)
 195     Form = DIEInteger::BestForm(false, Integer);
 196   Die.addValue(Attribute, *Form, DIEInteger(Integer));
 197 }
 198
 199 void DwarfUnit::addUInt(DIE &Block, dwarf::Form Form, uint64_t Integer) {
 200   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
 201 }
 202
 203 void DwarfUnit::addSInt(DIE &Die, dwarf::Attribute Attribute,
 204                         Optional<dwarf::Form> Form, int64_t Integer) {
 205   if (!Form)
 206     Form = DIEInteger::BestForm(true, Integer);
 207   Die.addValue(Attribute, *Form, DIEInteger(Integer));
 208 }
 209
 210 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
 211                         int64_t Integer) {
 212   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 213 }
 214
 215 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
 216                           StringRef String) {
 217   Die.addValue(Attribute,
 218                isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp,
 219                DIEString(DU->getStringPool().getEntry(*Asm, String)));
 220 }
 221
 222 void DwarfUnit::addLabel(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
 223                          const MCSymbol *Label) {
 224   Die.addValue(Attribute, Form, DIELabel(Label));
 225 }
 226
 227 void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
 228   addLabel(Die, (dwarf::Attribute)0, Form, Label);
 229 }
 230
 231 void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
 232                                  uint64_t Integer) {
 233   if (DD->getDwarfVersion() >= 4)
 234     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
 235   else
 236     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
 237 }
 238
 239 unsigned DwarfTypeUnit::getOrCreateSourceID(StringRef FileName, StringRef DirName) {
 240   return SplitLineTable ? SplitLineTable->getFile(DirName, FileName)
 241                         : getCU().getOrCreateSourceID(FileName, DirName);
 242 }
 243
 244 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
 245   if (!DD->useSplitDwarf()) {
 246     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
 247     addLabel(Die, dwarf::DW_FORM_udata, Sym);
 248   } else {
 249     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
 250     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
 251             DD->getAddressPool().getIndex(Sym));
 252   }
 253 }
 254
 255 void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
 256                               const MCSymbol *Hi, const MCSymbol *Lo) {
 257   Die.addValue(Attribute, dwarf::DW_FORM_data4,
 258                new (DIEValueAllocator) DIEDelta(Hi, Lo));
 259 }
 260
 261 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
 262   addDIEEntry(Die, Attribute, DIEEntry(Entry));
 263 }
 264
 265 void DwarfUnit::addDIETypeSignature(DIE &Die, const DwarfTypeUnit &Type) {
 266   // Flag the type unit reference as a declaration so that if it contains
 267   // members (implicit special members, static data member definitions, member
 268   // declarations for definitions in this CU, etc) consumers don't get confused
 269   // and think this is a full definition.
 270   addFlag(Die, dwarf::DW_AT_declaration);
 271
 272   Die.addValue(dwarf::DW_AT_signature, dwarf::DW_FORM_ref_sig8,
 273                DIETypeSignature(Type));
 274 }
 275
 276 void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
 277                             DIEEntry Entry) {
 278   const DIE *DieCU = Die.getUnitOrNull();
 279   const DIE *EntryCU = Entry.getEntry().getUnitOrNull();
 280   if (!DieCU)
 281     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
 282     DieCU = &getUnitDie();
 283   if (!EntryCU)
 284     EntryCU = &getUnitDie();
 285   Die.addValue(Attribute,
 286                EntryCU == DieCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 287                Entry);
 288 }
 289
 290 DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
 291   assert(Tag != dwarf::DW_TAG_auto_variable &&
 292          Tag != dwarf::DW_TAG_arg_variable);
 293   Parent.addChild(make_unique<DIE>((dwarf::Tag)Tag));
 294   DIE &Die = *Parent.getChildren().back();
 295   if (N)
 296     insertDIE(N, &Die);
 297   return Die;
 298 }
 299
 300 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
 301   Loc->ComputeSize(Asm);
 302   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
 303   Die.addValue(Attribute, Loc->BestForm(DD->getDwarfVersion()), Loc);
 304 }
 305
 306 void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
 307                          DIEBlock *Block) {
 308   Block->ComputeSize(Asm);
 309   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 310   Die.addValue(Attribute, Block->BestForm(), Block);
 311 }
 312
 313 void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, StringRef File,
 314                               StringRef Directory) {
 315   if (Line == 0)
 316     return;
 317
 318   unsigned FileID = getOrCreateSourceID(File, Directory);
 319   assert(FileID && "Invalid file id");
 320   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
 321   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 322 }
 323
 324 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
 325   assert(V);
 326
 327   addSourceLine(Die, V->getLine(), V->getScope()->getFilename(),
 328                 V->getScope()->getDirectory());
 329 }
 330
 331 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
 332   assert(G);
 333
 334   addSourceLine(Die, G->getLine(), G->getFilename(), G->getDirectory());
 335 }
 336
 337 void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
 338   assert(SP);
 339
 340   addSourceLine(Die, SP->getLine(), SP->getFilename(), SP->getDirectory());
 341 }
 342
 343 void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
 344   assert(Ty);
 345
 346   addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
 347 }
 348
 349 void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
 350   assert(Ty);
 351
 352   addSourceLine(Die, Ty->getLine(), Ty->getFilename(), Ty->getDirectory());
 353 }
 354
 355 void DwarfUnit::addSourceLine(DIE &Die, const DINamespace *NS) {
 356   addSourceLine(Die, NS->getLine(), NS->getFilename(), NS->getDirectory());
 357 }
 358
 359 bool DwarfUnit::addRegisterOpPiece(DIELoc &TheDie, unsigned Reg,
 360                                    unsigned SizeInBits, unsigned OffsetInBits) {
 361   DIEDwarfExpression Expr(*Asm, *this, TheDie);
 362   Expr.AddMachineRegPiece(Reg, SizeInBits, OffsetInBits);
 363   return true;
 364 }
 365
 366 bool DwarfUnit::addRegisterOffset(DIELoc &TheDie, unsigned Reg,
 367                                   int64_t Offset) {
 368   DIEDwarfExpression Expr(*Asm, *this, TheDie);
 369   return Expr.AddMachineRegIndirect(Reg, Offset);
 370 }
 371
 372 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 373    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 374    gives the variable VarName either the struct, or a pointer to the struct, as
 375    its type.  This is necessary for various behind-the-scenes things the
 376    compiler needs to do with by-reference variables in Blocks.
 377
 378    However, as far as the original *programmer* is concerned, the variable
 379    should still have type 'SomeType', as originally declared.
 380
 381    The function getBlockByrefType dives into the __Block_byref_x_VarName
 382    struct to find the original type of the variable, which is then assigned to
 383    the variable's Debug Information Entry as its real type.  So far, so good.
 384    However now the debugger will expect the variable VarName to have the type
 385    SomeType.  So we need the location attribute for the variable to be an
 386    expression that explains to the debugger how to navigate through the
 387    pointers and struct to find the actual variable of type SomeType.
 388
 389    The following function does just that.  We start by getting
 390    the "normal" location for the variable. This will be the location
 391    of either the struct __Block_byref_x_VarName or the pointer to the
 392    struct __Block_byref_x_VarName.
 393
 394    The struct will look something like:
 395
 396    struct __Block_byref_x_VarName {
 397      ... <various fields>
 398      struct __Block_byref_x_VarName *forwarding;
 399      ... <various other fields>
 400      SomeType VarName;
 401      ... <maybe more fields>
 402    };
 403
 404    If we are given the struct directly (as our starting point) we
 405    need to tell the debugger to:
 406
 407    1).  Add the offset of the forwarding field.
 408
 409    2).  Follow that pointer to get the real __Block_byref_x_VarName
 410    struct to use (the real one may have been copied onto the heap).
 411
 412    3).  Add the offset for the field VarName, to find the actual variable.
 413
 414    If we started with a pointer to the struct, then we need to
 415    dereference that pointer first, before the other steps.
 416    Translating this into DWARF ops, we will need to append the following
 417    to the current location description for the variable:
 418
 419    DW_OP_deref                    -- optional, if we start with a pointer
 420    DW_OP_plus_uconst <forward_fld_offset>
 421    DW_OP_deref
 422    DW_OP_plus_uconst <varName_fld_offset>
 423
 424    That is what this function does.  */
 425
 426 void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
 427                                      dwarf::Attribute Attribute,
 428                                      const MachineLocation &Location) {
 429   const DIType *Ty = DV.getType();
 430   const DIType *TmpTy = Ty;
 431   uint16_t Tag = Ty->getTag();
 432   bool isPointer = false;
 433
 434   StringRef varName = DV.getName();
 435
 436   if (Tag == dwarf::DW_TAG_pointer_type) {
 437     auto *DTy = cast<DIDerivedType>(Ty);
 438     TmpTy = resolve(DTy->getBaseType());
 439     isPointer = true;
 440   }
 441
 442   // Find the __forwarding field and the variable field in the __Block_byref
 443   // struct.
 444   DINodeArray Fields = cast<DICompositeTypeBase>(TmpTy)->getElements();
 445   const DIDerivedType *varField = nullptr;
 446   const DIDerivedType *forwardingField = nullptr;
 447
 448   for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
 449     auto *DT = cast<DIDerivedType>(Fields[i]);
 450     StringRef fieldName = DT->getName();
 451     if (fieldName == "__forwarding")
 452       forwardingField = DT;
 453     else if (fieldName == varName)
 454       varField = DT;
 455   }
 456
 457   // Get the offsets for the forwarding field and the variable field.
 458   unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
 459   unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
 460
 461   // Decode the original location, and use that as the start of the byref
 462   // variable's location.
 463   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
 464
 465   bool validReg;
 466   if (Location.isReg())
 467     validReg = addRegisterOpPiece(*Loc, Location.getReg());
 468   else
 469     validReg = addRegisterOffset(*Loc, Location.getReg(), Location.getOffset());
 470
 471   if (!validReg)
 472     return;
 473
 474   // If we started with a pointer to the __Block_byref... struct, then
 475   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 476   if (isPointer)
 477     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 478
 479   // Next add the offset for the '__forwarding' field:
 480   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 481   // adding the offset if it's 0.
 482   if (forwardingFieldOffset > 0) {
 483     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 484     addUInt(*Loc, dwarf::DW_FORM_udata, forwardingFieldOffset);
 485   }
 486
 487   // Now dereference the __forwarding field to get to the real __Block_byref
 488   // struct:  DW_OP_deref.
 489   addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 490
 491   // Now that we've got the real __Block_byref... struct, add the offset
 492   // for the variable's field to get to the location of the actual variable:
 493   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 494   if (varFieldOffset > 0) {
 495     addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 496     addUInt(*Loc, dwarf::DW_FORM_udata, varFieldOffset);
 497   }
 498
 499   // Now attach the location information to the DIE.
 500   addBlock(Die, Attribute, Loc);
 501 }
 502
 503 /// Return true if type encoding is unsigned.
 504 static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
 505   if (auto *DTy = dyn_cast<DIDerivedTypeBase>(Ty)) {
 506     dwarf::Tag T = (dwarf::Tag)Ty->getTag();
 507     // Encode pointer constants as unsigned bytes. This is used at least for
 508     // null pointer constant emission.
 509     // (Pieces of) aggregate types that get hacked apart by SROA may also be
 510     // represented by a constant. Encode them as unsigned bytes.
 511     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
 512     // here, but accept them for now due to a bug in SROA producing bogus
 513     // dbg.values.
 514     if (T == dwarf::DW_TAG_array_type ||
 515         T == dwarf::DW_TAG_class_type ||
 516         T == dwarf::DW_TAG_pointer_type ||
 517         T == dwarf::DW_TAG_ptr_to_member_type ||
 518         T == dwarf::DW_TAG_reference_type ||
 519         T == dwarf::DW_TAG_rvalue_reference_type ||
 520         T == dwarf::DW_TAG_structure_type ||
 521         T == dwarf::DW_TAG_union_type)
 522       return true;
 523     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
 524            T == dwarf::DW_TAG_volatile_type ||
 525            T == dwarf::DW_TAG_restrict_type ||
 526            T == dwarf::DW_TAG_enumeration_type);
 527     if (DITypeRef Deriv = DTy->getBaseType())
 528       return isUnsignedDIType(DD, DD->resolve(Deriv));
 529     // FIXME: Enums without a fixed underlying type have unknown signedness
 530     // here, leading to incorrectly emitted constants.
 531     assert(DTy->getTag() == dwarf::DW_TAG_enumeration_type);
 532     return false;
 533   }
 534
 535   auto *BTy = cast<DIBasicType>(Ty);
 536   unsigned Encoding = BTy->getEncoding();
 537   assert((Encoding == dwarf::DW_ATE_unsigned ||
 538           Encoding == dwarf::DW_ATE_unsigned_char ||
 539           Encoding == dwarf::DW_ATE_signed ||
 540           Encoding == dwarf::DW_ATE_signed_char ||
 541           Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
 542           Encoding == dwarf::DW_ATE_boolean ||
 543           (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
 544            Ty->getName() == "decltype(nullptr)")) &&
 545          "Unsupported encoding");
 546   return Encoding == dwarf::DW_ATE_unsigned ||
 547          Encoding == dwarf::DW_ATE_unsigned_char ||
 548          Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
 549          Ty->getTag() == dwarf::DW_TAG_unspecified_type;
 550 }
 551
 552 /// If this type is derived from a base type then return base type size.
 553 static uint64_t getBaseTypeSize(DwarfDebug *DD, const DIDerivedType *Ty) {
 554   unsigned Tag = Ty->getTag();
 555
 556   if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
 557       Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
 558       Tag != dwarf::DW_TAG_restrict_type)
 559     return Ty->getSizeInBits();
 560
 561   auto *BaseType = DD->resolve(Ty->getBaseType());
 562
 563   assert(BaseType && "Unexpected invalid base type");
 564
 565   // If this is a derived type, go ahead and get the base type, unless it's a
 566   // reference then it's just the size of the field. Pointer types have no need
 567   // of this since they're a different type of qualification on the type.
 568   if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
 569       BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
 570     return Ty->getSizeInBits();
 571
 572   if (auto *DT = dyn_cast<DIDerivedType>(BaseType))
 573     return getBaseTypeSize(DD, DT);
 574
 575   return BaseType->getSizeInBits();
 576 }
 577
 578 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
 579   assert(MO.isFPImm() && "Invalid machine operand!");
 580   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 581   APFloat FPImm = MO.getFPImm()->getValueAPF();
 582
 583   // Get the raw data form of the floating point.
 584   const APInt FltVal = FPImm.bitcastToAPInt();
 585   const char *FltPtr = (const char *)FltVal.getRawData();
 586
 587   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 588   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 589   int Incr = (LittleEndian ? 1 : -1);
 590   int Start = (LittleEndian ? 0 : NumBytes - 1);
 591   int Stop = (LittleEndian ? NumBytes : -1);
 592
 593   // Output the constant to DWARF one byte at a time.
 594   for (; Start != Stop; Start += Incr)
 595     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
 596
 597   addBlock(Die, dwarf::DW_AT_const_value, Block);
 598 }
 599
 600 void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
 601   // Pass this down to addConstantValue as an unsigned bag of bits.
 602   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
 603 }
 604
 605 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
 606                                  const DIType *Ty) {
 607   addConstantValue(Die, CI->getValue(), Ty);
 608 }
 609
 610 void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
 611                                  const DIType *Ty) {
 612   assert(MO.isImm() && "Invalid machine operand!");
 613
 614   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
 615 }
 616
 617 void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
 618   // FIXME: This is a bit conservative/simple - it emits negative values always
 619   // sign extended to 64 bits rather than minimizing the number of bytes.
 620   addUInt(Die, dwarf::DW_AT_const_value,
 621           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
 622 }
 623
 624 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
 625   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
 626 }
 627
 628 void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
 629   unsigned CIBitWidth = Val.getBitWidth();
 630   if (CIBitWidth <= 64) {
 631     addConstantValue(Die, Unsigned,
 632                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
 633     return;
 634   }
 635
 636   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
 637
 638   // Get the raw data form of the large APInt.
 639   const uint64_t *Ptr64 = Val.getRawData();
 640
 641   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 642   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
 643
 644   // Output the constant to DWARF one byte at a time.
 645   for (int i = 0; i < NumBytes; i++) {
 646     uint8_t c;
 647     if (LittleEndian)
 648       c = Ptr64[i / 8] >> (8 * (i & 7));
 649     else
 650       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 651     addUInt(*Block, dwarf::DW_FORM_data1, c);
 652   }
 653
 654   addBlock(Die, dwarf::DW_AT_const_value, Block);
 655 }
 656
 657 void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
 658   if (!LinkageName.empty())
 659     addString(Die,
 660               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
 661                                          : dwarf::DW_AT_MIPS_linkage_name,
 662               GlobalValue::getRealLinkageName(LinkageName));
 663 }
 664
 665 void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
 666   // Add template parameters.
 667   for (const auto *Element : TParams) {
 668     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
 669       constructTemplateTypeParameterDIE(Buffer, TTP);
 670     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
 671       constructTemplateValueParameterDIE(Buffer, TVP);
 672   }
 673 }
 674
 675 DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
 676   if (!Context || isa<DIFile>(Context))
 677     return &getUnitDie();
 678   if (auto *T = dyn_cast<DIType>(Context))
 679     return getOrCreateTypeDIE(T);
 680   if (auto *NS = dyn_cast<DINamespace>(Context))
 681     return getOrCreateNameSpace(NS);
 682   if (auto *SP = dyn_cast<DISubprogram>(Context))
 683     return getOrCreateSubprogramDIE(SP);
 684   return getDIE(Context);
 685 }
 686
 687 DIE *DwarfUnit::createTypeDIE(const DICompositeType *Ty) {
 688   auto *Context = resolve(Ty->getScope());
 689   DIE *ContextDIE = getOrCreateContextDIE(Context);
 690
 691   if (DIE *TyDIE = getDIE(Ty))
 692     return TyDIE;
 693
 694   // Create new type.
 695   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 696
 697   constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
 698
 699   updateAcceleratorTables(Context, Ty, TyDIE);
 700   return &TyDIE;
 701 }
 702
 703 DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 704   if (!TyNode)
 705     return nullptr;
 706
 707   auto *Ty = cast<DIType>(TyNode);
 708   assert(Ty == resolve(Ty->getRef()) &&
 709          "type was not uniqued, possible ODR violation.");
 710
 711   // DW_TAG_restrict_type is not supported in DWARF2
 712   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
 713     return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
 714
 715   // Construct the context before querying for the existence of the DIE in case
 716   // such construction creates the DIE.
 717   auto *Context = resolve(Ty->getScope());
 718   DIE *ContextDIE = getOrCreateContextDIE(Context);
 719   assert(ContextDIE);
 720
 721   if (DIE *TyDIE = getDIE(Ty))
 722     return TyDIE;
 723
 724   // Create new type.
 725   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
 726
 727   updateAcceleratorTables(Context, Ty, TyDIE);
 728
 729   if (auto *BT = dyn_cast<DIBasicType>(Ty))
 730     constructTypeDIE(TyDIE, BT);
 731   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
 732     constructTypeDIE(TyDIE, STy);
 733   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
 734     if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
 735       if (MDString *TypeId = CTy->getRawIdentifier()) {
 736         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
 737         // Skip updating the accelerator tables since this is not the full type.
 738         return &TyDIE;
 739       }
 740     constructTypeDIE(TyDIE, CTy);
 741   } else {
 742     constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
 743   }
 744
 745   return &TyDIE;
 746 }
 747
 748 void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
 749                                         const DIType *Ty, const DIE &TyDIE) {
 750   if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
 751     bool IsImplementation = 0;
 752     if (auto *CT = dyn_cast<DICompositeTypeBase>(Ty)) {
 753       // A runtime language of 0 actually means C/C++ and that any
 754       // non-negative value is some version of Objective-C/C++.
 755       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
 756     }
 757     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
 758     DD->addAccelType(Ty->getName(), TyDIE, Flags);
 759
 760     if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
 761         isa<DINamespace>(Context))
 762       addGlobalType(Ty, TyDIE, Context);
 763   }
 764 }
 765
 766 void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
 767                         dwarf::Attribute Attribute) {
 768   assert(Ty && "Trying to add a type that doesn't exist?");
 769   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
 770 }
 771
 772 std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
 773   if (!Context)
 774     return "";
 775
 776   // FIXME: Decide whether to implement this for non-C++ languages.
 777   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
 778     return "";
 779
 780   std::string CS;
 781   SmallVector<const DIScope *, 1> Parents;
 782   while (!isa<DICompileUnit>(Context)) {
 783     Parents.push_back(Context);
 784     if (Context->getScope())
 785       Context = resolve(Context->getScope());
 786     else
 787       // Structure, etc types will have a NULL context if they're at the top
 788       // level.
 789       break;
 790   }
 791
 792   // Reverse iterate over our list to go from the outermost construct to the
 793   // innermost.
 794   for (auto I = Parents.rbegin(), E = Parents.rend(); I != E; ++I) {
 795     const DIScope *Ctx = *I;
 796     StringRef Name = Ctx->getName();
 797     if (Name.empty() && isa<DINamespace>(Ctx))
 798       Name = "(anonymous namespace)";
 799     if (!Name.empty()) {
 800       CS += Name;
 801       CS += "::";
 802     }
 803   }
 804   return CS;
 805 }
 806
 807 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
 808   // Get core information.
 809   StringRef Name = BTy->getName();
 810   // Add name if not anonymous or intermediate type.
 811   if (!Name.empty())
 812     addString(Buffer, dwarf::DW_AT_name, Name);
 813
 814   // An unspecified type only has a name attribute.
 815   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
 816     return;
 817
 818   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 819           BTy->getEncoding());
 820
 821   uint64_t Size = BTy->getSizeInBits() >> 3;
 822   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 823 }
 824
 825 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
 826   // Get core information.
 827   StringRef Name = DTy->getName();
 828   uint64_t Size = DTy->getSizeInBits() >> 3;
 829   uint16_t Tag = Buffer.getTag();
 830
 831   // Map to main type, void will not have a type.
 832   const DIType *FromTy = resolve(DTy->getBaseType());
 833   if (FromTy)
 834     addType(Buffer, FromTy);
 835
 836   // Add name if not anonymous or intermediate type.
 837   if (!Name.empty())
 838     addString(Buffer, dwarf::DW_AT_name, Name);
 839
 840   // Add size if non-zero (derived types might be zero-sized.)
 841   if (Size && Tag != dwarf::DW_TAG_pointer_type
 842            && Tag != dwarf::DW_TAG_ptr_to_member_type)
 843     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 844
 845   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
 846     addDIEEntry(
 847         Buffer, dwarf::DW_AT_containing_type,
 848         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
 849   // Add source line info if available and TyDesc is not a forward declaration.
 850   if (!DTy->isForwardDecl())
 851     addSourceLine(Buffer, DTy);
 852 }
 853
 854 void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
 855   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
 856     const DIType *Ty = resolve(Args[i]);
 857     if (!Ty) {
 858       assert(i == N-1 && "Unspecified parameter must be the last argument");
 859       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
 860     } else {
 861       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
 862       addType(Arg, Ty);
 863       if (Ty->isArtificial())
 864         addFlag(Arg, dwarf::DW_AT_artificial);
 865     }
 866   }
 867 }
 868
 869 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
 870   // Add return type.  A void return won't have a type.
 871   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
 872   if (Elements.size())
 873     if (auto RTy = resolve(Elements[0]))
 874       addType(Buffer, RTy);
 875
 876   bool isPrototyped = true;
 877   if (Elements.size() == 2 && !Elements[1])
 878     isPrototyped = false;
 879
 880   constructSubprogramArguments(Buffer, Elements);
 881
 882   // Add prototype flag if we're dealing with a C language and the function has
 883   // been prototyped.
 884   uint16_t Language = getLanguage();
 885   if (isPrototyped &&
 886       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
 887        Language == dwarf::DW_LANG_ObjC))
 888     addFlag(Buffer, dwarf::DW_AT_prototyped);
 889
 890   if (CTy->isLValueReference())
 891     addFlag(Buffer, dwarf::DW_AT_reference);
 892
 893   if (CTy->isRValueReference())
 894     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
 895 }
 896
 897 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
 898   // Add name if not anonymous or intermediate type.
 899   StringRef Name = CTy->getName();
 900
 901   uint64_t Size = CTy->getSizeInBits() >> 3;
 902   uint16_t Tag = Buffer.getTag();
 903
 904   switch (Tag) {
 905   case dwarf::DW_TAG_array_type:
 906     constructArrayTypeDIE(Buffer, CTy);
 907     break;
 908   case dwarf::DW_TAG_enumeration_type:
 909     constructEnumTypeDIE(Buffer, CTy);
 910     break;
 911   case dwarf::DW_TAG_structure_type:
 912   case dwarf::DW_TAG_union_type:
 913   case dwarf::DW_TAG_class_type: {
 914     // Add elements to structure type.
 915     DINodeArray Elements = CTy->getElements();
 916     for (const auto *Element : Elements) {
 917       if (!Element)
 918         continue;
 919       if (auto *SP = dyn_cast<DISubprogram>(Element))
 920         getOrCreateSubprogramDIE(SP);
 921       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
 922         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
 923           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
 924           addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
 925         } else if (DDTy->isStaticMember()) {
 926           getOrCreateStaticMemberDIE(DDTy);
 927         } else {
 928           constructMemberDIE(Buffer, DDTy);
 929         }
 930       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
 931         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
 932         StringRef PropertyName = Property->getName();
 933         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 934         if (Property->getType())
 935           addType(ElemDie, Property->getType());
 936         addSourceLine(ElemDie, Property);
 937         StringRef GetterName = Property->getGetterName();
 938         if (!GetterName.empty())
 939           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 940         StringRef SetterName = Property->getSetterName();
 941         if (!SetterName.empty())
 942           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 943         if (unsigned PropertyAttributes = Property->getAttributes())
 944           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
 945                   PropertyAttributes);
 946       }
 947     }
 948
 949     if (CTy->isAppleBlockExtension())
 950       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
 951
 952     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
 953     // inside C++ composite types to point to the base class with the vtable.
 954     if (auto *ContainingType =
 955             dyn_cast_or_null<DICompositeType>(resolve(CTy->getVTableHolder())))
 956       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
 957                   *getOrCreateTypeDIE(ContainingType));
 958
 959     if (CTy->isObjcClassComplete())
 960       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
 961
 962     // Add template parameters to a class, structure or union types.
 963     // FIXME: The support isn't in the metadata for this yet.
 964     if (Tag == dwarf::DW_TAG_class_type ||
 965         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 966       addTemplateParams(Buffer, CTy->getTemplateParams());
 967
 968     break;
 969   }
 970   default:
 971     break;
 972   }
 973
 974   // Add name if not anonymous or intermediate type.
 975   if (!Name.empty())
 976     addString(Buffer, dwarf::DW_AT_name, Name);
 977
 978   if (Tag == dwarf::DW_TAG_enumeration_type ||
 979       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
 980       Tag == dwarf::DW_TAG_union_type) {
 981     // Add size if non-zero (derived types might be zero-sized.)
 982     // TODO: Do we care about size for enum forward declarations?
 983     if (Size)
 984       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 985     else if (!CTy->isForwardDecl())
 986       // Add zero size if it is not a forward declaration.
 987       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
 988
 989     // If we're a forward decl, say so.
 990     if (CTy->isForwardDecl())
 991       addFlag(Buffer, dwarf::DW_AT_declaration);
 992
 993     // Add source line info if available.
 994     if (!CTy->isForwardDecl())
 995       addSourceLine(Buffer, CTy);
 996
 997     // No harm in adding the runtime language to the declaration.
 998     unsigned RLang = CTy->getRuntimeLang();
 999     if (RLang)
1000       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
1001               RLang);
1002   }
1003 }
1004
1005 void DwarfUnit::constructTemplateTypeParameterDIE(
1006     DIE &Buffer, const DITemplateTypeParameter *TP) {
1007   DIE &ParamDIE =
1008       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
1009   // Add the type if it exists, it could be void and therefore no type.
1010   if (TP->getType())
1011     addType(ParamDIE, resolve(TP->getType()));
1012   if (!TP->getName().empty())
1013     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
1014 }
1015
1016 void DwarfUnit::constructTemplateValueParameterDIE(
1017     DIE &Buffer, const DITemplateValueParameter *VP) {
1018   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
1019
1020   // Add the type if there is one, template template and template parameter
1021   // packs will not have a type.
1022   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
1023     addType(ParamDIE, resolve(VP->getType()));
1024   if (!VP->getName().empty())
1025     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
1026   if (Metadata *Val = VP->getValue()) {
1027     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1028       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
1029     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
1030       // For declaration non-type template parameters (such as global values and
1031       // functions)
1032       DIELoc *Loc = new (DIEValueAllocator) DIELoc;
1033       addOpAddress(*Loc, Asm->getSymbol(GV));
1034       // Emit DW_OP_stack_value to use the address as the immediate value of the
1035       // parameter, rather than a pointer to it.
1036       addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
1037       addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
1038     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
1039       assert(isa<MDString>(Val));
1040       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
1041                 cast<MDString>(Val)->getString());
1042     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
1043       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
1044     }
1045   }
1046 }
1047
1048 DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
1049   // Construct the context before querying for the existence of the DIE in case
1050   // such construction creates the DIE.
1051   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
1052
1053   if (DIE *NDie = getDIE(NS))
1054     return NDie;
1055   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
1056
1057   StringRef Name = NS->getName();
1058   if (!Name.empty())
1059     addString(NDie, dwarf::DW_AT_name, NS->getName());
1060   else
1061     Name = "(anonymous namespace)";
1062   DD->addAccelNamespace(Name, NDie);
1063   addGlobalName(Name, NDie, NS->getScope());
1064   addSourceLine(NDie, NS);
1065   return &NDie;
1066 }
1067
1068 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
1069   // Construct the context before querying for the existence of the DIE in case
1070   // such construction creates the DIE (as is the case for member function
1071   // declarations).
1072   DIE *ContextDIE =
1073       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
1074
1075   if (DIE *SPDie = getDIE(SP))
1076     return SPDie;
1077
1078   if (auto *SPDecl = SP->getDeclaration()) {
1079     if (!Minimal) {
1080       // Add subprogram definitions to the CU die directly.
1081       ContextDIE = &getUnitDie();
1082       // Build the decl now to ensure it precedes the definition.
1083       getOrCreateSubprogramDIE(SPDecl);
1084     }
1085   }
1086
1087   // DW_TAG_inlined_subroutine may refer to this DIE.
1088   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
1089
1090   // Stop here and fill this in later, depending on whether or not this
1091   // subprogram turns out to have inlined instances or not.
1092   if (SP->isDefinition())
1093     return &SPDie;
1094
1095   applySubprogramAttributes(SP, SPDie);
1096   return &SPDie;
1097 }
1098
1099 bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
1100                                                     DIE &SPDie) {
1101   DIE *DeclDie = nullptr;
1102   StringRef DeclLinkageName;
1103   if (auto *SPDecl = SP->getDeclaration()) {
1104     DeclDie = getDIE(SPDecl);
1105     assert(DeclDie && "This DIE should've already been constructed when the "
1106                       "definition DIE was created in "
1107                       "getOrCreateSubprogramDIE");
1108     DeclLinkageName = SPDecl->getLinkageName();
1109   }
1110
1111   // Add function template parameters.
1112   addTemplateParams(SPDie, SP->getTemplateParams());
1113
1114   // Add the linkage name if we have one and it isn't in the Decl.
1115   StringRef LinkageName = SP->getLinkageName();
1116   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
1117           LinkageName == DeclLinkageName) &&
1118          "decl has a linkage name and it is different");
1119   if (DeclLinkageName.empty())
1120     addLinkageName(SPDie, LinkageName);
1121
1122   if (!DeclDie)
1123     return false;
1124
1125   // Refer to the function declaration where all the other attributes will be
1126   // found.
1127   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
1128   return true;
1129 }
1130
1131 void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
1132                                           bool Minimal) {
1133   if (!Minimal)
1134     if (applySubprogramDefinitionAttributes(SP, SPDie))
1135       return;
1136
1137   // Constructors and operators for anonymous aggregates do not have names.
1138   if (!SP->getName().empty())
1139     addString(SPDie, dwarf::DW_AT_name, SP->getName());
1140
1141   // Skip the rest of the attributes under -gmlt to save space.
1142   if (Minimal)
1143     return;
1144
1145   addSourceLine(SPDie, SP);
1146
1147   // Add the prototype if we have a prototype and we have a C like
1148   // language.
1149   uint16_t Language = getLanguage();
1150   if (SP->isPrototyped() &&
1151       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
1152        Language == dwarf::DW_LANG_ObjC))
1153     addFlag(SPDie, dwarf::DW_AT_prototyped);
1154
1155   const DISubroutineType *SPTy = SP->getType();
1156   assert(SPTy->getTag() == dwarf::DW_TAG_subroutine_type &&
1157          "the type of a subprogram should be a subroutine");
1158
1159   auto Args = SPTy->getTypeArray();
1160   // Add a return type. If this is a type like a C/C++ void type we don't add a
1161   // return type.
1162   if (Args.size())
1163     if (auto Ty = resolve(Args[0]))
1164       addType(SPDie, Ty);
1165
1166   unsigned VK = SP->getVirtuality();
1167   if (VK) {
1168     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1169     DIELoc *Block = getDIELoc();
1170     addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1171     addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
1172     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
1173     ContainingTypeMap.insert(
1174         std::make_pair(&SPDie, resolve(SP->getContainingType())));
1175   }
1176
1177   if (!SP->isDefinition()) {
1178     addFlag(SPDie, dwarf::DW_AT_declaration);
1179
1180     // Add arguments. Do not add arguments for subprogram definition. They will
1181     // be handled while processing variables.
1182     constructSubprogramArguments(SPDie, Args);
1183   }
1184
1185   if (SP->isArtificial())
1186     addFlag(SPDie, dwarf::DW_AT_artificial);
1187
1188   if (!SP->isLocalToUnit())
1189     addFlag(SPDie, dwarf::DW_AT_external);
1190
1191   if (SP->isOptimized())
1192     addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
1193
1194   if (unsigned isa = Asm->getISAEncoding())
1195     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1196
1197   if (SP->isLValueReference())
1198     addFlag(SPDie, dwarf::DW_AT_reference);
1199
1200   if (SP->isRValueReference())
1201     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
1202
1203   if (SP->isProtected())
1204     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1205             dwarf::DW_ACCESS_protected);
1206   else if (SP->isPrivate())
1207     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1208             dwarf::DW_ACCESS_private);
1209   else if (SP->isPublic())
1210     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1211             dwarf::DW_ACCESS_public);
1212
1213   if (SP->isExplicit())
1214     addFlag(SPDie, dwarf::DW_AT_explicit);
1215 }
1216
1217 void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
1218                                      DIE *IndexTy) {
1219   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
1220   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
1221
1222   // The LowerBound value defines the lower bounds which is typically zero for
1223   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
1224   // Count == -1 then the array is unbounded and we do not emit
1225   // DW_AT_lower_bound and DW_AT_count attributes.
1226   int64_t LowerBound = SR->getLowerBound();
1227   int64_t DefaultLowerBound = getDefaultLowerBound();
1228   int64_t Count = SR->getCount();
1229
1230   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
1231     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
1232
1233   if (Count != -1)
1234     // FIXME: An unbounded array should reference the expression that defines
1235     // the array.
1236     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
1237 }
1238
1239 DIE *DwarfUnit::getIndexTyDie() {
1240   if (IndexTyDie)
1241     return IndexTyDie;
1242   // Construct an integer type to use for indexes.
1243   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, UnitDie);
1244   addString(*IndexTyDie, dwarf::DW_AT_name, "sizetype");
1245   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
1246   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1247           dwarf::DW_ATE_unsigned);
1248   return IndexTyDie;
1249 }
1250
1251 void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1252   if (CTy->isVector())
1253     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
1254
1255   // Emit the element type.
1256   addType(Buffer, resolve(CTy->getBaseType()));
1257
1258   // Get an anonymous type for index type.
1259   // FIXME: This type should be passed down from the front end
1260   // as different languages may have different sizes for indexes.
1261   DIE *IdxTy = getIndexTyDie();
1262
1263   // Add subranges to array type.
1264   DINodeArray Elements = CTy->getElements();
1265   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1266     // FIXME: Should this really be such a loose cast?
1267     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
1268       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
1269         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
1270   }
1271 }
1272
1273 void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
1274   DINodeArray Elements = CTy->getElements();
1275
1276   // Add enumerators to enumeration type.
1277   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
1278     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
1279     if (Enum) {
1280       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
1281       StringRef Name = Enum->getName();
1282       addString(Enumerator, dwarf::DW_AT_name, Name);
1283       int64_t Value = Enum->getValue();
1284       addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata,
1285               Value);
1286     }
1287   }
1288   const DIType *DTy = resolve(CTy->getBaseType());
1289   if (DTy) {
1290     addType(Buffer, DTy);
1291     addFlag(Buffer, dwarf::DW_AT_enum_class);
1292   }
1293 }
1294
1295 void DwarfUnit::constructContainingTypeDIEs() {
1296   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
1297        CI != CE; ++CI) {
1298     DIE &SPDie = *CI->first;
1299     const DINode *D = CI->second;
1300     if (!D)
1301       continue;
1302     DIE *NDie = getDIE(D);
1303     if (!NDie)
1304       continue;
1305     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
1306   }
1307 }
1308
1309 void DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
1310   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
1311   StringRef Name = DT->getName();
1312   if (!Name.empty())
1313     addString(MemberDie, dwarf::DW_AT_name, Name);
1314
1315   addType(MemberDie, resolve(DT->getBaseType()));
1316
1317   addSourceLine(MemberDie, DT);
1318
1319   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
1320
1321     // For C++, virtual base classes are not at fixed offset. Use following
1322     // expression to extract appropriate offset from vtable.
1323     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1324
1325     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
1326     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1327     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1328     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1329     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
1330     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1331     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1332     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1333
1334     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
1335   } else {
1336     uint64_t Size = DT->getSizeInBits();
1337     uint64_t FieldSize = getBaseTypeSize(DD, DT);
1338     uint64_t OffsetInBytes;
1339
1340     if (FieldSize && Size != FieldSize) {
1341       // Handle bitfield, assume bytes are 8 bits.
1342       addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
1343       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
1344
1345       uint64_t Offset = DT->getOffsetInBits();
1346       uint64_t AlignMask = ~(DT->getAlignInBits() - 1);
1347       uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1348       uint64_t FieldOffset = (HiMark - FieldSize);
1349       Offset -= FieldOffset;
1350
1351       // Maybe we need to work from the other end.
1352       if (Asm->getDataLayout().isLittleEndian())
1353         Offset = FieldSize - (Offset + Size);
1354       addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
1355
1356       // Here DW_AT_data_member_location points to the anonymous
1357       // field that includes this bit field.
1358       OffsetInBytes = FieldOffset >> 3;
1359     } else
1360       // This is not a bitfield.
1361       OffsetInBytes = DT->getOffsetInBits() >> 3;
1362
1363     if (DD->getDwarfVersion() <= 2) {
1364       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
1365       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1366       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
1367       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
1368     } else
1369       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
1370               OffsetInBytes);
1371   }
1372
1373   if (DT->isProtected())
1374     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1375             dwarf::DW_ACCESS_protected);
1376   else if (DT->isPrivate())
1377     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1378             dwarf::DW_ACCESS_private);
1379   // Otherwise C++ member and base classes are considered public.
1380   else if (DT->isPublic())
1381     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1382             dwarf::DW_ACCESS_public);
1383   if (DT->isVirtual())
1384     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1385             dwarf::DW_VIRTUALITY_virtual);
1386
1387   // Objective-C properties.
1388   if (DINode *PNode = DT->getObjCProperty())
1389     if (DIE *PDie = getDIE(PNode))
1390       MemberDie.addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1391                          DIEEntry(*PDie));
1392
1393   if (DT->isArtificial())
1394     addFlag(MemberDie, dwarf::DW_AT_artificial);
1395 }
1396
1397 DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
1398   if (!DT)
1399     return nullptr;
1400
1401   // Construct the context before querying for the existence of the DIE in case
1402   // such construction creates the DIE.
1403   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
1404   assert(dwarf::isType(ContextDIE->getTag()) &&
1405          "Static member should belong to a type.");
1406
1407   if (DIE *StaticMemberDIE = getDIE(DT))
1408     return StaticMemberDIE;
1409
1410   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
1411
1412   const DIType *Ty = resolve(DT->getBaseType());
1413
1414   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
1415   addType(StaticMemberDIE, Ty);
1416   addSourceLine(StaticMemberDIE, DT);
1417   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
1418   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
1419
1420   // FIXME: We could omit private if the parent is a class_type, and
1421   // public if the parent is something else.
1422   if (DT->isProtected())
1423     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1424             dwarf::DW_ACCESS_protected);
1425   else if (DT->isPrivate())
1426     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1427             dwarf::DW_ACCESS_private);
1428   else if (DT->isPublic())
1429     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1430             dwarf::DW_ACCESS_public);
1431
1432   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1433     addConstantValue(StaticMemberDIE, CI, Ty);
1434   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
1435     addConstantFPValue(StaticMemberDIE, CFP);
1436
1437   return &StaticMemberDIE;
1438 }
1439
1440 void DwarfUnit::emitHeader(bool UseOffsets) {
1441   // Emit size of content not including length itself
1442   Asm->OutStreamer->AddComment("Length of Unit");
1443   Asm->EmitInt32(getHeaderSize() + UnitDie.getSize());
1444
1445   Asm->OutStreamer->AddComment("DWARF version number");
1446   Asm->EmitInt16(DD->getDwarfVersion());
1447   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
1448
1449   // We share one abbreviations table across all units so it's always at the
1450   // start of the section. Use a relocatable offset where needed to ensure
1451   // linking doesn't invalidate that offset.
1452   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1453   if (!UseOffsets)
1454     Asm->emitSectionOffset(TLOF.getDwarfAbbrevSection()->getBeginSymbol());
1455   else
1456     Asm->EmitInt32(0);
1457
1458   Asm->OutStreamer->AddComment("Address Size (in bytes)");
1459   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1460 }
1461
1462 void DwarfUnit::initSection(MCSection *Section) {
1463   assert(!this->Section);
1464   this->Section = Section;
1465 }
1466
1467 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
1468   DwarfUnit::emitHeader(UseOffsets);
1469   Asm->OutStreamer->AddComment("Type Signature");
1470   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
1471   Asm->OutStreamer->AddComment("Type DIE Offset");
1472   // In a skeleton type unit there is no type DIE so emit a zero offset.
1473   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
1474                                  sizeof(Ty->getOffset()));
1475 }
1476
1477 bool DwarfTypeUnit::isDwoUnit() const {
1478   // Since there are no skeleton type units, all type units are dwo type units
1479   // when split DWARF is being used.
1480   return DD->useSplitDwarf();
1481 }