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-06-17 00:07:59 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      101169 : GenerateDwarfTypeUnits("generate-type-units", cl::Hidden,
      52      101169 :                        cl::desc("Generate DWARF4 type units."),
      53      303507 :                        cl::init(false));
      54             : 
      55      110750 : DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
      56      110750 :                                        DIELoc &DIE)
      57      110750 :     : DwarfExpression(AP.getDwarfVersion()), AP(AP), DU(DU),
      58      221500 :       DIE(DIE) {}
      59             : 
      60      107752 : void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
      61      107752 :   DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
      62      107752 : }
      63             : 
      64       68478 : void DIEDwarfExpression::emitSigned(int64_t Value) {
      65      136956 :   DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
      66       68478 : }
      67             : 
      68          87 : void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
      69          87 :   DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
      70          87 : }
      71             : 
      72       68499 : bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
      73             :                                          unsigned MachineReg) {
      74       68499 :   return MachineReg == TRI.getFrameRegister(*AP.MF);
      75             : }
      76             : 
      77        3912 : DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
      78        3912 :                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
      79        7824 :     : DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
      80       19560 :       CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
      81        3912 : }
      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        7824 : 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        3912 : }
      96             : 
      97        3539 : int64_t DwarfUnit::getDefaultLowerBound() const {
      98        7078 :   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         350 :   case dwarf::DW_LANG_C99:
     114             :   case dwarf::DW_LANG_ObjC:
     115             :   case dwarf::DW_LANG_ObjC_plus_plus:
     116         350 :     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     3541162 : 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     3541162 :   if (isDwoUnit() && !DD->shareAcrossDWOCUs())
     185             :     return false;
     186     1411479 :   return (isa<DIType>(D) ||
     187     2687416 :           (isa<DISubprogram>(D) && !cast<DISubprogram>(D)->isDefinition())) &&
     188             :          !GenerateDwarfTypeUnits;
     189             : }
     190             : 
     191     2739710 : DIE *DwarfUnit::getDIE(const DINode *D) const {
     192     2739710 :   if (isShareableAcrossCUs(D))
     193     3187900 :     return DU->getDIE(D);
     194     2291520 :   return MDNodeToDieMap.lookup(D);
     195             : }
     196             : 
     197      801452 : void DwarfUnit::insertDIE(const DINode *Desc, DIE *D) {
     198      801452 :   if (isShareableAcrossCUs(Desc)) {
     199      459213 :     DU->insertDIE(Desc, D);
     200             :     return;
     201             :   }
     202      684478 :   MDNodeToDieMap.insert(std::make_pair(Desc, D));
     203             : }
     204             : 
     205      814836 : void DwarfUnit::addFlag(DIE &Die, dwarf::Attribute Attribute) {
     206      814836 :   if (DD->getDwarfVersion() >= 4)
     207             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag_present,
     208      813861 :                  DIEInteger(1));
     209             :   else
     210             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_flag,
     211         975 :                  DIEInteger(1));
     212      814836 : }
     213             : 
     214     1919638 : void DwarfUnit::addUInt(DIEValueList &Die, dwarf::Attribute Attribute,
     215             :                         Optional<dwarf::Form> Form, uint64_t Integer) {
     216     1919638 :   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     1919638 :   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
     221     1919638 : }
     222             : 
     223      119344 : void DwarfUnit::addUInt(DIEValueList &Block, dwarf::Form Form,
     224             :                         uint64_t Integer) {
     225      119344 :   addUInt(Block, (dwarf::Attribute)0, Form, Integer);
     226      119344 : }
     227             : 
     228       68478 : void DwarfUnit::addSInt(DIEValueList &Die, dwarf::Attribute Attribute,
     229             :                         Optional<dwarf::Form> Form, int64_t Integer) {
     230       68478 :   if (!Form)
     231             :     Form = DIEInteger::BestForm(true, Integer);
     232       68478 :   Die.addValue(DIEValueAllocator, Attribute, *Form, DIEInteger(Integer));
     233       68478 : }
     234             : 
     235       68478 : void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
     236             :                         int64_t Integer) {
     237       68478 :   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
     238       68478 : }
     239             : 
     240      840080 : void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
     241             :                           StringRef String) {
     242      840080 :   if (DD->useInlineStrings()) {
     243             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string,
     244         452 :                  new (DIEValueAllocator)
     245         904 :                      DIEInlineString(String, DIEValueAllocator));
     246         452 :     return;
     247             :   }
     248     1679256 :   auto StringPoolEntry = DU->getStringPool().getEntry(*Asm, String);
     249             :   dwarf::Form IxForm =
     250      839628 :       isDwoUnit() ? dwarf::DW_FORM_GNU_str_index : dwarf::DW_FORM_strp;
     251             :   // For DWARF v5 and beyond, use the smallest strx? form possible.
     252     1679256 :   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      839628 :                DIEString(StringPoolEntry));
     264             : }
     265             : 
     266       61865 : DIEValueList::value_iterator DwarfUnit::addLabel(DIEValueList &Die,
     267             :                                                  dwarf::Attribute Attribute,
     268             :                                                  dwarf::Form Form,
     269             :                                                  const MCSymbol *Label) {
     270      123730 :   return Die.addValue(DIEValueAllocator, Attribute, Form, DIELabel(Label));
     271             : }
     272             : 
     273        2604 : void DwarfUnit::addLabel(DIELoc &Die, dwarf::Form Form, const MCSymbol *Label) {
     274        2604 :   addLabel(Die, (dwarf::Attribute)0, Form, Label);
     275        2604 : }
     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     1494564 : MD5::MD5Result *DwarfUnit::getMD5AsBytes(const DIFile *File) const {
     286             :   assert(File);
     287     1494564 :   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        3116 : void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
     315        3116 :   if (!DD->useSplitDwarf()) {
     316        2604 :     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
     317        2604 :     addLabel(Die, dwarf::DW_FORM_udata, Sym);
     318             :   } else {
     319         512 :     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);
     320         512 :     addUInt(Die, dwarf::DW_FORM_GNU_addr_index,
     321        1024 :             DD->getAddressPool().getIndex(Sym));
     322             :   }
     323        3116 : }
     324             : 
     325       91141 : 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       91141 :                new (DIEValueAllocator) DIEDelta(Hi, Lo));
     329       91141 : }
     330             : 
     331      276059 : void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute, DIE &Entry) {
     332      276059 :   addDIEEntry(Die, Attribute, DIEEntry(Entry));
     333      276059 : }
     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     1427393 : void DwarfUnit::addDIEEntry(DIE &Die, dwarf::Attribute Attribute,
     347             :                             DIEEntry Entry) {
     348     1427393 :   const DIEUnit *CU = Die.getUnit();
     349     1427393 :   const DIEUnit *EntryCU = Entry.getEntry().getUnit();
     350     1427393 :   if (!CU)
     351             :     // We assume that Die belongs to this CU, if it is not linked to any CU yet.
     352      210976 :     CU = getUnitDie().getUnit();
     353     1427393 :   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     1427393 :                Entry);
     358     1427393 : }
     359             : 
     360     1308412 : DIE &DwarfUnit::createAndAddDIE(unsigned Tag, DIE &Parent, const DINode *N) {
     361     1308412 :   DIE &Die = Parent.addChild(DIE::get(DIEValueAllocator, (dwarf::Tag)Tag));
     362     1308412 :   if (N)
     363      599277 :     insertDIE(N, &Die);
     364     1308412 :   return Die;
     365             : }
     366             : 
     367      114529 : void DwarfUnit::addBlock(DIE &Die, dwarf::Attribute Attribute, DIELoc *Loc) {
     368      114529 :   Loc->ComputeSize(Asm);
     369      114529 :   DIELocs.push_back(Loc); // Memoize so we can call the destructor later on.
     370             :   Die.addValue(DIEValueAllocator, Attribute,
     371      229058 :                Loc->BestForm(DD->getDwarfVersion()), Loc);
     372      114529 : }
     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      792357 : void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
     382      792357 :   if (Line == 0)
     383             :     return;
     384             : 
     385      619037 :   unsigned FileID = getOrCreateSourceID(File);
     386             :   assert(FileID && "Invalid file id");
     387     1238074 :   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
     388     1238074 :   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
     389             : }
     390             : 
     391       76903 : void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
     392             :   assert(V);
     393             : 
     394       76903 :   addSourceLine(Die, V->getLine(), V->getFile());
     395       76903 : }
     396             : 
     397        4471 : void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
     398             :   assert(G);
     399             : 
     400        4471 :   addSourceLine(Die, G->getLine(), G->getFile());
     401        4471 : }
     402             : 
     403      296255 : void DwarfUnit::addSourceLine(DIE &Die, const DISubprogram *SP) {
     404             :   assert(SP);
     405             : 
     406      296255 :   addSourceLine(Die, SP->getLine(), SP->getFile());
     407      296255 : }
     408             : 
     409      309246 : void DwarfUnit::addSourceLine(DIE &Die, const DIType *Ty) {
     410             :   assert(Ty);
     411             : 
     412      309246 :   addSourceLine(Die, Ty->getLine(), Ty->getFile());
     413      309246 : }
     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       23408 : 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        2961 :     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       11659 :     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       23318 :     if (T == dwarf::DW_TAG_pointer_type ||
     574       11659 :         T == dwarf::DW_TAG_ptr_to_member_type ||
     575       23310 :         T == dwarf::DW_TAG_reference_type ||
     576       11655 :         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       11655 :     return isUnsignedDIType(DD, DD->resolve(Deriv));
     584             :   }
     585             : 
     586             :   auto *BTy = cast<DIBasicType>(Ty);
     587       20443 :   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       20443 :   return Encoding == dwarf::DW_ATE_unsigned ||
     598       20443 :          Encoding == dwarf::DW_ATE_unsigned_char ||
     599       43909 :          Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
     600        3023 :          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       21073 : void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
     631             :                                  const DIType *Ty) {
     632       21073 :   addConstantValue(Die, CI->getValue(), Ty);
     633       21073 : }
     634             : 
     635         821 : void DwarfUnit::addConstantValue(DIE &Die, const MachineOperand &MO,
     636             :                                  const DIType *Ty) {
     637             :   assert(MO.isImm() && "Invalid machine operand!");
     638             : 
     639         821 :   addConstantValue(Die, isUnsignedDIType(DD, Ty), MO.getImm());
     640         821 : }
     641             : 
     642       35778 : 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       35778 :   addUInt(Die, dwarf::DW_AT_const_value,
     646       35778 :           Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata, Val);
     647       35778 : }
     648             : 
     649       21073 : void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, const DIType *Ty) {
     650       21073 :   addConstantValue(Die, Val, isUnsignedDIType(DD, Ty));
     651       21073 : }
     652             : 
     653       21075 : void DwarfUnit::addConstantValue(DIE &Die, const APInt &Val, bool Unsigned) {
     654       21075 :   unsigned CIBitWidth = Val.getBitWidth();
     655       21075 :   if (CIBitWidth <= 64) {
     656       26522 :     addConstantValue(Die, Unsigned,
     657             :                      Unsigned ? Val.getZExtValue() : Val.getSExtValue());
     658       21074 :     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      311163 : void DwarfUnit::addLinkageName(DIE &Die, StringRef LinkageName) {
     683      311163 :   if (!LinkageName.empty())
     684      346852 :     addString(Die,
     685      173426 :               DD->getDwarfVersion() >= 4 ? dwarf::DW_AT_linkage_name
     686             :                                          : dwarf::DW_AT_MIPS_linkage_name,
     687             :               GlobalValue::dropLLVMManglingEscape(LinkageName));
     688      311163 : }
     689             : 
     690      371936 : void DwarfUnit::addTemplateParams(DIE &Buffer, DINodeArray TParams) {
     691             :   // Add template parameters.
     692      459137 :   for (const auto *Element : TParams) {
     693             :     if (auto *TTP = dyn_cast<DITemplateTypeParameter>(Element))
     694       62235 :       constructTemplateTypeParameterDIE(Buffer, TTP);
     695             :     else if (auto *TVP = dyn_cast<DITemplateValueParameter>(Element))
     696       24966 :       constructTemplateValueParameterDIE(Buffer, TVP);
     697             :   }
     698      371936 : }
     699             : 
     700             : /// Add thrown types.
     701      296254 : void DwarfUnit::addThrownTypes(DIE &Die, DINodeArray ThrownTypes) {
     702      296256 :   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      296254 : }
     707             : 
     708     2752737 : DIE *DwarfUnit::getOrCreateContextDIE(const DIScope *Context) {
     709     3962057 :   if (!Context || isa<DIFile>(Context))
     710     1637690 :     return &getUnitDie();
     711             :   if (auto *T = dyn_cast<DIType>(Context))
     712      387349 :     return getOrCreateTypeDIE(T);
     713             :   if (auto *NS = dyn_cast<DINamespace>(Context))
     714      718164 :     return getOrCreateNameSpace(NS);
     715             :   if (auto *SP = dyn_cast<DISubprogram>(Context))
     716        2401 :     return getOrCreateSubprogramDIE(SP);
     717             :   if (auto *M = dyn_cast<DIModule>(Context))
     718         614 :     return getOrCreateModule(M);
     719        6519 :   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     1563361 : DIE *DwarfUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
     739     1563383 :   if (!TyNode)
     740             :     return nullptr;
     741             : 
     742             :   auto *Ty = cast<DIType>(TyNode);
     743             : 
     744             :   // DW_TAG_restrict_type is not supported in DWARF2
     745     1563383 :   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     1563364 :   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     1563361 :   DIE *ContextDIE = getOrCreateContextDIE(Context);
     756             :   assert(ContextDIE);
     757             : 
     758     1563361 :   if (DIE *TyDIE = getDIE(Ty))
     759             :     return TyDIE;
     760             : 
     761             :   // Create new type.
     762      521590 :   DIE &TyDIE = createAndAddDIE(Ty->getTag(), *ContextDIE, Ty);
     763             : 
     764      260795 :   updateAcceleratorTables(Context, Ty, TyDIE);
     765             : 
     766             :   if (auto *BT = dyn_cast<DIBasicType>(Ty))
     767       12016 :     constructTypeDIE(TyDIE, BT);
     768             :   else if (auto *STy = dyn_cast<DISubroutineType>(Ty))
     769        1945 :     constructTypeDIE(TyDIE, STy);
     770             :   else if (auto *CTy = dyn_cast<DICompositeType>(Ty)) {
     771       46065 :     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       45952 :     constructTypeDIE(TyDIE, CTy);
     778             :   } else {
     779      200828 :     constructTypeDIE(TyDIE, cast<DIDerivedType>(Ty));
     780             :   }
     781             : 
     782             :   return &TyDIE;
     783             : }
     784             : 
     785      260839 : void DwarfUnit::updateAcceleratorTables(const DIScope *Context,
     786             :                                         const DIType *Ty, const DIE &TyDIE) {
     787      373494 :   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       33653 :       IsImplementation = CT->getRuntimeLang() == 0 || CT->isObjcClassComplete();
     793             :     }
     794             :     unsigned Flags = IsImplementation ? dwarf::DW_FLAG_type_implementation : 0;
     795      215916 :     DD->addAccelType(Ty->getName(), TyDIE, Flags);
     796             : 
     797      173216 :     if (!Context || isa<DICompileUnit>(Context) || isa<DIFile>(Context) ||
     798             :         isa<DINamespace>(Context))
     799       73270 :       addGlobalType(Ty, TyDIE, Context);
     800             :   }
     801      260839 : }
     802             : 
     803     1151334 : 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     2302668 :   addDIEEntry(Entity, Attribute, DIEEntry(*getOrCreateTypeDIE(Ty)));
     807     1151334 : }
     808             : 
     809      122387 : std::string DwarfUnit::getParentContextString(const DIScope *Context) const {
     810      122387 :   if (!Context)
     811       44983 :     return "";
     812             : 
     813             :   // FIXME: Decide whether to implement this for non-C++ languages.
     814      154808 :   if (getLanguage() != dwarf::DW_LANG_C_plus_plus)
     815        2529 :     return "";
     816             : 
     817             :   std::string CS;
     818             :   SmallVector<const DIScope *, 1> Parents;
     819      247631 :   while (!isa<DICompileUnit>(Context)) {
     820      104980 :     Parents.push_back(Context);
     821      209960 :     if (Context->getScope())
     822       65254 :       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       74875 :   for (const DIScope *Ctx : make_range(Parents.rbegin(), Parents.rend())) {
     832      104980 :     StringRef Name = Ctx->getName();
     833      109806 :     if (Name.empty() && isa<DINamespace>(Ctx))
     834             :       Name = "(anonymous namespace)";
     835      104980 :     if (!Name.empty()) {
     836             :       CS += Name;
     837             :       CS += "::";
     838             :     }
     839             :   }
     840             :   return CS;
     841             : }
     842             : 
     843       12016 : void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
     844             :   // Get core information.
     845       12016 :   StringRef Name = BTy->getName();
     846             :   // Add name if not anonymous or intermediate type.
     847       12016 :   if (!Name.empty())
     848       12008 :     addString(Buffer, dwarf::DW_AT_name, Name);
     849             : 
     850             :   // An unspecified type only has a name attribute.
     851       12016 :   if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
     852         434 :     return;
     853             : 
     854       23164 :   addUInt(Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
     855       11582 :           BTy->getEncoding());
     856             : 
     857       11582 :   uint64_t Size = BTy->getSizeInBits() >> 3;
     858       11582 :   addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
     859             : }
     860             : 
     861      200828 : void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIDerivedType *DTy) {
     862             :   // Get core information.
     863      200828 :   StringRef Name = DTy->getName();
     864      200828 :   uint64_t Size = DTy->getSizeInBits() >> 3;
     865      200828 :   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      198811 :     addType(Buffer, FromTy);
     871             : 
     872             :   // Add name if not anonymous or intermediate type.
     873      200828 :   if (!Name.empty())
     874       62343 :     addString(Buffer, dwarf::DW_AT_name, Name);
     875             : 
     876             :   // Add size if non-zero (derived types might be zero-sized.)
     877      200828 :   if (Size && Tag != dwarf::DW_TAG_pointer_type
     878       48295 :            && Tag != dwarf::DW_TAG_ptr_to_member_type
     879       48295 :            && Tag != dwarf::DW_TAG_reference_type
     880        9439 :            && Tag != dwarf::DW_TAG_rvalue_reference_type)
     881           3 :     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
     882             : 
     883      200828 :   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
     884          19 :     addDIEEntry(
     885             :         Buffer, dwarf::DW_AT_containing_type,
     886          19 :         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
     887             :   // Add source line info if available and TyDesc is not a forward declaration.
     888      200828 :   if (!DTy->isForwardDecl())
     889      200828 :     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      200828 :   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      200828 : }
     898             : 
     899      282682 : void DwarfUnit::constructSubprogramArguments(DIE &Buffer, DITypeRefArray Args) {
     900     1325794 :   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        5167 :       createAndAddDIE(dwarf::DW_TAG_unspecified_parameters, Buffer);
     905             :     } else {
     906      516389 :       DIE &Arg = createAndAddDIE(dwarf::DW_TAG_formal_parameter, Buffer);
     907      516389 :       addType(Arg, Ty);
     908      516389 :       if (Ty->isArtificial())
     909      182862 :         addFlag(Arg, dwarf::DW_AT_artificial);
     910             :     }
     911             :   }
     912      282682 : }
     913             : 
     914        1945 : 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        1945 :   if (Elements.size())
     918             :     if (auto RTy = resolve(Elements[0]))
     919        1204 :       addType(Buffer, RTy);
     920             : 
     921             :   bool isPrototyped = true;
     922        2242 :   if (Elements.size() == 2 && !Elements[1])
     923             :     isPrototyped = false;
     924             : 
     925        1945 :   constructSubprogramArguments(Buffer, Elements);
     926             : 
     927             :   // Add prototype flag if we're dealing with a C language and the function has
     928             :   // been prototyped.
     929        1945 :   uint16_t Language = getLanguage();
     930        3889 :   if (isPrototyped &&
     931        3860 :       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
     932             :        Language == dwarf::DW_LANG_ObjC))
     933          31 :     addFlag(Buffer, dwarf::DW_AT_prototyped);
     934             : 
     935             :   // Add a DW_AT_calling_convention if this has an explicit convention.
     936        1945 :   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        1945 :   if (CTy->isLValueReference())
     941           1 :     addFlag(Buffer, dwarf::DW_AT_reference);
     942             : 
     943        1945 :   if (CTy->isRValueReference())
     944           1 :     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
     945        1945 : }
     946             : 
     947       46005 : void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
     948             :   // Add name if not anonymous or intermediate type.
     949       46005 :   StringRef Name = CTy->getName();
     950             : 
     951       46005 :   uint64_t Size = CTy->getSizeInBits() >> 3;
     952       46005 :   uint16_t Tag = Buffer.getTag();
     953             : 
     954             :   switch (Tag) {
     955        3468 :   case dwarf::DW_TAG_array_type:
     956        3468 :     constructArrayTypeDIE(Buffer, CTy);
     957        3468 :     break;
     958        1556 :   case dwarf::DW_TAG_enumeration_type:
     959        1556 :     constructEnumTypeDIE(Buffer, CTy);
     960        1556 :     break;
     961       40981 :   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       40981 :     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      309363 :     for (const auto *Element : Elements) {
     982           0 :       if (!Element)
     983           0 :         continue;
     984             :       if (auto *SP = dyn_cast<DISubprogram>(Element))
     985      197695 :         getOrCreateSubprogramDIE(SP);
     986             :       else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
     987       70670 :         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       70669 :         } else if (DDTy->isStaticMember()) {
     991        5711 :           getOrCreateStaticMemberDIE(DDTy);
     992       64958 :         } 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       64955 :           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       40981 :     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        1073 :       addDIEEntry(Buffer, dwarf::DW_AT_containing_type,
    1040        1073 :                   *getOrCreateTypeDIE(ContainingType));
    1041             : 
    1042       40981 :     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       81962 :     if (Tag == dwarf::DW_TAG_class_type ||
    1048       42084 :         Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
    1049       40979 :       addTemplateParams(Buffer, CTy->getTemplateParams());
    1050             : 
    1051             :     // Add the type's non-standard calling convention.
    1052             :     uint8_t CC = 0;
    1053       40981 :     if (CTy->isTypePassByValue())
    1054             :       CC = dwarf::DW_CC_pass_by_value;
    1055       16212 :     else if (CTy->isTypePassByReference())
    1056             :       CC = dwarf::DW_CC_pass_by_reference;
    1057             :     if (CC)
    1058       70372 :       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       46005 :   if (!Name.empty())
    1068       38261 :     addString(Buffer, dwarf::DW_AT_name, Name);
    1069             : 
    1070       92010 :   if (Tag == dwarf::DW_TAG_enumeration_type ||
    1071      107257 :       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
    1072       30626 :       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       42535 :     if (Size)
    1076       37710 :       addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
    1077        4825 :     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       42535 :     if (CTy->isForwardDecl())
    1083        4787 :       addFlag(Buffer, dwarf::DW_AT_declaration);
    1084             : 
    1085             :     // Add source line info if available.
    1086       42535 :     if (!CTy->isForwardDecl())
    1087       37748 :       addSourceLine(Buffer, CTy);
    1088             : 
    1089             :     // No harm in adding the runtime language to the declaration.
    1090       42535 :     unsigned RLang = CTy->getRuntimeLang();
    1091       42535 :     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       42535 :     if (uint32_t AlignInBytes = CTy->getAlignInBytes())
    1097         550 :       addUInt(Buffer, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
    1098             :               AlignInBytes);
    1099             :   }
    1100       46005 : }
    1101             : 
    1102       62235 : void DwarfUnit::constructTemplateTypeParameterDIE(
    1103             :     DIE &Buffer, const DITemplateTypeParameter *TP) {
    1104             :   DIE &ParamDIE =
    1105       62235 :       createAndAddDIE(dwarf::DW_TAG_template_type_parameter, Buffer);
    1106             :   // Add the type if it exists, it could be void and therefore no type.
    1107       62235 :   if (TP->getType())
    1108       58939 :     addType(ParamDIE, resolve(TP->getType()));
    1109       62235 :   if (!TP->getName().empty())
    1110       49006 :     addString(ParamDIE, dwarf::DW_AT_name, TP->getName());
    1111       62235 : }
    1112             : 
    1113       24966 : void DwarfUnit::constructTemplateValueParameterDIE(
    1114             :     DIE &Buffer, const DITemplateValueParameter *VP) {
    1115       49932 :   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       24966 :   if (VP->getTag() == dwarf::DW_TAG_template_value_parameter)
    1120       16542 :     addType(ParamDIE, resolve(VP->getType()));
    1121       24966 :   if (!VP->getName().empty())
    1122       19524 :     addString(ParamDIE, dwarf::DW_AT_name, VP->getName());
    1123       24966 :   if (Metadata *Val = VP->getValue()) {
    1124             :     if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
    1125       16512 :       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       16848 :     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_template_param) {
    1140             :       assert(isa<MDString>(Val));
    1141         146 :       addString(ParamDIE, dwarf::DW_AT_GNU_template_name,
    1142             :                 cast<MDString>(Val)->getString());
    1143        8278 :     } else if (VP->getTag() == dwarf::DW_TAG_GNU_template_parameter_pack) {
    1144        8278 :       addTemplateParams(ParamDIE, cast<MDTuple>(Val));
    1145             :     }
    1146             :   }
    1147       24966 : }
    1148             : 
    1149      718903 : 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      718903 :   DIE *ContextDIE = getOrCreateContextDIE(NS->getScope());
    1153             : 
    1154      718903 :   if (DIE *NDie = getDIE(NS))
    1155             :     return NDie;
    1156        3806 :   DIE &NDie = createAndAddDIE(dwarf::DW_TAG_namespace, *ContextDIE, NS);
    1157             : 
    1158        3806 :   StringRef Name = NS->getName();
    1159        3806 :   if (!Name.empty())
    1160        3751 :     addString(NDie, dwarf::DW_AT_name, NS->getName());
    1161             :   else
    1162          55 :     Name = "(anonymous namespace)";
    1163        3806 :   DD->addAccelNamespace(Name, NDie);
    1164        7612 :   addGlobalName(Name, NDie, NS->getScope());
    1165        3806 :   if (NS->getExportSymbols())
    1166         166 :     addFlag(NDie, dwarf::DW_AT_export_symbols);
    1167             :   return &NDie;
    1168             : }
    1169             : 
    1170         621 : 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         621 :   DIE *ContextDIE = getOrCreateContextDIE(M->getScope());
    1174             : 
    1175         621 :   if (DIE *MDie = getDIE(M))
    1176             :     return MDie;
    1177         121 :   DIE &MDie = createAndAddDIE(dwarf::DW_TAG_module, *ContextDIE, M);
    1178             : 
    1179         121 :   if (!M->getName().empty()) {
    1180         121 :     addString(MDie, dwarf::DW_AT_name, M->getName());
    1181         242 :     addGlobalName(M->getName(), MDie, M->getScope());
    1182             :   }
    1183         121 :   if (!M->getConfigurationMacros().empty())
    1184          26 :     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
    1185             :               M->getConfigurationMacros());
    1186         121 :   if (!M->getIncludePath().empty())
    1187         114 :     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
    1188         121 :   if (!M->getISysRoot().empty())
    1189         121 :     addString(MDie, dwarf::DW_AT_LLVM_isysroot, M->getISysRoot());
    1190             :   
    1191             :   return &MDie;
    1192             : }
    1193             : 
    1194      357975 : 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      711414 :       Minimal ? &getUnitDie() : getOrCreateContextDIE(resolve(SP->getScope()));
    1200             : 
    1201      357975 :   if (DIE *SPDie = getDIE(SP))
    1202             :     return SPDie;
    1203             : 
    1204             :   if (auto *SPDecl = SP->getDeclaration()) {
    1205       24134 :     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       24116 :       getOrCreateSubprogramDIE(SPDecl);
    1210             :     }
    1211             :   }
    1212             : 
    1213             :   // DW_TAG_inlined_subroutine may refer to this DIE.
    1214      324263 :   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      324263 :   if (SP->isDefinition())
    1219             :     return &SPDie;
    1220             : 
    1221      280737 :   applySubprogramAttributes(SP, SPDie);
    1222      280737 :   return &SPDie;
    1223             : }
    1224             : 
    1225      322679 : bool DwarfUnit::applySubprogramDefinitionAttributes(const DISubprogram *SP,
    1226             :                                                     DIE &SPDie) {
    1227             :   DIE *DeclDie = nullptr;
    1228             :   StringRef DeclLinkageName;
    1229             :   if (auto *SPDecl = SP->getDeclaration()) {
    1230       26424 :     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       26424 :     if (DD->useAllLinkageNames())
    1236             :       DeclLinkageName = SPDecl->getLinkageName();
    1237       52848 :     unsigned DeclID = getOrCreateSourceID(SPDecl->getFile());
    1238       52848 :     unsigned DefID = getOrCreateSourceID(SP->getFile());
    1239       26424 :     if (DeclID != DefID)
    1240        3590 :       addUInt(SPDie, dwarf::DW_AT_decl_file, None, DefID);
    1241             : 
    1242       26424 :     if (SP->getLine() != SPDecl->getLine())
    1243        4548 :       addUInt(SPDie, dwarf::DW_AT_decl_line, None, SP->getLine());
    1244             :   }
    1245             : 
    1246             :   // Add function template parameters.
    1247      322679 :   addTemplateParams(SPDie, SP->getTemplateParams());
    1248             : 
    1249             :   // Add the linkage name if we have one and it isn't in the Decl.
    1250      322679 :   StringRef LinkageName = SP->getLinkageName();
    1251             :   assert(((LinkageName.empty() || DeclLinkageName.empty()) ||
    1252             :           LinkageName == DeclLinkageName) &&
    1253             :          "decl has a linkage name and it is different");
    1254      629344 :   if (DeclLinkageName.empty() &&
    1255             :       // Always emit it for abstract subprograms.
    1256      306703 :       (DD->useAllLinkageNames() || DU->getAbstractSPDies().lookup(SP)))
    1257      306637 :     addLinkageName(SPDie, LinkageName);
    1258             : 
    1259      322679 :   if (!DeclDie)
    1260             :     return false;
    1261             : 
    1262             :   // Refer to the function declaration where all the other attributes will be
    1263             :   // found.
    1264       26424 :   addDIEEntry(SPDie, dwarf::DW_AT_specification, *DeclDie);
    1265       26424 :   return true;
    1266             : }
    1267             : 
    1268      341148 : 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      359618 :   bool SkipSPSourceLocation = SkipSPAttributes &&
    1273       18470 :                               !CUNode->getDebugInfoForProfiling();
    1274             :   if (!SkipSPSourceLocation)
    1275      322679 :     if (applySubprogramDefinitionAttributes(SP, SPDie))
    1276             :       return;
    1277             : 
    1278             :   // Constructors and operators for anonymous aggregates do not have names.
    1279      314724 :   if (!SP->getName().empty())
    1280      314369 :     addString(SPDie, dwarf::DW_AT_name, SP->getName());
    1281             : 
    1282      314724 :   if (!SkipSPSourceLocation)
    1283      296255 :     addSourceLine(SPDie, SP);
    1284             : 
    1285             :   // Skip the rest of the attributes under -gmlt to save space.
    1286      314724 :   if (SkipSPAttributes)
    1287             :     return;
    1288             : 
    1289             :   // Add the prototype if we have a prototype and we have a C like
    1290             :   // language.
    1291      296254 :   uint16_t Language = getLanguage();
    1292      591807 :   if (SP->isPrototyped() &&
    1293      589557 :       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
    1294             :        Language == dwarf::DW_LANG_ObjC))
    1295        1590 :     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      296254 :     CC = SPTy->getCC();
    1302             :   }
    1303             : 
    1304             :   // Add a DW_AT_calling_convention if this has an explicit convention.
    1305      296254 :   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      296254 :   if (Args.size())
    1311             :     if (auto Ty = resolve(Args[0]))
    1312      202412 :       addType(SPDie, Ty);
    1313             : 
    1314             :   unsigned VK = SP->getVirtuality();
    1315      296254 :   if (VK) {
    1316        7282 :     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
    1317        3641 :     if (SP->getVirtualIndex() != -1u) {
    1318             :       DIELoc *Block = getDIELoc();
    1319        3640 :       addUInt(*Block, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
    1320        3640 :       addUInt(*Block, dwarf::DW_FORM_udata, SP->getVirtualIndex());
    1321        3640 :       addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, Block);
    1322             :     }
    1323        3641 :     ContainingTypeMap.insert(
    1324        7282 :         std::make_pair(&SPDie, resolve(SP->getContainingType())));
    1325             :   }
    1326             : 
    1327      296254 :   if (!SP->isDefinition()) {
    1328      280737 :     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      280737 :     constructSubprogramArguments(SPDie, Args);
    1333             :   }
    1334             : 
    1335      296254 :   addThrownTypes(SPDie, SP->getThrownTypes());
    1336             : 
    1337      296254 :   if (SP->isArtificial())
    1338        1304 :     addFlag(SPDie, dwarf::DW_AT_artificial);
    1339             : 
    1340      296254 :   if (!SP->isLocalToUnit())
    1341      294454 :     addFlag(SPDie, dwarf::DW_AT_external);
    1342             : 
    1343      296254 :   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      296254 :   if (SP->isLValueReference())
    1352           1 :     addFlag(SPDie, dwarf::DW_AT_reference);
    1353             : 
    1354      296254 :   if (SP->isRValueReference())
    1355           1 :     addFlag(SPDie, dwarf::DW_AT_rvalue_reference);
    1356             : 
    1357      296254 :   if (SP->isNoReturn())
    1358        2146 :     addFlag(SPDie, dwarf::DW_AT_noreturn);
    1359             : 
    1360      296254 :   if (SP->isProtected())
    1361       11348 :     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1362             :             dwarf::DW_ACCESS_protected);
    1363      284906 :   else if (SP->isPrivate())
    1364         419 :     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1365             :             dwarf::DW_ACCESS_private);
    1366      284487 :   else if (SP->isPublic())
    1367      123805 :     addUInt(SPDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1368             :             dwarf::DW_ACCESS_public);
    1369             : 
    1370      296254 :   if (SP->isExplicit())
    1371        7473 :     addFlag(SPDie, dwarf::DW_AT_explicit);
    1372             : 
    1373      296254 :   if (SP->isMainSubprogram())
    1374           5 :     addFlag(SPDie, dwarf::DW_AT_main_subprogram);
    1375             : }
    1376             : 
    1377        3539 : void DwarfUnit::constructSubrangeDIE(DIE &Buffer, const DISubrange *SR,
    1378             :                                      DIE *IndexTy) {
    1379        3539 :   DIE &DW_Subrange = createAndAddDIE(dwarf::DW_TAG_subrange_type, Buffer);
    1380        3539 :   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        3539 :   int64_t LowerBound = SR->getLowerBound();
    1387        3539 :   int64_t DefaultLowerBound = getDefaultLowerBound();
    1388             :   int64_t Count = -1;
    1389        7078 :   if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
    1390             :     Count = CI->getSExtValue();
    1391             : 
    1392        3539 :   if (DefaultLowerBound == -1 || LowerBound != DefaultLowerBound)
    1393          18 :     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, None, LowerBound);
    1394             : 
    1395        7078 :   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        3525 :   } else if (Count != -1)
    1399        6652 :     addUInt(DW_Subrange, dwarf::DW_AT_count, None, Count);
    1400        3539 : }
    1401             : 
    1402        3468 : DIE *DwarfUnit::getIndexTyDie() {
    1403        3468 :   if (IndexTyDie)
    1404             :     return IndexTyDie;
    1405             :   // Construct an integer type to use for indexes.
    1406         811 :   IndexTyDie = &createAndAddDIE(dwarf::DW_TAG_base_type, getUnitDie());
    1407             :   StringRef Name = "__ARRAY_SIZE_TYPE__";
    1408         811 :   addString(*IndexTyDie, dwarf::DW_AT_name, Name);
    1409         811 :   addUInt(*IndexTyDie, dwarf::DW_AT_byte_size, None, sizeof(int64_t));
    1410         811 :   addUInt(*IndexTyDie, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
    1411             :           dwarf::DW_ATE_unsigned);
    1412         811 :   DD->addAccelType(Name, *IndexTyDie, /*Flags*/ 0);
    1413         811 :   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          34 : static bool hasVectorBeenPadded(const DICompositeType *CTy) {
    1420             :   assert(CTy && CTy->isVector() && "Composite type is not a vector");
    1421          34 :   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          34 :   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          68 :   const auto CI = Subrange->getCount().get<ConstantInt *>();
    1435          34 :   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          34 :   return ActualSize != (NumVecElements * ElementSize);
    1441             : }
    1442             : 
    1443        3468 : void DwarfUnit::constructArrayTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
    1444        3468 :   if (CTy->isVector()) {
    1445          34 :     addFlag(Buffer, dwarf::DW_AT_GNU_vector);
    1446          34 :     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        3468 :   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        3468 :   DIE *IdxTy = getIndexTyDie();
    1458             : 
    1459             :   // Add subranges to array type.
    1460             :   DINodeArray Elements = CTy->getElements();
    1461       10546 :   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        3539 :       if (Element->getTag() == dwarf::DW_TAG_subrange_type)
    1465        3539 :         constructSubrangeDIE(Buffer, cast<DISubrange>(Element), IdxTy);
    1466             :   }
    1467        3468 : }
    1468             : 
    1469        1556 : void DwarfUnit::constructEnumTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
    1470             :   const DIType *DTy = resolve(CTy->getBaseType());
    1471        1513 :   bool IsUnsigned = DTy && isUnsignedDIType(DD, DTy);
    1472        1556 :   if (DTy) {
    1473        1513 :     if (DD->getDwarfVersion() >= 3)
    1474        1504 :       addType(Buffer, DTy);
    1475        3017 :     if (DD->getDwarfVersion() >= 4 && (CTy->getFlags() & DINode::FlagFixedEnum))
    1476         137 :       addFlag(Buffer, dwarf::DW_AT_enum_class);
    1477             :   }
    1478             : 
    1479             :   DINodeArray Elements = CTy->getElements();
    1480             : 
    1481             :   // Add enumerators to enumeration type.
    1482       29300 :   for (unsigned i = 0, N = Elements.size(); i < N; ++i) {
    1483             :     auto *Enum = dyn_cast_or_null<DIEnumerator>(Elements[i]);
    1484             :     if (Enum) {
    1485       13872 :       DIE &Enumerator = createAndAddDIE(dwarf::DW_TAG_enumerator, Buffer);
    1486       13872 :       StringRef Name = Enum->getName();
    1487       13872 :       addString(Enumerator, dwarf::DW_AT_name, Name);
    1488       13872 :       auto Value = static_cast<uint64_t>(Enum->getValue());
    1489       13872 :       addConstantValue(Enumerator, IsUnsigned, Value);
    1490             :     }
    1491             :   }
    1492        1556 : }
    1493             : 
    1494        3249 : void DwarfUnit::constructContainingTypeDIEs() {
    1495        3249 :   for (auto CI = ContainingTypeMap.begin(), CE = ContainingTypeMap.end();
    1496        6890 :        CI != CE; ++CI) {
    1497        3641 :     DIE &SPDie = *CI->first;
    1498        3641 :     const DINode *D = CI->second;
    1499        3641 :     if (!D)
    1500           0 :       continue;
    1501        3641 :     DIE *NDie = getDIE(D);
    1502        3641 :     if (!NDie)
    1503           0 :       continue;
    1504        3641 :     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, *NDie);
    1505             :   }
    1506        3249 : }
    1507             : 
    1508       64959 : DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
    1509      129918 :   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
    1510       64959 :   StringRef Name = DT->getName();
    1511       64959 :   if (!Name.empty())
    1512       56630 :     addString(MemberDie, dwarf::DW_AT_name, Name);
    1513             : 
    1514             :   if (DIType *Resolved = resolve(DT->getBaseType()))
    1515       64958 :     addType(MemberDie, Resolved);
    1516             : 
    1517       64959 :   addSourceLine(MemberDie, DT);
    1518             : 
    1519       72944 :   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          33 :     DIELoc *VBaseLocationDie = new (DIEValueAllocator) DIELoc;
    1526          33 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
    1527          33 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
    1528          33 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
    1529          33 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
    1530          33 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
    1531          33 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
    1532          33 :     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
    1533             : 
    1534          33 :     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
    1535             :   } else {
    1536       64926 :     uint64_t Size = DT->getSizeInBits();
    1537       64926 :     uint64_t FieldSize = DD->getBaseTypeSize(DT);
    1538             :     uint32_t AlignInBytes = DT->getAlignInBytes();
    1539             :     uint64_t OffsetInBytes;
    1540             : 
    1541       64926 :     bool IsBitfield = FieldSize && Size != FieldSize;
    1542       64926 :     if (IsBitfield) {
    1543             :       // Handle bitfield, assume bytes are 8 bits.
    1544         111 :       if (DD->useDWARF2Bitfields())
    1545         196 :         addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
    1546         111 :       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);
    1547             : 
    1548         111 :       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         111 :       uint32_t AlignInBits = FieldSize;
    1553         111 :       uint32_t AlignMask = ~(AlignInBits - 1);
    1554             :       // The bits from the start of the storage unit to the start of the field.
    1555         111 :       uint64_t StartBitOffset = Offset - (Offset & AlignMask);
    1556             :       // The byte offset of the field's aligned storage unit inside the struct.
    1557         111 :       OffsetInBytes = (Offset - StartBitOffset) / 8;
    1558             : 
    1559         111 :       if (DD->useDWARF2Bitfields()) {
    1560          98 :         uint64_t HiMark = (Offset + FieldSize) & AlignMask;
    1561          98 :         uint64_t FieldOffset = (HiMark - FieldSize);
    1562          98 :         Offset -= FieldOffset;
    1563             : 
    1564             :         // Maybe we need to work from the other end.
    1565          98 :         if (Asm->getDataLayout().isLittleEndian())
    1566          95 :           Offset = FieldSize - (Offset + Size);
    1567             : 
    1568          98 :         addUInt(MemberDie, dwarf::DW_AT_bit_offset, None, Offset);
    1569          98 :         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       64815 :       OffsetInBytes = DT->getOffsetInBits() / 8;
    1576       64815 :       if (AlignInBytes)
    1577        1114 :         addUInt(MemberDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
    1578             :                 AlignInBytes);
    1579             :     }
    1580             : 
    1581       64926 :     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       64812 :     } else if (!IsBitfield || DD->useDWARF2Bitfields())
    1587       64799 :       addUInt(MemberDie, dwarf::DW_AT_data_member_location, None,
    1588             :               OffsetInBytes);
    1589             :   }
    1590             : 
    1591       64959 :   if (DT->isProtected())
    1592        2951 :     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1593             :             dwarf::DW_ACCESS_protected);
    1594       62008 :   else if (DT->isPrivate())
    1595        2098 :     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       59910 :   else if (DT->isPublic())
    1599        2808 :     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1600             :             dwarf::DW_ACCESS_public);
    1601       64959 :   if (DT->isVirtual())
    1602          33 :     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       64959 :   if (DT->isArtificial())
    1612         782 :     addFlag(MemberDie, dwarf::DW_AT_artificial);
    1613             : 
    1614       64959 :   return MemberDie;
    1615             : }
    1616             : 
    1617        5777 : DIE *DwarfUnit::getOrCreateStaticMemberDIE(const DIDerivedType *DT) {
    1618        5777 :   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        5777 :   DIE *ContextDIE = getOrCreateContextDIE(resolve(DT->getScope()));
    1624             :   assert(dwarf::isType(ContextDIE->getTag()) &&
    1625             :          "Static member should belong to a type.");
    1626             : 
    1627        5777 :   if (DIE *StaticMemberDIE = getDIE(DT))
    1628             :     return StaticMemberDIE;
    1629             : 
    1630       11422 :   DIE &StaticMemberDIE = createAndAddDIE(DT->getTag(), *ContextDIE, DT);
    1631             : 
    1632             :   const DIType *Ty = resolve(DT->getBaseType());
    1633             : 
    1634        5711 :   addString(StaticMemberDIE, dwarf::DW_AT_name, DT->getName());
    1635        5711 :   addType(StaticMemberDIE, Ty);
    1636        5711 :   addSourceLine(StaticMemberDIE, DT);
    1637        5711 :   addFlag(StaticMemberDIE, dwarf::DW_AT_external);
    1638        5711 :   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        5711 :   if (DT->isProtected())
    1643          34 :     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1644             :             dwarf::DW_ACCESS_protected);
    1645        5677 :   else if (DT->isPrivate())
    1646          89 :     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1647             :             dwarf::DW_ACCESS_private);
    1648        5588 :   else if (DT->isPublic())
    1649        3017 :     addUInt(StaticMemberDIE, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
    1650             :             dwarf::DW_ACCESS_public);
    1651             : 
    1652        5709 :   if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
    1653        4560 :     addConstantValue(StaticMemberDIE, CI, Ty);
    1654             :   if (const ConstantFP *CFP = dyn_cast_or_null<ConstantFP>(DT->getConstant()))
    1655           2 :     addConstantFPValue(StaticMemberDIE, CFP);
    1656             : 
    1657        5711 :   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        3901 : void DwarfUnit::emitCommonHeader(bool UseOffsets, dwarf::UnitType UT) {
    1665             :   // Emit size of content not including length itself
    1666       11703 :   Asm->OutStreamer->AddComment("Length of Unit");
    1667        3901 :   Asm->emitInt32(getHeaderSize() + getUnitDie().getSize());
    1668             : 
    1669       11703 :   Asm->OutStreamer->AddComment("DWARF version number");
    1670        3901 :   unsigned Version = DD->getDwarfVersion();
    1671        3901 :   Asm->emitInt16(Version);
    1672             : 
    1673             :   // DWARF v5 reorders the address size and adds a unit type.
    1674        3901 :   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       11703 :   Asm->OutStreamer->AddComment("Offset Into Abbrev. Section");
    1685        3901 :   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
    1686        3901 :   if (UseOffsets)
    1687         618 :     Asm->emitInt32(0);
    1688             :   else
    1689        6566 :     Asm->emitDwarfSymbolReference(
    1690        3283 :         TLOF.getDwarfAbbrevSection()->getBeginSymbol(), false);
    1691             : 
    1692        3901 :   if (Version <= 4) {
    1693       11598 :     Asm->OutStreamer->AddComment("Address Size (in bytes)");
    1694        3866 :     Asm->emitInt8(Asm->MAI->getCodePointerSize());
    1695             :   }
    1696        3901 : }
    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         356 : DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
    1712             :                            const MCSymbol *Hi, const MCSymbol *Lo) {
    1713             :   return Die.addValue(DIEValueAllocator, Attribute,
    1714         356 :                       DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
    1715             :                                                  : dwarf::DW_FORM_data4,
    1716        1068 :                       new (DIEValueAllocator) DIEDelta(Hi, Lo));
    1717             : }
    1718             : 
    1719             : DIE::value_iterator
    1720       59484 : DwarfUnit::addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
    1721             :                            const MCSymbol *Label, const MCSymbol *Sec) {
    1722       59484 :   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
    1723             :     return addLabel(Die, Attribute,
    1724       59261 :                     DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
    1725             :                                                : dwarf::DW_FORM_data4,
    1726       59261 :                     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         317 : const MCSymbol *DwarfUnit::getCrossSectionRelativeBaseAddress() const {
    1747         317 :   if (!Asm->MAI->doesDwarfUseRelocationsAcrossSections())
    1748             :     return nullptr;
    1749         307 :   if (isDwoUnit())
    1750             :     return nullptr;
    1751         304 :   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      303534 : }

Generated by: LCOV version 1.13