LCOV - code coverage report
Current view: top level - lib/CodeGen/AsmPrinter - DwarfUnit.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 751 793 94.7 %
Date: 2018-07-13 00:08:38 Functions: 85 86 98.8 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "AddressPool.h"
      16             : #include "DwarfCompileUnit.h"
      17             : #include "DwarfDebug.h"
      18             : #include "DwarfExpression.h"
      19             : #include "llvm/ADT/APFloat.h"
      20             : #include "llvm/ADT/APInt.h"
      21             : #include "llvm/ADT/None.h"
      22             : #include "llvm/ADT/StringExtras.h"
      23             : #include "llvm/ADT/iterator_range.h"
      24             : #include "llvm/CodeGen/MachineFunction.h"
      25             : #include "llvm/CodeGen/MachineOperand.h"
      26             : #include "llvm/CodeGen/TargetRegisterInfo.h"
      27             : #include "llvm/CodeGen/TargetSubtargetInfo.h"
      28             : #include "llvm/IR/Constants.h"
      29             : #include "llvm/IR/DataLayout.h"
      30             : #include "llvm/IR/GlobalValue.h"
      31             : #include "llvm/IR/Metadata.h"
      32             : #include "llvm/MC/MCAsmInfo.h"
      33             : #include "llvm/MC/MCContext.h"
      34             : #include "llvm/MC/MCDwarf.h"
      35             : #include "llvm/MC/MCSection.h"
      36             : #include "llvm/MC/MCStreamer.h"
      37             : #include "llvm/MC/MachineLocation.h"
      38             : #include "llvm/Support/Casting.h"
      39             : #include "llvm/Support/CommandLine.h"
      40             : #include "llvm/Target/TargetLoweringObjectFile.h"
      41             : #include <cassert>
      42             : #include <cstdint>
      43             : #include <string>
      44             : #include <utility>
      45             : 
      46             : using namespace llvm;
      47             : 
      48             : #define DEBUG_TYPE "dwarfdebug"
      49             : 
      50             : static cl::opt<bool>
      51       99743 : GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
      52       99743 :                        cl::desc("Generate DWARF4 type units."),
      53      299229 :                        cl::init(false));
      54             : 
      55       89895 : DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
      56       89895 :                                        DIELoc &DIE)
      57       89895 :     : DwarfExpression(AP.getDwarfVersion()), AP(AP), DU(DU),
      58      179790 :       DIE(DIE) {}
      59             : 
      60       84719 : void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
      61       84719 :   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
      62       84719 : }
      63             : 
      64       53921 : void DIEDwarfExpression::emitSigned(int64_t Value) {
      65      107842 :   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
      66       53921 : }
      67             : 
      68          89 : void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
      69          89 :   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
      70          89 : }
      71             : 
      72       56630 : bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
      73             :                                          unsigned MachineReg) {
      74       56630 :   return MachineReg == TRI.getFrameRegister(*AP.MF);
      75             : }
      76             : 
      77        3194 : DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
      78        3194 :                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
      79        6388 :     : DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
      80       15970 :       CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
      81        3194 : }
      82             : 
      83          44 : DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
      84             :                              DwarfDebug *DW, DwarfFile *DWU,
      85          44 :                              MCDwarfDwoLineTable *SplitLineTable)
      86             :     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
      87          44 :       SplitLineTable(SplitLineTable) {
      88          44 : }
      89             : 
      90        6388 : DwarfUnit::~DwarfUnit() {
      91             :   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
      92             :     DIEBlocks[j]->~DIEBlock();
      93             :   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
      94             :     DIELocs[j]->~DIELoc();
      95        3194 : }
      96             : 
      97        3169 : int64_t DwarfUnit::getDefaultLowerBound() const {
      98        6338 :   switch (getLanguage()) {
      99             :   default:
     100             :     break;
     101             : 
     102             :   // The languages below have valid values in all DWARF versions.
     103             :   case dwarf::DW_LANG_C:
     104             :   case dwarf::DW_LANG_C89:
     105             :   case dwarf::DW_LANG_C_plus_plus:
     106             :     return 0;
     107             : 
     108           0 :   case dwarf::DW_LANG_Fortran77:
     109             :   case dwarf::DW_LANG_Fortran90:
     110           0 :     return 1;
     111             : 
     112             :   // The languages below have valid values only if the DWARF version >= 3.
     113         271 :   case dwarf::DW_LANG_C99:
     114             :   case dwarf::DW_LANG_ObjC:
     115             :   case dwarf::DW_LANG_ObjC_plus_plus:
     116         271 :     if (DD->getDwarfVersion() >= 3)
     117             :       return 0;
     118             :     break;
     119             : 
     120           0 :   case dwarf::DW_LANG_Fortran95:
     121           0 :     if (DD->getDwarfVersion() >= 3)
     122             :       return 1;
     123             :     break;
     124             : 
     125             :   // Starting with DWARF v4, all defined languages have valid values.
     126           0 :   case dwarf::DW_LANG_D:
     127             :   case dwarf::DW_LANG_Java:
     128             :   case dwarf::DW_LANG_Python:
     129             :   case dwarf::DW_LANG_UPC:
     130           0 :     if (DD->getDwarfVersion() >= 4)
     131             :       return 0;
     132             :     break;
     133             : 
     134           0 :   case dwarf::DW_LANG_Ada83:
     135             :   case dwarf::DW_LANG_Ada95:
     136             :   case dwarf::DW_LANG_Cobol74:
     137             :   case dwarf::DW_LANG_Cobol85:
     138             :   case dwarf::DW_LANG_Modula2:
     139             :   case dwarf::DW_LANG_Pascal83:
     140             :   case dwarf::DW_LANG_PLI:
     141           0 :     if (DD->getDwarfVersion() >= 4)
     142             :       return 1;
     143             :     break;
     144             : 
     145             :   // The languages below are new in DWARF v5.
     146           2 :   case dwarf::DW_LANG_BLISS:
     147             :   case dwarf::DW_LANG_C11:
     148             :   case dwarf::DW_LANG_C_plus_plus_03:
     149             :   case dwarf::DW_LANG_C_plus_plus_11:
     150             :   case dwarf::DW_LANG_C_plus_plus_14:
     151             :   case dwarf::DW_LANG_Dylan:
     152             :   case dwarf::DW_LANG_Go:
     153             :   case dwarf::DW_LANG_Haskell:
     154             :   case dwarf::DW_LANG_OCaml:
     155             :   case dwarf::DW_LANG_OpenCL:
     156             :   case dwarf::DW_LANG_RenderScript:
     157             :   case dwarf::DW_LANG_Rust:
     158             :   case dwarf::DW_LANG_Swift:
     159           2 :     if (DD->getDwarfVersion() >= 5)
     160             :       return 0;
     161             :     break;
     162             : 
     163           0 :   case dwarf::DW_LANG_Fortran03:
     164             :   case dwarf::DW_LANG_Fortran08:
     165             :   case dwarf::DW_LANG_Julia:
     166             :   case dwarf::DW_LANG_Modula3:
     167           0 :     if (DD->getDwarfVersion() >= 5)
     168             :       return 1;
     169             :     break;
     170             :   }
     171             : 
     172             :   return -1;
     173             : }
     174             : 
     175             : /// Check whether the DIE for this MDNode can be shared across CUs.
     176     3029881 : bool DwarfUnit::isShareableAcrossCUs(const DINode *D) const {
     177             :   // When the MDNode can be part of the type system, the DIE can be shared
     178             :   // across CUs.
     179             :   // Combining type units and cross-CU DIE sharing is lower value (since
     180             :   // cross-CU DIE sharing is used in LTO and removes type redundancy at that
     181             :   // level already) but may be implementable for some value in projects
     182             :   // building multiple independent libraries with LTO and then linking those
     183             :   // together.
     184     3029881 :   if (isDwoUnit() && !DD->shareAcrossDWOCUs())
     185             :     return false;
     186     1150013 :   return (isa<DIType>(D) ||
     187     2205083 :           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
     188             :          !GenerateDwarfTypeUnits;
     189             : }
     190             : 
     191     2332265 : DIE *DwarfUnit::getDIE(const DINode *D) const {
     192     2332265 :   if (isShareableAcrossCUs(D))
     193     2609446 :     return DU->getDIE(D);
     194     2055084 :   return MDNodeToDieMap.lookup(D);
     195             : }
     196             : 
     197      697616 : void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
     198      697616 :   if (isShareableAcrossCUs(Desc)) {
     199      380845 :     DU->insertDIE(Desc, D);
     200             :     return;
     201             :   }
     202      633542 :   MDNodeToDieMap.insert(std::make_pair(Desc, D));
     203             : }
     204             : 
     205      704458 : void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
     206      704458 :   if (DD->getDwarfVersion() >= 4)
     207             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
     208      703479 :                  DIEInteger(1));
     209             :   else
     210             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
     211         979 :                  DIEInteger(1));
     212      704458 : }
     213             : 
     214     1683636 : void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
     215             :                         Optional<dwarf::Form> Form, uint64_t Integer) {
     216     1683636 :   if (!Form)
     217             :     Form = DIEInteger::BestForm(false, Integer);
     218             :   assert(Form != dwarf::DW_FORM_implicit_const &&
     219             :          "DW_FORM_implicit_const is used only for signed integers");
     220     1683636 :   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
     221     1683636 : }
     222             : 
     223       94310 : void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
     224             :                         uint64_t Integer) {
     225       94310 :   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
     226       94310 : }
     227             : 
     228       53921 : void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
     229             :                         Optional<dwarf::Form> Form, int64_t Integer) {
     230       53921 :   if (!Form)
     231             :     Form = DIEInteger::BestForm(true, Integer);
     232       53921 :   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
     233       53921 : }
     234             : 
     235       53921 : void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
     236             :                         int64_t Integer) {
     237       53921 :   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
     238       53921 : }
     239             : 
     240      720414 : void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
     241             :                           StringRef String) {
     242      720414 :   if (DD->useInlineStrings()) {
     243             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string,
     244         466 :                  new (DIEValueAllocator)
     245         932 :                      DIEInlineString(String, DIEValueAllocator));
     246         466 :     return;
     247             :   }
     248     1439896 :   auto StringPoolEntry = DU->getStringPool().getEntry(*Asm, String);
     249             :   dwarf::Form IxForm =
     250      719948 :       isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
     251             :   // For DWARF v5 and beyond, use the smallest strx? form possible.
     252     1439896 :   if (useSegmentedStringOffsetsTable()) {
     253             :     IxForm = dwarf::DW_FORM_strx1;
     254             :     unsigned Index = StringPoolEntry.getIndex();
     255         418 :     if (Index > 0xffffff)
     256             :       IxForm = dwarf::DW_FORM_strx4;
     257         418 :     else if (Index > 0xffff)
     258             :       IxForm = dwarf::DW_FORM_strx3;
     259         418 :     else if (Index > 0xff)
     260             :       IxForm = dwarf::DW_FORM_strx2;
     261             :   }
     262             :   Die.addValue(DIEValueAllocator, Attribute, IxForm,
     263      719948 :                DIEString(StringPoolEntry));
     264             : }
     265             : 
     266       60298 : DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
     267             :                                                  dwarf::Attribute Attribute,
     268             :                                                  dwarf::Form Form,
     269             :                                                  const MCSymbol *Label) {
     270      120596 :   return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
     271             : }
     272             : 
     273        2134 : void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
     274        2134 :   addLabel(Die, (dwarf::Attribute)0, Form, Label);
     275        2134 : }
     276             : 
     277          22 : void DwarfUnit::addSectionOffset(DIE &Die, dwarf::Attribute Attribute,
     278             :                                  uint64_t Integer) {
     279          22 :   if (DD->getDwarfVersion() >= 4)
     280          22 :     addUInt(Die, Attribute, dwarf::DW_FORM_sec_offset, Integer);
     281             :   else
     282           0 :     addUInt(Die, Attribute, dwarf::DW_FORM_data4, Integer);
     283          22 : }
     284             : 
     285     1345820 : MD5::MD5Result *DwarfUnit::getMD5AsBytes(const DIFile *File) const {
     286             :   assert(File);
     287     1345820 :   if (DD->getDwarfVersion() < 5)
     288             :     return nullptr;
     289             :   Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
     290          76 :   if (!Checksum || Checksum->Kind != DIFile::CSK_MD5)
     291             :     return nullptr;
     292             : 
     293             :   // Convert the string checksum to an MD5Result for the streamer.
     294             :   // The verifier validates the checksum so we assume it's okay.
     295             :   // An MD5 checksum is 16 bytes.
     296          37 :   std::string ChecksumString = fromHex(Checksum->Value);
     297          74 :   void *CKMem = Asm->OutStreamer->getContext().allocate(16, 1);
     298          37 :   memcpy(CKMem, ChecksumString.data(), 16);
     299             :   return reinterpret_cast<MD5::MD5Result *>(CKMem);
     300             : }
     301             : 
     302          69 : unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
     303          69 :   if (!SplitLineTable)
     304          33 :     return getCU().getOrCreateSourceID(File);
     305          36 :   if (!UsedLineTable) {
     306          22 :     UsedLineTable = true;
     307             :     // This is a split type unit that needs a line table.
     308          44 :     addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
     309             :   }
     310          72 :   return SplitLineTable->getFile(File->getDirectory(), File->getFilename(),
     311          36 :                                  getMD5AsBytes(File), File->getSource());
     312             : }
     313             : 
     314        2620 : void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
     315        2620 :   if (!DD->useSplitDwarf()) {
     316        2134 :     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
     317        2134 :     addLabel(Die, dwarf::DW_FORM_udata, Sym);
     318             :   } else {
     319         486 :     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
     320         486 :     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
     321         972 :             DD->getAddressPool().getIndex(Sym));
     322             :   }
     323        2620 : }
     324             : 
     325       82023 : void DwarfUnit::addLabelDelta(DIE &Die, dwarf::Attribute Attribute,
     326             :                               const MCSymbol *Hi, const MCSymbol *Lo) {
     327             :   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_data4,
     328       82023 :                new (DIEValueAllocator) DIEDelta(Hi, Lo));
     329       82023 : }
     330             : 
     331      258193 : void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
     332      258193 :   addDIEEntry(Die, Attribute, DIEEntry(Entry));
     333      258193 : }
     334             : 
     335          46 : void DwarfUnit::addDIETypeSignature(DIE &Die, uint64_t Signature) {
     336             :   // Flag the type unit reference as a declaration so that if it contains
     337             :   // members (implicit special members, static data member definitions, member
     338             :   // declarations for definitions in this CU, etc) consumers don't get confused
     339             :   // and think this is a full definition.
     340          46 :   addFlag(Die, dwarf::DW_AT_declaration);
     341             : 
     342             :   Die.addValue(DIEValueAllocator, dwarf::DW_AT_signature,
     343          46 :                dwarf::DW_FORM_ref_sig8, DIEInteger(Signature));
     344          46 : }
     345             : 
     346     1251760 : void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
     347             :                             DIEEntry Entry) {
     348     1251760 :   const DIEUnit *CU = Die.getUnit();
     349     1251760 :   const DIEUnit *EntryCU = Entry.getEntry().getUnit();
     350     1251760 :   if (!CU)
     351             :     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
     352      200640 :     CU = getUnitDie().getUnit();
     353     1251760 :   if (!EntryCU)
     354           2 :     EntryCU = getUnitDie().getUnit();
     355             :   Die.addValue(DIEValueAllocator, Attribute,
     356             :                EntryCU == CU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
     357     1251760 :                Entry);
     358     1251760 : }
     359             : 
     360     1134279 : DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
     361     1134279 :   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
     362     1134279 :   if (N)
     363      517486 :     insertDIE(N, &Die);
     364     1134279 :   return Die;
     365             : }
     366             : 
     367       90258 : void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
     368       90258 :   Loc->ComputeSize(Asm);
     369       90258 :   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
     370             :   Die.addValue(DIEValueAllocator, Attribute,
     371      180516 :                Loc->BestForm(DD->getDwarfVersion()), Loc);
     372       90258 : }
     373             : 
     374           5 : void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute,
     375             :                          DIEBlock *Block) {
     376           5 :   Block->ComputeSize(Asm);
     377           5 :   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
     378          10 :   Die.addValue(DIEValueAllocator, Attribute, Block->BestForm(), Block);
     379           5 : }
     380             : 
     381      687112 : void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
     382      687112 :   if (Line == 0)
     383             :     return;
     384             : 
     385      538583 :   unsigned FileID = getOrCreateSourceID(File);
     386             :   assert(FileID && "Invalid file id");
     387     1077166 :   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
     388     1077166 :   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
     389             : }
     390             : 
     391       62359 : void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
     392             :   assert(V);
     393             : 
     394       62359 :   addSourceLine(Die, V->getLine(), V->getFile());
     395       62359 : }
     396             : 
     397        3938 : void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
     398             :   assert(G);
     399             : 
     400        3938 :   addSourceLine(Die, G->getLine(), G->getFile());
     401        3938 : }
     402             : 
     403      257285 : void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
     404             :   assert(SP);
     405             : 
     406      257285 :   addSourceLine(Die, SP->getLine(), SP->getFile());
     407      257285 : }
     408             : 
     409      268098 : void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
     410             :   assert(Ty);
     411             : 
     412      268098 :   addSourceLine(Die, Ty->getLine(), Ty->getFile());
     413      268098 : }
     414             : 
     415          10 : void DwarfUnit::addSourceLine(DIE &Die, const DIObjCProperty *Ty) {
     416             :   assert(Ty);
     417             : 
     418          10 :   addSourceLine(Die, Ty->getLine(), Ty->getFile());
     419          10 : }
     420             : 
     421             : /* Byref variables, in Blocks, are declared by the programmer as "SomeType
     422             :    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
     423             :    gives the variable VarName either the struct, or a pointer to the struct, as
     424             :    its type.  This is necessary for various behind-the-scenes things the
     425             :    compiler needs to do with by-reference variables in Blocks.
     426             : 
     427             :    However, as far as the original *programmer* is concerned, the variable
     428             :    should still have type 'SomeType', as originally declared.
     429             : 
     430             :    The function getBlockByrefType dives into the __Block_byref_x_VarName
     431             :    struct to find the original type of the variable, which is then assigned to
     432             :    the variable's Debug Information Entry as its real type.  So far, so good.
     433             :    However now the debugger will expect the variable VarName to have the type
     434             :    SomeType.  So we need the location attribute for the variable to be an
     435             :    expression that explains to the debugger how to navigate through the
     436             :    pointers and struct to find the actual variable of type SomeType.
     437             : 
     438             :    The following function does just that.  We start by getting
     439             :    the "normal" location for the variable. This will be the location
     440             :    of either the struct __Block_byref_x_VarName or the pointer to the
     441             :    struct __Block_byref_x_VarName.
     442             : 
     443             :    The struct will look something like:
     444             : 
     445             :    struct __Block_byref_x_VarName {
     446             :      ... <various fields>
     447             :      struct __Block_byref_x_VarName *forwarding;
     448             :      ... <various other fields>
     449             :      SomeType VarName;
     450             :      ... <maybe more fields>
     451             :    };
     452             : 
     453             :    If we are given the struct directly (as our starting point) we
     454             :    need to tell the debugger to:
     455             : 
     456             :    1).  Add the offset of the forwarding field.
     457             : 
     458             :    2).  Follow that pointer to get the real __Block_byref_x_VarName
     459             :    struct to use (the real one may have been copied onto the heap).
     460             : 
     461             :    3).  Add the offset for the field VarName, to find the actual variable.
     462             : 
     463             :    If we started with a pointer to the struct, then we need to
     464             :    dereference that pointer first, before the other steps.
     465             :    Translating this into DWARF ops, we will need to append the following
     466             :    to the current location description for the variable:
     467             : 
     468             :    DW_OP_deref                    -- optional, if we start with a pointer
     469             :    DW_OP_plus_uconst <forward_fld_offset>
     470             :    DW_OP_deref
     471             :    DW_OP_plus_uconst <varName_fld_offset>
     472             : 
     473             :    That is what this function does.  */
     474             : 
     475           0 : void DwarfUnit::addBlockByrefAddress(const DbgVariable &DV, DIE &Die,
     476             :                                      dwarf::Attribute Attribute,
     477             :                                      const MachineLocation &Location) {
     478           0 :   const DIType *Ty = DV.getType();
     479             :   const DIType *TmpTy = Ty;
     480           0 :   uint16_t Tag = Ty->getTag();
     481             :   bool isPointer = false;
     482             : 
     483           0 :   StringRef varName = DV.getName();
     484             : 
     485           0 :   if (Tag == dwarf::DW_TAG_pointer_type) {
     486             :     auto *DTy = cast<DIDerivedType>(Ty);
     487             :     TmpTy = resolve(DTy->getBaseType());
     488             :     isPointer = true;
     489             :   }
     490             : 
     491             :   // Find the __forwarding field and the variable field in the __Block_byref
     492             :   // struct.
     493             :   DINodeArray Fields = cast<DICompositeType>(TmpTy)->getElements();
     494             :   const DIDerivedType *varField = nullptr;
     495             :   const DIDerivedType *forwardingField = nullptr;
     496             : 
     497           0 :   for (unsigned i = 0, N = Fields.size(); i < N; ++i) {
     498             :     auto *DT = cast<DIDerivedType>(Fields[i]);
     499             :     StringRef fieldName = DT->getName();
     500             :     if (fieldName == "__forwarding")
     501             :       forwardingField = DT;
     502             :     else if (fieldName == varName)
     503             :       varField = DT;
     504             :   }
     505             : 
     506             :   // Get the offsets for the forwarding field and the variable field.
     507           0 :   unsigned forwardingFieldOffset = forwardingField->getOffsetInBits() >> 3;
     508           0 :   unsigned varFieldOffset = varField->getOffsetInBits() >> 2;
     509             : 
     510             :   // Decode the original location, and use that as the start of the byref
     511             :   // variable's location.
     512           0 :   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     513           0 :   DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     514           0 :   if (Location.isIndirect())
     515             :     DwarfExpr.setMemoryLocationKind();
     516             : 
     517             :   SmallVector<uint64_t, 6> Ops;
     518             :   // If we started with a pointer to the __Block_byref... struct, then
     519             :   // the first thing we need to do is dereference the pointer (DW_OP_deref).
     520           0 :   if (isPointer)
     521           0 :     Ops.push_back(dwarf::DW_OP_deref);
     522             : 
     523             :   // Next add the offset for the '__forwarding' field:
     524             :   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
     525             :   // adding the offset if it's 0.
     526           0 :   if (forwardingFieldOffset > 0) {
     527           0 :     Ops.push_back(dwarf::DW_OP_plus_uconst);
     528           0 :     Ops.push_back(forwardingFieldOffset);
     529             :   }
     530             : 
     531             :   // Now dereference the __forwarding field to get to the real __Block_byref
     532             :   // struct:  DW_OP_deref.
     533           0 :   Ops.push_back(dwarf::DW_OP_deref);
     534             : 
     535             :   // Now that we've got the real __Block_byref... struct, add the offset
     536             :   // for the variable's field to get to the location of the actual variable:
     537             :   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
     538           0 :   if (varFieldOffset > 0) {
     539           0 :     Ops.push_back(dwarf::DW_OP_plus_uconst);
     540           0 :     Ops.push_back(varFieldOffset);
     541             :   }
     542             : 
     543             :   DIExpressionCursor Cursor(Ops);
     544           0 :   const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
     545           0 :   if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
     546             :     return;
     547           0 :   DwarfExpr.addExpression(std::move(Cursor));
     548             : 
     549             :   // Now attach the location information to the DIE.
     550           0 :   addBlock(Die, Attribute, DwarfExpr.finalize());
     551             : }
     552             : 
     553             : /// Return true if type encoding is unsigned.
     554       19473 : static bool isUnsignedDIType(DwarfDebug *DD, const DIType *Ty) {
     555             :   if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
     556             :     // FIXME: Enums without a fixed underlying type have unknown signedness
     557             :     // here, leading to incorrectly emitted constants.
     558        2538 :     if (CTy->getTag() == dwarf::DW_TAG_enumeration_type)
     559             :       return false;
     560             : 
     561             :     // (Pieces of) aggregate types that get hacked apart by SROA may be
     562             :     // represented by a constant. Encode them as unsigned bytes.
     563          13 :     return true;
     564             :   }
     565             : 
     566             :   if (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
     567        9416 :     dwarf::Tag T = (dwarf::Tag)Ty->getTag();
     568             :     // Encode pointer constants as unsigned bytes. This is used at least for
     569             :     // null pointer constant emission.
     570             :     // FIXME: reference and rvalue_reference /probably/ shouldn't be allowed
     571             :     // here, but accept them for now due to a bug in SROA producing bogus
     572             :     // dbg.values.
     573       18832 :     if (T == dwarf::DW_TAG_pointer_type ||
     574        9416 :         T == dwarf::DW_TAG_ptr_to_member_type ||
     575       18824 :         T == dwarf::DW_TAG_reference_type ||
     576        9412 :         T == dwarf::DW_TAG_rvalue_reference_type)
     577             :       return true;
     578             :     assert(T == dwarf::DW_TAG_typedef || T == dwarf::DW_TAG_const_type ||
     579             :            T == dwarf::DW_TAG_volatile_type ||
     580             :            T == dwarf::DW_TAG_restrict_type || T == dwarf::DW_TAG_atomic_type);
     581             :     DITypeRef Deriv = DTy->getBaseType();
     582             :     assert(Deriv && "Expected valid base type");
     583        9412 :     return isUnsignedDIType(DD, DD->resolve(Deriv));
     584             :   }
     585             : 
     586             :   auto *BTy = cast<DIBasicType>(Ty);
     587       16931 :   unsigned Encoding = BTy->getEncoding();
     588             :   assert((Encoding == dwarf::DW_ATE_unsigned ||
     589             :           Encoding == dwarf::DW_ATE_unsigned_char ||
     590             :           Encoding == dwarf::DW_ATE_signed ||
     591             :           Encoding == dwarf::DW_ATE_signed_char ||
     592             :           Encoding == dwarf::DW_ATE_float || Encoding == dwarf::DW_ATE_UTF ||
     593             :           Encoding == dwarf::DW_ATE_boolean ||
     594             :           (Ty->getTag() == dwarf::DW_TAG_unspecified_type &&
     595             :            Ty->getName() == "decltype(nullptr)")) &&
     596             :          "Unsupported encoding");
     597       16931 :   return Encoding == dwarf::DW_ATE_unsigned ||
     598       16931 :          Encoding == dwarf::DW_ATE_unsigned_char ||
     599       36188 :          Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
     600        2326 :          Ty->getTag() == dwarf::DW_TAG_unspecified_type;
     601             : }
     602             : 
     603           4 : void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
     604             :   assert(MO.isFPImm() && "Invalid machine operand!");
     605           4 :   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
     606           4 :   APFloat FPImm = MO.getFPImm()->getValueAPF();
     607             : 
     608             :   // Get the raw data form of the floating point.
     609           4 :   const APInt FltVal = FPImm.bitcastToAPInt();
     610             :   const char *FltPtr = (const char *)FltVal.getRawData();
     611             : 
     612           4 :   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
     613           4 :   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
     614           4 :   int Incr = (LittleEndian ? 1 : -1);
     615           4 :   int Start = (LittleEndian ? 0 : NumBytes - 1);
     616           4 :   int Stop = (LittleEndian ? NumBytes : -1);
     617             : 
     618             :   // Output the constant to DWARF one byte at a time.
     619          60 :   for (; Start != Stop; Start += Incr)
     620          28 :     addUInt(*Block, dwarf::DW_FORM_data1, (unsigned char)0xFF & FltPtr[Start]);
     621             : 
     622           4 :   addBlock(Die, dwarf::DW_AT_const_value, Block);
     623           4 : }
     624             : 
     625           2 : void DwarfUnit::addConstantFPValue(DIE &Die, const ConstantFP *CFP) {
     626             :   // Pass this down to addConstantValue as an unsigned bag of bits.
     627           4 :   addConstantValue(Die, CFP->getValueAPF().bitcastToAPInt(), true);
     628           2 : }
     629             : 
     630       17320 : void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
     631             :                                  const DIType *Ty) {
     632       17320 :   addConstantValue(Die, CI->getValue(), Ty);
     633       17320 : }
     634             : 
     635         839 : void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
     636             :                                  const DIType *Ty) {
     637             :   assert(MO.isImm() && "Invalid machine operand!");
     638             : 
     639         839 :   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
     640         839 : }
     641             : 
     642       30134 : void DwarfUnit::addConstantValue(DIE &Die, bool Unsigned, uint64_t Val) {
     643             :   // FIXME: This is a bit conservative/simple - it emits negative values always
     644             :   // sign extended to 64 bits rather than minimizing the number of bytes.
     645       30134 :   addUInt(Die, dwarf::DW_AT_const_value,
     646       30134 :           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
     647       30134 : }
     648             : 
     649       17320 : void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
     650       17320 :   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
     651       17320 : }
     652             : 
     653       17322 : void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
     654       17322 :   unsigned CIBitWidth = Val.getBitWidth();
     655       17322 :   if (CIBitWidth <= 64) {
     656       21711 :     addConstantValue(Die, Unsigned,
     657             :                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
     658       17321 :     return;
     659             :   }
     660             : 
     661           1 :   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
     662             : 
     663             :   // Get the raw data form of the large APInt.
     664             :   const uint64_t *Ptr64 = Val.getRawData();
     665             : 
     666           1 :   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
     667           1 :   bool LittleEndian = Asm->getDataLayout().isLittleEndian();
     668             : 
     669             :   // Output the constant to DWARF one byte at a time.
     670          33 :   for (int i = 0; i < NumBytes; i++) {
     671             :     uint8_t c;
     672          16 :     if (LittleEndian)
     673          16 :       c = Ptr64[i / 8] >> (8 * (i & 7));
     674             :     else
     675           0 :       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
     676          16 :     addUInt(*Block, dwarf::DW_FORM_data1, c);
     677             :   }
     678             : 
     679           1 :   addBlock(Die, dwarf::DW_AT_const_value, Block);
     680             : }
     681             : 
     682      269259 : void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
     683      269259 :   if (!LinkageName.empty())
     684      294652 :     addString(Die,
     685      147326 :               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
     686             :                                          : dwarf::DW_AT_MIPS_linkage_name,
     687             :               GlobalValue::dropLLVMManglingEscape(LinkageName));
     688      269259 : }
     689             : 
     690      320395 : void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
     691             :   // Add template parameters.
     692      392343 :   for (const auto *Element : TParams) {
     693             :     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
     694       51473 :       constructTemplateTypeParameterDIE(Buffer, TTP);
     695             :     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
     696       20475 :       constructTemplateValueParameterDIE(Buffer, TVP);
     697             :   }
     698      320395 : }
     699             : 
     700             : /// Add thrown types.
     701      257284 : void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
     702      257286 :   for (const auto *Ty : ThrownTypes) {
     703           2 :     DIE &TT = createAndAddDIE(dwarf::DW_TAG_thrown_type, Die);
     704           2 :     addType(TT, cast<DIType>(Ty));
     705             :   }
     706      257284 : }
     707             : 
     708     2351502 : DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
     709     3370931 :   if (!Context || isa<DIFile>(Context))
     710     1416541 :     return &getUnitDie();
     711             :   if (auto *T = dyn_cast<DIType>(Context))
     712      322664 :     return getOrCreateTypeDIE(T);
     713             :   if (auto *NS = dyn_cast<DINamespace>(Context))
     714      605125 :     return getOrCreateNameSpace(NS);
     715             :   if (auto *SP = dyn_cast<DISubprogram>(Context))
     716        1816 :     return getOrCreateSubprogramDIE(SP);
     717             :   if (auto *M = dyn_cast<DIModule>(Context))
     718         242 :     return getOrCreateModule(M);
     719        5114 :   return getDIE(Context);
     720             : }
     721             : 
     722          44 : DIE *DwarfTypeUnit::createTypeDIE(const DICompositeType *Ty) {
     723          44 :   auto *Context = resolve(Ty->getScope());
     724          44 :   DIE *ContextDIE = getOrCreateContextDIE(Context);
     725             : 
     726          44 :   if (DIE *TyDIE = getDIE(Ty))
     727             :     return TyDIE;
     728             : 
     729             :   // Create new type.
     730          88 :   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
     731             : 
     732          44 :   constructTypeDIE(TyDIE, cast<DICompositeType>(Ty));
     733             : 
     734          44 :   updateAcceleratorTables(Context, Ty, TyDIE);
     735          44 :   return &TyDIE;
     736             : }
     737             : 
     738     1337829 : DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
     739     1337851 :   if (!TyNode)
     740             :     return nullptr;
     741             : 
     742             :   auto *Ty = cast<DIType>(TyNode);
     743             : 
     744             :   // DW_TAG_restrict_type is not supported in DWARF2
     745     1337851 :   if (Ty->getTag() == dwarf::DW_TAG_restrict_type && DD->getDwarfVersion() <= 2)
     746          21 :     return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
     747             : 
     748             :   // DW_TAG_atomic_type is not supported in DWARF < 5
     749     1337832 :   if (Ty->getTag() == dwarf::DW_TAG_atomic_type && DD->getDwarfVersion() < 5)
     750           1 :     return getOrCreateTypeDIE(resolve(cast<DIDerivedType>(Ty)->getBaseType()));
     751             : 
     752             :   // Construct the context before querying for the existence of the DIE in case
     753             :   // such construction creates the DIE.
     754             :   auto *Context = resolve(Ty->getScope());
     755     1337829 :   DIE *ContextDIE = getOrCreateContextDIE(Context);
     756             :   assert(ContextDIE);
     757             : 
     758     1337829 :   if (DIE *TyDIE = getDIE(Ty))
     759             :     return TyDIE;
     760             : 
     761             :   // Create new type.
     762      451288 :   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
     763             : 
     764      225644 :   updateAcceleratorTables(Context, Ty, TyDIE);
     765             : 
     766             :   if (auto *BT = dyn_cast<DIBasicType>(Ty))
     767       10151 :     constructTypeDIE(TyDIE, BT);
     768             :   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
     769        1705 :     constructTypeDIE(TyDIE, STy);
     770             :   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
     771       39962 :     if (GenerateDwarfTypeUnits && !Ty->isForwardDecl())
     772             :       if (MDString *TypeId = CTy->getRawIdentifier()) {
     773          54 :         DD->addDwarfTypeUnitType(getCU(), TypeId->getString(), TyDIE, CTy);
     774             :         // Skip updating the accelerator tables since this is not the full type.
     775          54 :         return &TyDIE;
     776             :       }
     777       39849 :     constructTypeDIE(TyDIE, CTy);
     778             :   } else {
     779      173885 :     constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
     780             :   }
     781             : 
     782             :   return &TyDIE;
     783             : }
     784             : 
     785      225688 : void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
     786             :                                         const DIType *Ty, const DIE &TyDIE) {
     787      322849 :   if (!Ty->getName().empty() && !Ty->isForwardDecl()) {
     788             :     bool IsImplementation = false;
     789             :     if (auto *CT = dyn_cast<DICompositeType>(Ty)) {
     790             :       // A runtime language of 0 actually means C/C++ and that any
     791             :       // non-negative value is some version of Objective-C/C++.
     792       28585 :       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
     793             :     }
     794             :     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
     795      185794 :     DD->addAccelType(Ty->getName(), TyDIE, Flags);
     796             : 
     797      147991 :     if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
     798             :         isa<DINamespace>(Context))
     799       63800 :       addGlobalType(Ty, TyDIE, Context);
     800             :   }
     801      225688 : }
     802             : 
     803      993567 : void DwarfUnit::addType(DIE &Entity, const DIType *Ty,
     804             :                         dwarf::Attribute Attribute) {
     805             :   assert(Ty && "Trying to add a type that doesn't exist?");
     806     1987134 :   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
     807      993567 : }
     808             : 
     809      103207 : std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
     810      103207 :   if (!Context)
     811       39732 :     return "";
     812             : 
     813             :   // FIXME: Decide whether to implement this for non-C++ languages.
     814      126950 :   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
     815        1987 :     return "";
     816             : 
     817             :   std::string CS;
     818             :   SmallVector<const DIScope *, 1> Parents;
     819      200754 :   while (!isa<DICompileUnit>(Context)) {
     820       85136 :     Parents.push_back(Context);
     821      170272 :     if (Context->getScope())
     822       51852 :       Context = resolve(Context->getScope());
     823             :     else
     824             :       // Structure, etc types will have a NULL context if they're at the top
     825             :       // level.
     826             :       break;
     827             :   }
     828             : 
     829             :   // Reverse iterate over our list to go from the outermost construct to the
     830             :   // innermost.
     831       61488 :   for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
     832       85136 :     StringRef Name = Ctx->getName();
     833       88820 :     if (Name.empty() && isa<DINamespace>(Ctx))
     834             :       Name = "(anonymous namespace)";
     835       85136 :     if (!Name.empty()) {
     836             :       CS += Name;
     837             :       CS += "::";
     838             :     }
     839             :   }
     840             :   return CS;
     841             : }
     842             : 
     843       10151 : void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
     844             :   // Get core information.
     845       10151 :   StringRef Name = BTy->getName();
     846             :   // Add name if not anonymous or intermediate type.
     847       10151 :   if (!Name.empty())
     848       10143 :     addString(Buffer, dwarf::DW_AT_name, Name);
     849             : 
     850             :   // An unspecified type only has a name attribute.
     851       10151 :   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
     852         349 :     return;
     853             : 
     854       19604 :   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
     855        9802 :           BTy->getEncoding());
     856             : 
     857        9802 :   uint64_t Size = BTy->getSizeInBits() >> 3;
     858        9802 :   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
     859             : }
     860             : 
     861      173885 : void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
     862             :   // Get core information.
     863      173885 :   StringRef Name = DTy->getName();
     864      173885 :   uint64_t Size = DTy->getSizeInBits() >> 3;
     865      173885 :   uint16_t Tag = Buffer.getTag();
     866             : 
     867             :   // Map to main type, void will not have a type.
     868             :   const DIType *FromTy = resolve(DTy->getBaseType());
     869             :   if (FromTy)
     870      171976 :     addType(Buffer, FromTy);
     871             : 
     872             :   // Add name if not anonymous or intermediate type.
     873      173885 :   if (!Name.empty())
     874       54215 :     addString(Buffer, dwarf::DW_AT_name, Name);
     875             : 
     876             :   // Add size if non-zero (derived types might be zero-sized.)
     877      173885 :   if (Size && Tag != dwarf::DW_TAG_pointer_type
     878       41502 :            && Tag != dwarf::DW_TAG_ptr_to_member_type
     879       41502 :            && Tag != dwarf::DW_TAG_reference_type
     880        8065 :            && Tag != dwarf::DW_TAG_rvalue_reference_type)
     881           3 :     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
     882             : 
     883      173885 :   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
     884          16 :     addDIEEntry(
     885             :         Buffer, dwarf::DW_AT_containing_type,
     886          16 :         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
     887             :   // Add source line info if available and TyDesc is not a forward declaration.
     888      173885 :   if (!DTy->isForwardDecl())
     889      173885 :     addSourceLine(Buffer, DTy);
     890             : 
     891             :   // If DWARF address space value is other than None, add it for pointer and
     892             :   // reference types as DW_AT_address_class.
     893      173885 :   if (DTy->getDWARFAddressSpace() && (Tag == dwarf::DW_TAG_pointer_type ||
     894             :                                       Tag == dwarf::DW_TAG_reference_type))
     895           8 :     addUInt(Buffer, dwarf::DW_AT_address_class, dwarf::DW_FORM_data4,
     896             :             DTy->getDWARFAddressSpace().getValue());
     897      173885 : }
     898             : 
     899      246703 : void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
     900     1155931 :   for (unsigned i = 1, N = Args.size(); i < N; ++i) {
     901             :     const DIType *Ty = resolve(Args[i]);
     902             :     if (!Ty) {
     903             :       assert(i == N-1 && "Unspecified parameter must be the last argument");
     904        5124 :       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
     905             :     } else {
     906      449490 :       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
     907      449490 :       addType(Arg, Ty);
     908      449490 :       if (Ty->isArtificial())
     909      157618 :         addFlag(Arg, dwarf::DW_AT_artificial);
     910             :     }
     911             :   }
     912      246703 : }
     913             : 
     914        1705 : void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
     915             :   // Add return type.  A void return won't have a type.
     916             :   auto Elements = cast<DISubroutineType>(CTy)->getTypeArray();
     917        1705 :   if (Elements.size())
     918             :     if (auto RTy = resolve(Elements[0]))
     919        1020 :       addType(Buffer, RTy);
     920             : 
     921             :   bool isPrototyped = true;
     922        1963 :   if (Elements.size() == 2 && !Elements[1])
     923             :     isPrototyped = false;
     924             : 
     925        1705 :   constructSubprogramArguments(Buffer, Elements);
     926             : 
     927             :   // Add prototype flag if we're dealing with a C language and the function has
     928             :   // been prototyped.
     929        1705 :   uint16_t Language = getLanguage();
     930        3409 :   if (isPrototyped &&
     931        3387 :       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
     932             :        Language == dwarf::DW_LANG_ObjC))
     933          24 :     addFlag(Buffer, dwarf::DW_AT_prototyped);
     934             : 
     935             :   // Add a DW_AT_calling_convention if this has an explicit convention.
     936        1705 :   if (CTy->getCC() && CTy->getCC() != dwarf::DW_CC_normal)
     937           2 :     addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
     938             :             CTy->getCC());
     939             : 
     940        1705 :   if (CTy->isLValueReference())
     941           1 :     addFlag(Buffer, dwarf::DW_AT_reference);
     942             : 
     943        1705 :   if (CTy->isRValueReference())
     944           1 :     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
     945        1705 : }
     946             : 
     947       39902 : void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
     948             :   // Add name if not anonymous or intermediate type.
     949       39902 :   StringRef Name = CTy->getName();
     950             : 
     951       39902 :   uint64_t Size = CTy->getSizeInBits() >> 3;
     952       39902 :   uint16_t Tag = Buffer.getTag();
     953             : 
     954             :   switch (Tag) {
     955        3110 :   case dwarf::DW_TAG_array_type:
     956        3110 :     constructArrayTypeDIE(Buffer, CTy);
     957        3110 :     break;
     958        1355 :   case dwarf::DW_TAG_enumeration_type:
     959        1355 :     constructEnumTypeDIE(Buffer, CTy);
     960        1355 :     break;
     961       35437 :   case dwarf::DW_TAG_variant_part:
     962             :   case dwarf::DW_TAG_structure_type:
     963             :   case dwarf::DW_TAG_union_type:
     964             :   case dwarf::DW_TAG_class_type: {
     965             :     // Emit the discriminator for a variant part.
     966             :     DIDerivedType *Discriminator = nullptr;
     967       35437 :     if (Tag == dwarf::DW_TAG_variant_part) {
     968             :       Discriminator = CTy->getDiscriminator();
     969             :       if (Discriminator) {
     970             :         // DWARF says:
     971             :         //    If the variant part has a discriminant, the discriminant is
     972             :         //    represented by a separate debugging information entry which is
     973             :         //    a child of the variant part entry.
     974           1 :         DIE &DiscMember = constructMemberDIE(Buffer, Discriminator);
     975           1 :         addDIEEntry(Buffer, dwarf::DW_AT_discr, DiscMember);
     976             :       }
     977             :     }
     978             : 
     979             :     // Add elements to structure type.
     980             :     DINodeArray Elements = CTy->getElements();
     981      267300 :     for (const auto *Element : Elements) {
     982           0 :       if (!Element)
     983           0 :         continue;
     984             :       if (auto *SP = dyn_cast<DISubprogram>(Element))
     985      170069 :         getOrCreateSubprogramDIE(SP);
     986             :       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
     987       61777 :         if (DDTy->getTag() == dwarf::DW_TAG_friend) {
     988           1 :           DIE &ElemDie = createAndAddDIE(dwarf::DW_TAG_friend, Buffer);
     989           1 :           addType(ElemDie, resolve(DDTy->getBaseType()), dwarf::DW_AT_friend);
     990       61776 :         } else if (DDTy->isStaticMember()) {
     991        4504 :           getOrCreateStaticMemberDIE(DDTy);
     992       57272 :         } else if (Tag == dwarf::DW_TAG_variant_part) {
     993             :           // When emitting a variant part, wrap each member in
     994             :           // DW_TAG_variant.
     995           3 :           DIE &Variant = createAndAddDIE(dwarf::DW_TAG_variant, Buffer);
     996             :           if (const ConstantInt *CI =
     997             :               dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
     998           1 :             if (isUnsignedDIType(DD, resolve(Discriminator->getBaseType())))
     999           1 :               addUInt(Variant, dwarf::DW_AT_discr_value, None, CI->getZExtValue());
    1000             :             else
    1001           0 :               addSInt(Variant, dwarf::DW_AT_discr_value, None, CI->getSExtValue());
    1002             :           }
    1003           3 :           constructMemberDIE(Variant, DDTy);
    1004             :         } else {
    1005       57269 :           constructMemberDIE(Buffer, DDTy);
    1006             :         }
    1007             :       } else if (auto *Property = dyn_cast<DIObjCProperty>(Element)) {
    1008          20 :         DIE &ElemDie = createAndAddDIE(Property->getTag(), Buffer);
    1009          10 :         StringRef PropertyName = Property->getName();
    1010          10 :         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
    1011          10 :         if (Property->getType())
    1012           9 :           addType(ElemDie, resolve(Property->getType()));
    1013          10 :         addSourceLine(ElemDie, Property);
    1014          10 :         StringRef GetterName = Property->getGetterName();
    1015          10 :         if (!GetterName.empty())
    1016           1 :           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
    1017          10 :         StringRef SetterName = Property->getSetterName();
    1018          10 :         if (!SetterName.empty())
    1019           1 :           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
    1020          10 :         if (unsigned PropertyAttributes = Property->getAttributes())
    1021          20 :           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, None,
    1022             :                   PropertyAttributes);
    1023             :       } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
    1024           4 :         if (Composite->getTag() == dwarf::DW_TAG_variant_part) {
    1025           2 :           DIE &VariantPart = createAndAddDIE(Composite->getTag(), Buffer);
    1026           2 :           constructTypeDIE(VariantPart, Composite);
    1027             :         }
    1028             :       }
    1029             :     }
    1030             : 
    1031       35437 :     if (CTy->isAppleBlockExtension())
    1032           8 :       addFlag(Buffer, dwarf::DW_AT_APPLE_block);
    1033             : 
    1034             :     // This is outside the DWARF spec, but GDB expects a DW_AT_containing_type
    1035             :     // inside C++ composite types to point to the base class with the vtable.
    1036             :     // Rust uses DW_AT_containing_type to link a vtable to the type
    1037             :     // for which it was created.
    1038             :     if (auto *ContainingType = resolve(CTy->getVTableHolder()))
    1039         840 :       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
    1040         840 :                   *getOrCreateTypeDIE(ContainingType));
    1041             : 
    1042       35437 :     if (CTy->isObjcClassComplete())
    1043          19 :       addFlag(Buffer, dwarf::DW_AT_APPLE_objc_complete_type);
    1044             : 
    1045             :     // Add template parameters to a class, structure or union types.
    1046             :     // FIXME: The support isn't in the metadata for this yet.
    1047       70874 :     if (Tag == dwarf::DW_TAG_class_type ||
    1048       36463 :         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
    1049       35435 :       addTemplateParams(Buffer, CTy->getTemplateParams());
    1050             : 
    1051             :     // Add the type's non-standard calling convention.
    1052             :     uint8_t CC = 0;
    1053       35437 :     if (CTy->isTypePassByValue())
    1054             :       CC = dwarf::DW_CC_pass_by_value;
    1055       14154 :     else if (CTy->isTypePassByReference())
    1056             :       CC = dwarf::DW_CC_pass_by_reference;
    1057             :     if (CC)
    1058       60522 :       addUInt(Buffer, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1,
    1059             :               CC);
    1060             :     break;
    1061             :   }
    1062             :   default:
    1063             :     break;
    1064             :   }
    1065             : 
    1066             :   // Add name if not anonymous or intermediate type.
    1067       39902 :   if (!Name.empty())
    1068       32760 :     addString(Buffer, dwarf::DW_AT_name, Name);
    1069             : 
    1070       79804 :   if (Tag == dwarf::DW_TAG_enumeration_type ||
    1071       92720 :       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
    1072       26409 :       Tag == dwarf::DW_TAG_union_type) {
    1073             :     // Add size if non-zero (derived types might be zero-sized.)
    1074             :     // TODO: Do we care about size for enum forward declarations?
    1075       36790 :     if (Size)
    1076       32398 :       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
    1077        4392 :     else if (!CTy->isForwardDecl())
    1078             :       // Add zero size if it is not a forward declaration.
    1079          39 :       addUInt(Buffer, dwarf::DW_AT_byte_size, None, 0);
    1080             : 
    1081             :     // If we're a forward decl, say so.
    1082       36790 :     if (CTy->isForwardDecl())
    1083        4354 :       addFlag(Buffer, dwarf::DW_AT_declaration);
    1084             : 
    1085             :     // Add source line info if available.
    1086       36790 :     if (!CTy->isForwardDecl())
    1087       32436 :       addSourceLine(Buffer, CTy);
    1088             : 
    1089             :     // No harm in adding the runtime language to the declaration.
    1090       36790 :     unsigned RLang = CTy->getRuntimeLang();
    1091       36790 :     if (RLang)
    1092         104 :       addUInt(Buffer, dwarf::DW_AT_APPLE_runtime_class, dwarf::DW_FORM_data1,
    1093             :               RLang);
    1094             : 
    1095             :     // Add align info if available.
    1096       36790 :     if (uint32_t AlignInBytes = CTy->getAlignInBytes())
    1097         540 :       addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
    1098             :               AlignInBytes);
    1099             :   }
    1100       39902 : }
    1101             : 
    1102       51473 : void DwarfUnit::constructTemplateTypeParameterDIE(
    1103             :     DIE &Buffer, const DITemplateTypeParameter *TP) {
    1104             :   DIE &ParamDIE =
    1105       51473 :       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
    1106             :   // Add the type if it exists, it could be void and therefore no type.
    1107       51473 :   if (TP->getType())
    1108       48834 :     addType(ParamDIE, resolve(TP->getType()));
    1109       51473 :   if (!TP->getName().empty())
    1110       40815 :     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
    1111       51473 : }
    1112             : 
    1113       20475 : void DwarfUnit::constructTemplateValueParameterDIE(
    1114             :     DIE &Buffer, const DITemplateValueParameter *VP) {
    1115       40950 :   DIE &ParamDIE = createAndAddDIE(VP->getTag(), Buffer);
    1116             : 
    1117             :   // Add the type if there is one, template template and template parameter
    1118             :   // packs will not have a type.
    1119       20475 :   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
    1120       13767 :     addType(ParamDIE, resolve(VP->getType()));
    1121       20475 :   if (!VP->getName().empty())
    1122       15900 :     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
    1123       20475 :   if (Metadata *Val = VP->getValue()) {
    1124             :     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
    1125       13737 :       addConstantValue(ParamDIE, CI, resolve(VP->getType()));
    1126             :     else if (GlobalValue *GV = mdconst::dyn_extract<GlobalValue>(Val)) {
    1127             :       // We cannot describe the location of dllimport'd entities: the
    1128             :       // computation of their address requires loads from the IAT.
    1129          26 :       if (!GV->hasDLLImportStorageClass()) {
    1130             :         // For declaration non-type template parameters (such as global values
    1131             :         // and functions)
    1132          26 :         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
    1133          26 :         addOpAddress(*Loc, Asm->getSymbol(GV));
    1134             :         // Emit DW_OP_stack_value to use the address as the immediate value of
    1135             :         // the parameter, rather than a pointer to it.
    1136          26 :         addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_stack_value);
    1137          26 :         addBlock(ParamDIE, dwarf::DW_AT_location, Loc);
    1138             :       }
    1139       13416 :     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
    1140             :       assert(isa<MDString>(Val));
    1141         137 :       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
    1142             :                 cast<MDString>(Val)->getString());
    1143        6571 :     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
    1144        6571 :       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
    1145             :     }
    1146             :   }
    1147       20475 : }
    1148             : 
    1149      605701 : DIE *DwarfUnit::getOrCreateNameSpace(const DINamespace *NS) {
    1150             :   // Construct the context before querying for the existence of the DIE in case
    1151             :   // such construction creates the DIE.
    1152      605701 :   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
    1153             : 
    1154      605701 :   if (DIE *NDie = getDIE(NS))
    1155             :     return NDie;
    1156        3243 :   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
    1157             : 
    1158        3243 :   StringRef Name = NS->getName();
    1159        3243 :   if (!Name.empty())
    1160        3202 :     addString(NDie, dwarf::DW_AT_name, NS->getName());
    1161             :   else
    1162          41 :     Name = "(anonymous namespace)";
    1163        3243 :   DD->addAccelNamespace(Name, NDie);
    1164        6486 :   addGlobalName(Name, NDie, NS->getScope());
    1165        3243 :   if (NS->getExportSymbols())
    1166         128 :     addFlag(NDie, dwarf::DW_AT_export_symbols);
    1167             :   return &NDie;
    1168             : }
    1169             : 
    1170         249 : DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
    1171             :   // Construct the context before querying for the existence of the DIE in case
    1172             :   // such construction creates the DIE.
    1173         249 :   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
    1174             : 
    1175         249 :   if (DIE *MDie = getDIE(M))
    1176             :     return MDie;
    1177          28 :   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
    1178             : 
    1179          28 :   if (!M->getName().empty()) {
    1180          28 :     addString(MDie, dwarf::DW_AT_name, M->getName());
    1181          56 :     addGlobalName(M->getName(), MDie, M->getScope());
    1182             :   }
    1183          28 :   if (!M->getConfigurationMacros().empty())
    1184           8 :     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
    1185             :               M->getConfigurationMacros());
    1186          28 :   if (!M->getIncludePath().empty())
    1187          22 :     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
    1188          28 :   if (!M->getISysRoot().empty())
    1189          28 :     addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
    1190             :   
    1191             :   return &MDie;
    1192             : }
    1193             : 
    1194      307642 : DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
    1195             :   // Construct the context before querying for the existence of the DIE in case
    1196             :   // such construction creates the DIE (as is the case for member function
    1197             :   // declarations).
    1198             :   DIE *ContextDIE =
    1199      610752 :       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
    1200             : 
    1201      307642 :   if (DIE *SPDie = getDIE(SP))
    1202             :     return SPDie;
    1203             : 
    1204             :   if (auto *SPDecl = SP->getDeclaration()) {
    1205       18855 :     if (!Minimal) {
    1206             :       // Add subprogram definitions to the CU die directly.
    1207             :       ContextDIE = &getUnitDie();
    1208             :       // Build the decl now to ensure it precedes the definition.
    1209       18839 :       getOrCreateSubprogramDIE(SPDecl);
    1210             :     }
    1211             :   }
    1212             : 
    1213             :   // DW_TAG_inlined_subroutine may refer to this DIE.
    1214      280032 :   DIE &SPDie = createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, SP);
    1215             : 
    1216             :   // Stop here and fill this in later, depending on whether or not this
    1217             :   // subprogram turns out to have inlined instances or not.
    1218      280032 :   if (SP->isDefinition())
    1219             :     return &SPDie;
    1220             : 
    1221      244998 :   applySubprogramAttributes(SP, SPDie);
    1222      244998 :   return &SPDie;
    1223             : }
    1224             : 
    1225      278389 : bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
    1226             :                                                     DIE &SPDie) {
    1227             :   DIE *DeclDie = nullptr;
    1228             :   StringRef DeclLinkageName;
    1229             :   if (auto *SPDecl = SP->getDeclaration()) {
    1230       21104 :     DeclDie = getDIE(SPDecl);
    1231             :     assert(DeclDie && "This DIE should've already been constructed when the "
    1232             :                       "definition DIE was created in "
    1233             :                       "getOrCreateSubprogramDIE");
    1234             :     // Look at the Decl's linkage name only if we emitted it.
    1235       21104 :     if (DD->useAllLinkageNames())
    1236             :       DeclLinkageName = SPDecl->getLinkageName();
    1237       42208 :     unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
    1238       42208 :     unsigned DefID = getOrCreateSourceID(SP->getFile());
    1239       21104 :     if (DeclID != DefID)
    1240        2814 :       addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
    1241             : 
    1242       21104 :     if (SP->getLine() != SPDecl->getLine())
    1243        3562 :       addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
    1244             :   }
    1245             : 
    1246             :   // Add function template parameters.
    1247      278389 :   addTemplateParams(SPDie, SP->getTemplateParams());
    1248             : 
    1249             :   // Add the linkage name if we have one and it isn't in the Decl.
    1250      278389 :   StringRef LinkageName = SP->getLinkageName();
    1251             :   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
    1252             :           LinkageName == DeclLinkageName) &&
    1253             :          "decl has a linkage name and it is different");
    1254      543696 :   if (DeclLinkageName.empty() &&
    1255             :       // Always emit it for abstract subprograms.
    1256      265345 :       (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
    1257      265279 :     addLinkageName(SPDie, LinkageName);
    1258             : 
    1259      278389 :   if (!DeclDie)
    1260             :     return false;
    1261             : 
    1262             :   // Refer to the function declaration where all the other attributes will be
    1263             :   // found.
    1264       21104 :   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
    1265       21104 :   return true;
    1266             : }
    1267             : 
    1268      296850 : void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
    1269             :                                           bool SkipSPAttributes) {
    1270             :   // If -fdebug-info-for-profiling is enabled, need to emit the subprogram
    1271             :   // and its source location.
    1272      315312 :   bool SkipSPSourceLocation = SkipSPAttributes &&
    1273       18462 :                               !CUNode->getDebugInfoForProfiling();
    1274             :   if (!SkipSPSourceLocation)
    1275      278389 :     if (applySubprogramDefinitionAttributes(SP, SPDie))
    1276             :       return;
    1277             : 
    1278             :   // Constructors and operators for anonymous aggregates do not have names.
    1279      275746 :   if (!SP->getName().empty())
    1280      275494 :     addString(SPDie, dwarf::DW_AT_name, SP->getName());
    1281             : 
    1282      275746 :   if (!SkipSPSourceLocation)
    1283      257285 :     addSourceLine(SPDie, SP);
    1284             : 
    1285             :   // Skip the rest of the attributes under -gmlt to save space.
    1286      275746 :   if (SkipSPAttributes)
    1287             :     return;
    1288             : 
    1289             :   // Add the prototype if we have a prototype and we have a C like
    1290             :   // language.
    1291      257284 :   uint16_t Language = getLanguage();
    1292      514013 :   if (SP->isPrototyped() &&
    1293      512304 :       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
    1294             :        Language == dwarf::DW_LANG_ObjC))
    1295        1195 :     addFlag(SPDie, dwarf::DW_AT_prototyped);
    1296             : 
    1297             :   unsigned CC = 0;
    1298             :   DITypeRefArray Args;
    1299             :   if (const DISubroutineType *SPTy = SP->getType()) {
    1300             :     Args = SPTy->getTypeArray();
    1301      257284 :     CC = SPTy->getCC();
    1302             :   }
    1303             : 
    1304             :   // Add a DW_AT_calling_convention if this has an explicit convention.
    1305      257284 :   if (CC && CC != dwarf::DW_CC_normal)
    1306           4 :     addUInt(SPDie, dwarf::DW_AT_calling_convention, dwarf::DW_FORM_data1, CC);
    1307             : 
    1308             :   // Add a return type. If this is a type like a C/C++ void type we don't add a
    1309             :   // return type.
    1310      257284 :   if (Args.size())
    1311             :     if (auto Ty = resolve(Args[0]))
    1312      175974 :       addType(SPDie, Ty);
    1313             : 
    1314             :   unsigned VK = SP->getVirtuality();
    1315      257284 :   if (VK) {
    1316        5840 :     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
    1317        2920 :     if (SP->getVirtualIndex() != -1u) {
    1318             :       DIELoc *Block = getDIELoc();
    1319        2919 :       addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
    1320        2919 :       addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
    1321        2919 :       addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
    1322             :     }
    1323        2920 :     ContainingTypeMap.insert(
    1324        5840 :         std::make_pair(&SPDie, resolve(SP->getContainingType())));
    1325             :   }
    1326             : 
    1327      257284 :   if (!SP->isDefinition()) {
    1328      244998 :     addFlag(SPDie, dwarf::DW_AT_declaration);
    1329             : 
    1330             :     // Add arguments. Do not add arguments for subprogram definition. They will
    1331             :     // be handled while processing variables.
    1332      244998 :     constructSubprogramArguments(SPDie, Args);
    1333             :   }
    1334             : 
    1335      257284 :   addThrownTypes(SPDie, SP->getThrownTypes());
    1336             : 
    1337      257284 :   if (SP->isArtificial())
    1338         957 :     addFlag(SPDie, dwarf::DW_AT_artificial);
    1339             : 
    1340      257284 :   if (!SP->isLocalToUnit())
    1341      255867 :     addFlag(SPDie, dwarf::DW_AT_external);
    1342             : 
    1343      257284 :   if (DD->useAppleExtensionAttributes()) {
    1344         337 :     if (SP->isOptimized())
    1345         147 :       addFlag(SPDie, dwarf::DW_AT_APPLE_optimized);
    1346             : 
    1347         337 :     if (unsigned isa = Asm->getISAEncoding())
    1348         100 :       addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
    1349             :   }
    1350             : 
    1351      257284 :   if (SP->isLValueReference())
    1352           1 :     addFlag(SPDie, dwarf::DW_AT_reference);
    1353             : 
    1354      257284 :   if (SP->isRValueReference())
    1355           1 :     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
    1356             : 
    1357      257284 :   if (SP->isNoReturn())
    1358        1948 :     addFlag(SPDie, dwarf::DW_AT_noreturn);
    1359             : 
    1360      257284 :   if (SP->isProtected())
    1361       10156 :     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1362             :             dwarf::DW_ACCESS_protected);
    1363      247128 :   else if (SP->isPrivate())
    1364         369 :     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1365             :             dwarf::DW_ACCESS_private);
    1366      246759 :   else if (SP->isPublic())
    1367      107698 :     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1368             :             dwarf::DW_ACCESS_public);
    1369             : 
    1370      257284 :   if (SP->isExplicit())
    1371        6171 :     addFlag(SPDie, dwarf::DW_AT_explicit);
    1372             : 
    1373      257284 :   if (SP->isMainSubprogram())
    1374           5 :     addFlag(SPDie, dwarf::DW_AT_main_subprogram);
    1375             : }
    1376             : 
    1377        3169 : void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
    1378             :                                      DIE *IndexTy) {
    1379        3169 :   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
    1380        3169 :   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, *IndexTy);
    1381             : 
    1382             :   // The LowerBound value defines the lower bounds which is typically zero for
    1383             :   // C/C++. The Count value is the number of elements.  Values are 64 bit. If
    1384             :   // Count == -1 then the array is unbounded and we do not emit
    1385             :   // DW_AT_lower_bound and DW_AT_count attributes.
    1386        3169 :   int64_t LowerBound = SR->getLowerBound();
    1387        3169 :   int64_t DefaultLowerBound = getDefaultLowerBound();
    1388             :   int64_t Count = -1;
    1389        6338 :   if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
    1390             :     Count = CI->getSExtValue();
    1391             : 
    1392        3169 :   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
    1393          18 :     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
    1394             : 
    1395        6338 :   if (auto *CV = SR->getCount().dyn_cast<DIVariable*>()) {
    1396          14 :     if (auto *CountVarDIE = getDIE(CV))
    1397          12 :       addDIEEntry(DW_Subrange, dwarf::DW_AT_count, *CountVarDIE);
    1398        3155 :   } else if (Count != -1)
    1399        5966 :     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
    1400        3169 : }
    1401             : 
    1402        3110 : DIE *DwarfUnit::getIndexTyDie() {
    1403        3110 :   if (IndexTyDie)
    1404             :     return IndexTyDie;
    1405             :   // Construct an integer type to use for indexes.
    1406         704 :   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
    1407             :   StringRef Name = "__ARRAY_SIZE_TYPE__";
    1408         704 :   addString(*IndexTyDie, dwarf::DW_AT_name, Name);
    1409         704 :   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
    1410         704 :   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
    1411             :           dwarf::DW_ATE_unsigned);
    1412         704 :   DD->addAccelType(Name, *IndexTyDie, /*Flags*/ 0);
    1413         704 :   return IndexTyDie;
    1414             : }
    1415             : 
    1416             : /// Returns true if the vector's size differs from the sum of sizes of elements
    1417             : /// the user specified.  This can occur if the vector has been rounded up to
    1418             : /// fit memory alignment constraints.
    1419          25 : static bool hasVectorBeenPadded(const DICompositeType *CTy) {
    1420             :   assert(CTy && CTy->isVector() && "Composite type is not a vector");
    1421          25 :   const uint64_t ActualSize = CTy->getSizeInBits();
    1422             : 
    1423             :   // Obtain the size of each element in the vector.
    1424             :   DIType *BaseTy = CTy->getBaseType().resolve();
    1425             :   assert(BaseTy && "Unknown vector element type.");
    1426          25 :   const uint64_t ElementSize = BaseTy->getSizeInBits();
    1427             : 
    1428             :   // Locate the number of elements in the vector.
    1429             :   const DINodeArray Elements = CTy->getElements();
    1430             :   assert(Elements.size() == 1 &&
    1431             :          Elements[0]->getTag() == dwarf::DW_TAG_subrange_type &&
    1432             :          "Invalid vector element array, expected one element of type subrange");
    1433             :   const auto Subrange = cast<DISubrange>(Elements[0]);
    1434          50 :   const auto CI = Subrange->getCount().get<ConstantInt *>();
    1435          25 :   const int32_t NumVecElements = CI->getSExtValue();
    1436             : 
    1437             :   // Ensure we found the element count and that the actual size is wide
    1438             :   // enough to contain the requested size.
    1439             :   assert(ActualSize >= (NumVecElements * ElementSize) && "Invalid vector size");
    1440          25 :   return ActualSize != (NumVecElements * ElementSize);
    1441             : }
    1442             : 
    1443        3110 : void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
    1444        3110 :   if (CTy->isVector()) {
    1445          25 :     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
    1446          25 :     if (hasVectorBeenPadded(CTy))
    1447           2 :       addUInt(Buffer, dwarf::DW_AT_byte_size, None,
    1448           1 :               CTy->getSizeInBits() / CHAR_BIT);
    1449             :   }
    1450             : 
    1451             :   // Emit the element type.
    1452        3110 :   addType(Buffer, resolve(CTy->getBaseType()));
    1453             : 
    1454             :   // Get an anonymous type for index type.
    1455             :   // FIXME: This type should be passed down from the front end
    1456             :   // as different languages may have different sizes for indexes.
    1457        3110 :   DIE *IdxTy = getIndexTyDie();
    1458             : 
    1459             :   // Add subranges to array type.
    1460             :   DINodeArray Elements = CTy->getElements();
    1461        9448 :   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
    1462             :     // FIXME: Should this really be such a loose cast?
    1463             :     if (auto *Element = dyn_cast_or_null<DINode>(Elements[i]))
    1464        3169 :       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
    1465        3169 :         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
    1466             :   }
    1467        3110 : }
    1468             : 
    1469        1355 : void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
    1470             :   const DIType *DTy = resolve(CTy->getBaseType());
    1471        1313 :   bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
    1472        1355 :   if (DTy) {
    1473        1313 :     if (DD->getDwarfVersion() >= 3)
    1474        1304 :       addType(Buffer, DTy);
    1475        2617 :     if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum))
    1476         113 :       addFlag(Buffer, dwarf::DW_AT_enum_class);
    1477             :   }
    1478             : 
    1479             :   DINodeArray Elements = CTy->getElements();
    1480             : 
    1481             :   // Add enumerators to enumeration type.
    1482       25285 :   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
    1483             :     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
    1484             :     if (Enum) {
    1485       11965 :       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
    1486       11965 :       StringRef Name = Enum->getName();
    1487       11965 :       addString(Enumerator, dwarf::DW_AT_name, Name);
    1488       11965 :       auto Value = static_cast<uint64_t>(Enum->getValue());
    1489       11965 :       addConstantValue(Enumerator, IsUnsigned, Value);
    1490             :     }
    1491             :   }
    1492        1355 : }
    1493             : 
    1494        2575 : void DwarfUnit::constructContainingTypeDIEs() {
    1495        2575 :   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
    1496        5495 :        CI != CE; ++CI) {
    1497        2920 :     DIE &SPDie = *CI->first;
    1498        2920 :     const DINode *D = CI->second;
    1499        2920 :     if (!D)
    1500           0 :       continue;
    1501        2920 :     DIE *NDie = getDIE(D);
    1502        2920 :     if (!NDie)
    1503           0 :       continue;
    1504        2920 :     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
    1505             :   }
    1506        2575 : }
    1507             : 
    1508       57273 : DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
    1509      114546 :   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
    1510       57273 :   StringRef Name = DT->getName();
    1511       57273 :   if (!Name.empty())
    1512       50084 :     addString(MemberDie, dwarf::DW_AT_name, Name);
    1513             : 
    1514             :   if (DIType *Resolved = resolve(DT->getBaseType()))
    1515       57272 :     addType(MemberDie, Resolved);
    1516             : 
    1517       57273 :   addSourceLine(MemberDie, DT);
    1518             : 
    1519       64216 :   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
    1520             : 
    1521             :     // For C++, virtual base classes are not at fixed offset. Use following
    1522             :     // expression to extract appropriate offset from vtable.
    1523             :     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
    1524             : 
    1525          28 :     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
    1526          28 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
    1527          28 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
    1528          28 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
    1529          28 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
    1530          28 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
    1531          28 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
    1532          28 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
    1533             : 
    1534          28 :     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
    1535             :   } else {
    1536       57245 :     uint64_t Size = DT->getSizeInBits();
    1537       57245 :     uint64_t FieldSize = DD->getBaseTypeSize(DT);
    1538             :     uint32_t AlignInBytes = DT->getAlignInBytes();
    1539             :     uint64_t OffsetInBytes;
    1540             : 
    1541       57245 :     bool IsBitfield = FieldSize && Size != FieldSize;
    1542       57245 :     if (IsBitfield) {
    1543             :       // Handle bitfield, assume bytes are 8 bits.
    1544          85 :       if (DD->useDWARF2Bitfields())
    1545         144 :         addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
    1546          85 :       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
    1547             : 
    1548          85 :       uint64_t Offset = DT->getOffsetInBits();
    1549             :       // We can't use DT->getAlignInBits() here: AlignInBits for member type
    1550             :       // is non-zero if and only if alignment was forced (e.g. _Alignas()),
    1551             :       // which can't be done with bitfields. Thus we use FieldSize here.
    1552          85 :       uint32_t AlignInBits = FieldSize;
    1553          85 :       uint32_t AlignMask = ~(AlignInBits - 1);
    1554             :       // The bits from the start of the storage unit to the start of the field.
    1555          85 :       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
    1556             :       // The byte offset of the field's aligned storage unit inside the struct.
    1557          85 :       OffsetInBytes = (Offset - StartBitOffset) / 8;
    1558             : 
    1559          85 :       if (DD->useDWARF2Bitfields()) {
    1560          72 :         uint64_t HiMark = (Offset + FieldSize) & AlignMask;
    1561          72 :         uint64_t FieldOffset = (HiMark - FieldSize);
    1562          72 :         Offset -= FieldOffset;
    1563             : 
    1564             :         // Maybe we need to work from the other end.
    1565          72 :         if (Asm->getDataLayout().isLittleEndian())
    1566          69 :           Offset = FieldSize - (Offset + Size);
    1567             : 
    1568          72 :         addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
    1569          72 :         OffsetInBytes = FieldOffset >> 3;
    1570             :       } else {
    1571          13 :         addUInt(MemberDie, dwarf::DW_AT_data_bit_offset, None, Offset);
    1572             :       }
    1573             :     } else {
    1574             :       // This is not a bitfield.
    1575       57160 :       OffsetInBytes = DT->getOffsetInBits() / 8;
    1576       57160 :       if (AlignInBytes)
    1577         712 :         addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
    1578             :                 AlignInBytes);
    1579             :     }
    1580             : 
    1581       57245 :     if (DD->getDwarfVersion() <= 2) {
    1582         114 :       DIELoc *MemLocationDie = new (DIEValueAllocator) DIELoc;
    1583         114 :       addUInt(*MemLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
    1584         114 :       addUInt(*MemLocationDie, dwarf::DW_FORM_udata, OffsetInBytes);
    1585         114 :       addBlock(MemberDie, dwarf::DW_AT_data_member_location, MemLocationDie);
    1586       57131 :     } else if (!IsBitfield || DD->useDWARF2Bitfields())
    1587       57118 :       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
    1588             :               OffsetInBytes);
    1589             :   }
    1590             : 
    1591       57273 :   if (DT->isProtected())
    1592        2491 :     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1593             :             dwarf::DW_ACCESS_protected);
    1594       54782 :   else if (DT->isPrivate())
    1595        1762 :     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1596             :             dwarf::DW_ACCESS_private);
    1597             :   // Otherwise C++ member and base classes are considered public.
    1598       53020 :   else if (DT->isPublic())
    1599        2479 :     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1600             :             dwarf::DW_ACCESS_public);
    1601       57273 :   if (DT->isVirtual())
    1602          28 :     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
    1603             :             dwarf::DW_VIRTUALITY_virtual);
    1604             : 
    1605             :   // Objective-C properties.
    1606             :   if (DINode *PNode = DT->getObjCProperty())
    1607           5 :     if (DIE *PDie = getDIE(PNode))
    1608             :       MemberDie.addValue(DIEValueAllocator, dwarf::DW_AT_APPLE_property,
    1609           0 :                          dwarf::DW_FORM_ref4, DIEEntry(*PDie));
    1610             : 
    1611       57273 :   if (DT->isArtificial())
    1612         617 :     addFlag(MemberDie, dwarf::DW_AT_artificial);
    1613             : 
    1614       57273 :   return MemberDie;
    1615             : }
    1616             : 
    1617        4557 : DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
    1618        4557 :   if (!DT)
    1619             :     return nullptr;
    1620             : 
    1621             :   // Construct the context before querying for the existence of the DIE in case
    1622             :   // such construction creates the DIE.
    1623        4557 :   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
    1624             :   assert(dwarf::isType(ContextDIE->getTag()) &&
    1625             :          "Static member should belong to a type.");
    1626             : 
    1627        4557 :   if (DIE *StaticMemberDIE = getDIE(DT))
    1628             :     return StaticMemberDIE;
    1629             : 
    1630        9008 :   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
    1631             : 
    1632             :   const DIType *Ty = resolve(DT->getBaseType());
    1633             : 
    1634        4504 :   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
    1635        4504 :   addType(StaticMemberDIE, Ty);
    1636        4504 :   addSourceLine(StaticMemberDIE, DT);
    1637        4504 :   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
    1638        4504 :   addFlag(StaticMemberDIE, dwarf::DW_AT_declaration);
    1639             : 
    1640             :   // FIXME: We could omit private if the parent is a class_type, and
    1641             :   // public if the parent is something else.
    1642        4504 :   if (DT->isProtected())
    1643          24 :     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1644             :             dwarf::DW_ACCESS_protected);
    1645        4480 :   else if (DT->isPrivate())
    1646          74 :     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1647             :             dwarf::DW_ACCESS_private);
    1648        4406 :   else if (DT->isPublic())
    1649        2350 :     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1650             :             dwarf::DW_ACCESS_public);
    1651             : 
    1652        4502 :   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
    1653        3582 :     addConstantValue(StaticMemberDIE, CI, Ty);
    1654             :   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
    1655           2 :     addConstantFPValue(StaticMemberDIE, CFP);
    1656             : 
    1657        4504 :   if (uint32_t AlignInBytes = DT->getAlignInBytes())
    1658           2 :     addUInt(StaticMemberDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
    1659             :             AlignInBytes);
    1660             : 
    1661             :   return &StaticMemberDIE;
    1662             : }
    1663             : 
    1664        3183 : void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
    1665             :   // Emit size of content not including length itself
    1666        9549 :   Asm->OutStreamer->AddComment("Length of Unit");
    1667        3183 :   Asm->emitInt32(getHeaderSize() + getUnitDie().getSize());
    1668             : 
    1669        9549 :   Asm->OutStreamer->AddComment("DWARF version number");
    1670        3183 :   unsigned Version = DD->getDwarfVersion();
    1671        3183 :   Asm->emitInt16(Version);
    1672             : 
    1673             :   // DWARF v5 reorders the address size and adds a unit type.
    1674        3183 :   if (Version >= 5) {
    1675         105 :     Asm->OutStreamer->AddComment("DWARF Unit Type");
    1676          35 :     Asm->emitInt8(UT);
    1677         105 :     Asm->OutStreamer->AddComment("Address Size (in bytes)");
    1678          35 :     Asm->emitInt8(Asm->MAI->getCodePointerSize());
    1679             :   }
    1680             : 
    1681             :   // We share one abbreviations table across all units so it's always at the
    1682             :   // start of the section. Use a relocatable offset where needed to ensure
    1683             :   // linking doesn't invalidate that offset.
    1684        9549 :   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
    1685        3183 :   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
    1686        3183 :   if (UseOffsets)
    1687         580 :     Asm->emitInt32(0);
    1688             :   else
    1689        5206 :     Asm->emitDwarfSymbolReference(
    1690        2603 :         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
    1691             : 
    1692        3183 :   if (Version <= 4) {
    1693        9444 :     Asm->OutStreamer->AddComment("Address Size (in bytes)");
    1694        3148 :     Asm->emitInt8(Asm->MAI->getCodePointerSize());
    1695             :   }
    1696        3183 : }
    1697             : 
    1698          33 : void DwarfTypeUnit::emitHeader(bool UseOffsets) {
    1699          66 :   DwarfUnit::emitCommonHeader(UseOffsets, 
    1700          33 :                               DD->useSplitDwarf() ? dwarf::DW_UT_split_type
    1701             :                                                   : dwarf::DW_UT_type);
    1702          99 :   Asm->OutStreamer->AddComment("Type Signature");
    1703          66 :   Asm->OutStreamer->EmitIntValue(TypeSignature, sizeof(TypeSignature));
    1704          99 :   Asm->OutStreamer->AddComment("Type DIE Offset");
    1705             :   // In a skeleton type unit there is no type DIE so emit a zero offset.
    1706          66 :   Asm->OutStreamer->EmitIntValue(Ty ? Ty->getOffset() : 0,
    1707          33 :                                  sizeof(Ty->getOffset()));
    1708          33 : }
    1709             : 
    1710             : DIE::value_iterator
    1711         353 : DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
    1712             :                            const MCSymbol *Hi, const MCSymbol *Lo) {
    1713             :   return Die.addValue(DIEValueAllocator, Attribute,
    1714         353 :                       DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
    1715             :                                                  : dwarf::DW_FORM_data4,
    1716        1059 :                       new (DIEValueAllocator) DIEDelta(Hi, Lo));
    1717             : }
    1718             : 
    1719             : DIE::value_iterator
    1720       58387 : DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
    1721             :                            const MCSymbol *Label, const MCSymbol *Sec) {
    1722       58387 :   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
    1723             :     return addLabel(Die, Attribute,
    1724       58164 :                     DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
    1725             :                                                : dwarf::DW_FORM_data4,
    1726       58164 :                     Label);
    1727         223 :   return addSectionDelta(Die, Attribute, Label, Sec);
    1728             : }
    1729             : 
    1730         336 : bool DwarfTypeUnit::isDwoUnit() const {
    1731             :   // Since there are no skeleton type units, all type units are dwo type units
    1732             :   // when split DWARF is being used.
    1733         336 :   return DD->useSplitDwarf();
    1734             : }
    1735             : 
    1736           8 : void DwarfTypeUnit::addGlobalName(StringRef Name, const DIE &Die,
    1737             :                                   const DIScope *Context) {
    1738           8 :   getCU().addGlobalNameForTypeUnit(Name, Context);
    1739           8 : }
    1740             : 
    1741          76 : void DwarfTypeUnit::addGlobalType(const DIType *Ty, const DIE &Die,
    1742             :                                   const DIScope *Context) {
    1743          76 :   getCU().addGlobalTypeUnitType(Ty, Context);
    1744          76 : }
    1745             : 
    1746         318 : const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
    1747         318 :   if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
    1748             :     return nullptr;
    1749         308 :   if (isDwoUnit())
    1750             :     return nullptr;
    1751         305 :   return getSection()->getBeginSymbol();
    1752             : }
    1753             : 
    1754          27 : void DwarfUnit::addStringOffsetsStart() {
    1755          27 :   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
    1756          27 :   addSectionLabel(getUnitDie(), dwarf::DW_AT_str_offsets_base,
    1757          27 :                   DU->getStringOffsetsStartSym(),
    1758          27 :                   TLOF.getDwarfStrOffSection()->getBeginSymbol());
    1759      299256 : }

Generated by: LCOV version 1.13