LCOV - code coverage report
Current view: top level - lib/CodeGen/AsmPrinter - DwarfCompileUnit.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 434 439 98.9 %
Date: 2018-06-17 00:07:59 Functions: 46 46 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf 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 "DwarfCompileUnit.h"
      15             : #include "AddressPool.h"
      16             : #include "DwarfDebug.h"
      17             : #include "DwarfExpression.h"
      18             : #include "DwarfUnit.h"
      19             : #include "llvm/ADT/None.h"
      20             : #include "llvm/ADT/STLExtras.h"
      21             : #include "llvm/ADT/SmallVector.h"
      22             : #include "llvm/ADT/StringRef.h"
      23             : #include "llvm/BinaryFormat/Dwarf.h"
      24             : #include "llvm/CodeGen/AsmPrinter.h"
      25             : #include "llvm/CodeGen/DIE.h"
      26             : #include "llvm/CodeGen/LexicalScopes.h"
      27             : #include "llvm/CodeGen/MachineFunction.h"
      28             : #include "llvm/CodeGen/MachineInstr.h"
      29             : #include "llvm/CodeGen/MachineOperand.h"
      30             : #include "llvm/CodeGen/TargetFrameLowering.h"
      31             : #include "llvm/CodeGen/TargetRegisterInfo.h"
      32             : #include "llvm/CodeGen/TargetSubtargetInfo.h"
      33             : #include "llvm/IR/DataLayout.h"
      34             : #include "llvm/IR/DebugInfo.h"
      35             : #include "llvm/IR/DebugInfoMetadata.h"
      36             : #include "llvm/IR/GlobalVariable.h"
      37             : #include "llvm/MC/MCSection.h"
      38             : #include "llvm/MC/MCStreamer.h"
      39             : #include "llvm/MC/MCSymbol.h"
      40             : #include "llvm/MC/MachineLocation.h"
      41             : #include "llvm/Support/Casting.h"
      42             : #include "llvm/Target/TargetLoweringObjectFile.h"
      43             : #include "llvm/Target/TargetMachine.h"
      44             : #include "llvm/Target/TargetOptions.h"
      45             : #include <algorithm>
      46             : #include <cassert>
      47             : #include <cstdint>
      48             : #include <iterator>
      49             : #include <memory>
      50             : #include <string>
      51             : #include <utility>
      52             : 
      53             : using namespace llvm;
      54             : 
      55        3868 : DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
      56             :                                    AsmPrinter *A, DwarfDebug *DW,
      57        3868 :                                    DwarfFile *DWU)
      58       19340 :     : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID) {
      59        3868 :   insertDIE(Node, &getUnitDie());
      60        7736 :   MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
      61        3868 : }
      62             : 
      63             : /// addLabelAddress - Add a dwarf label attribute data and value using
      64             : /// DW_FORM_addr or DW_FORM_GNU_addr_index.
      65       91755 : void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
      66             :                                        const MCSymbol *Label) {
      67             :   // Don't use the address pool in non-fission or in the skeleton unit itself.
      68             :   // FIXME: Once GDB supports this, it's probably worthwhile using the address
      69             :   // pool from the skeleton - maybe even in non-fission (possibly fewer
      70             :   // relocations by sharing them in the pool, but we have other ideas about how
      71             :   // to reduce the number of relocations as well/instead).
      72       91755 :   if (!DD->useSplitDwarf() || !Skeleton)
      73       82995 :     return addLocalLabelAddress(Die, Attribute, Label);
      74             : 
      75        8760 :   if (Label)
      76             :     DD->addArangeLabel(SymbolCU(this, Label));
      77             : 
      78       17520 :   unsigned idx = DD->getAddressPool().getIndex(Label);
      79             :   Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_GNU_addr_index,
      80        8760 :                DIEInteger(idx));
      81             : }
      82             : 
      83       82995 : void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
      84             :                                             dwarf::Attribute Attribute,
      85             :                                             const MCSymbol *Label) {
      86       82995 :   if (Label)
      87       82995 :     DD->addArangeLabel(SymbolCU(this, Label));
      88             : 
      89       82995 :   if (Label)
      90             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
      91       82995 :                  DIELabel(Label));
      92             :   else
      93             :     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
      94           0 :                  DIEInteger(0));
      95       82995 : }
      96             : 
      97     1492475 : unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
      98             :   // If we print assembly, we can't separate .file entries according to
      99             :   // compile units. Thus all files will belong to the default compile unit.
     100             : 
     101             :   // FIXME: add a better feature test than hasRawTextSupport. Even better,
     102             :   // extend .file to support this.
     103     2984950 :   unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
     104     1492475 :   if (!File)
     105        1214 :     return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID);
     106     2982522 :   return Asm->OutStreamer->EmitDwarfFileDirective(
     107             :       0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
     108     1491261 :       File->getSource(), CUID);
     109             : }
     110             : 
     111        4615 : DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
     112             :     const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
     113             :   // Check for pre-existence.
     114        4615 :   if (DIE *Die = getDIE(GV))
     115             :     return Die;
     116             : 
     117             :   assert(GV);
     118             : 
     119             :   auto *GVContext = GV->getScope();
     120             :   auto *GTy = DD->resolve(GV->getType());
     121             : 
     122             :   // Construct the context before querying for the existence of the DIE in
     123             :   // case such construction creates the DIE.
     124        4537 :   DIE *ContextDIE = getOrCreateContextDIE(GVContext);
     125             : 
     126             :   // Add to map.
     127        9074 :   DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
     128             :   DIScope *DeclContext;
     129             :   if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
     130             :     DeclContext = resolve(SDMDecl->getScope());
     131             :     assert(SDMDecl->isStaticMember() && "Expected static member decl");
     132             :     assert(GV->isDefinition());
     133             :     // We need the declaration DIE that is in the static member's class.
     134          66 :     DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
     135          66 :     addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
     136             :     // If the global variable's type is different from the one in the class
     137             :     // member type, assume that it's more specific and also emit it.
     138          66 :     if (GTy != DD->resolve(SDMDecl->getBaseType()))
     139          10 :       addType(*VariableDIE, GTy);
     140             :   } else {
     141             :     DeclContext = GV->getScope();
     142             :     // Add name and type.
     143        4471 :     addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
     144        4471 :     addType(*VariableDIE, GTy);
     145             : 
     146             :     // Add scoping info.
     147        4471 :     if (!GV->isLocalToUnit())
     148        1935 :       addFlag(*VariableDIE, dwarf::DW_AT_external);
     149             : 
     150             :     // Add line number info.
     151        4471 :     addSourceLine(*VariableDIE, GV);
     152             :   }
     153             : 
     154        4537 :   if (!GV->isDefinition())
     155         261 :     addFlag(*VariableDIE, dwarf::DW_AT_declaration);
     156             :   else
     157        4276 :     addGlobalName(GV->getName(), *VariableDIE, DeclContext);
     158             : 
     159        4537 :   if (uint32_t AlignInBytes = GV->getAlignInBytes())
     160           8 :     addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
     161             :             AlignInBytes);
     162             : 
     163             :   // Add location.
     164             :   bool addToAccelTable = false;
     165             :   DIELoc *Loc = nullptr;
     166             :   std::unique_ptr<DIEDwarfExpression> DwarfExpr;
     167       13083 :   for (const auto &GE : GlobalExprs) {
     168        4284 :     const GlobalVariable *Global = GE.Var;
     169        4284 :     const DIExpression *Expr = GE.Expr;
     170             : 
     171             :     // For compatibility with DWARF 3 and earlier,
     172             :     // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
     173             :     // DW_AT_const_value(X).
     174        4284 :     if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
     175             :       addToAccelTable = true;
     176          11 :       addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
     177          11 :       break;
     178             :     }
     179             : 
     180             :     // We cannot describe the location of dllimport'd variables: the
     181             :     // computation of their address requires loads from the IAT.
     182        7400 :     if (Global && Global->hasDLLImportStorageClass())
     183           1 :       continue;
     184             : 
     185             :     // Nothing to describe without address or constant.
     186        5419 :     if (!Global && (!Expr || !Expr->isConstant()))
     187        1140 :       continue;
     188             : 
     189        3132 :     if (!Loc) {
     190             :       addToAccelTable = true;
     191        3124 :       Loc = new (DIEValueAllocator) DIELoc;
     192        3124 :       DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
     193             :     }
     194             : 
     195        3132 :     if (Expr)
     196        3132 :       DwarfExpr->addFragmentOffset(Expr);
     197             : 
     198        3132 :     if (Global) {
     199        3125 :       const MCSymbol *Sym = Asm->getSymbol(Global);
     200        3125 :       if (Global->isThreadLocal()) {
     201          35 :         if (Asm->TM.useEmulatedTLS()) {
     202             :           // TODO: add debug info for emulated thread local mode.
     203             :         } else {
     204             :           // FIXME: Make this work with -gsplit-dwarf.
     205          32 :           unsigned PointerSize = Asm->getDataLayout().getPointerSize();
     206             :           assert((PointerSize == 4 || PointerSize == 8) &&
     207             :                  "Add support for other sizes if necessary");
     208             :           // Based on GCC's support for TLS:
     209          32 :           if (!DD->useSplitDwarf()) {
     210             :             // 1) Start with a constNu of the appropriate pointer size
     211          28 :             addUInt(*Loc, dwarf::DW_FORM_data1,
     212             :                     PointerSize == 4 ? dwarf::DW_OP_const4u
     213             :                                      : dwarf::DW_OP_const8u);
     214             :             // 2) containing the (relocated) offset of the TLS variable
     215             :             //    within the module's TLS block.
     216          28 :             addExpr(*Loc, dwarf::DW_FORM_udata,
     217          28 :                     Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
     218             :           } else {
     219           4 :             addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
     220           4 :             addUInt(*Loc, dwarf::DW_FORM_udata,
     221           8 :                     DD->getAddressPool().getIndex(Sym, /* TLS */ true));
     222             :           }
     223             :           // 3) followed by an OP to make the debugger do a TLS lookup.
     224          32 :           addUInt(*Loc, dwarf::DW_FORM_data1,
     225          32 :                   DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
     226             :                                         : dwarf::DW_OP_form_tls_address);
     227             :         }
     228             :       } else {
     229        3090 :         DD->addArangeLabel(SymbolCU(this, Sym));
     230        3090 :         addOpAddress(*Loc, Sym);
     231             :       }
     232             :     }
     233             :     // Global variables attached to symbols are memory locations.
     234             :     // It would be better if this were unconditional, but malformed input that
     235             :     // mixes non-fragments and fragments for the same variable is too expensive
     236             :     // to detect in the verifier.
     237        3132 :     if (DwarfExpr->isUnknownLocation())
     238             :       DwarfExpr->setMemoryLocationKind();
     239        6264 :     DwarfExpr->addExpression(Expr);
     240             :   }
     241        4537 :   if (Loc)
     242        3124 :     addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());
     243             : 
     244        4537 :   if (DD->useAllLinkageNames())
     245        4526 :     addLinkageName(*VariableDIE, GV->getLinkageName());
     246             : 
     247        4537 :   if (addToAccelTable) {
     248        6270 :     DD->addAccelName(GV->getName(), *VariableDIE);
     249             : 
     250             :     // If the linkage name is different than the name, go ahead and output
     251             :     // that as well into the name table.
     252        1148 :     if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
     253        1148 :         DD->useAllLinkageNames())
     254        1143 :       DD->addAccelName(GV->getLinkageName(), *VariableDIE);
     255             :   }
     256             : 
     257             :   return VariableDIE;
     258             : }
     259             : 
     260       44498 : void DwarfCompileUnit::addRange(RangeSpan Range) {
     261       44498 :   bool SameAsPrevCU = this == DD->getPrevCU();
     262             :   DD->setPrevCU(this);
     263             :   // If we have no current ranges just add the range and return, otherwise,
     264             :   // check the current section and CU against the previous section and CU we
     265             :   // emitted into and the subprogram was contained within. If these are the
     266             :   // same then extend our current range, otherwise add this as a new range.
     267       85951 :   if (CURanges.empty() || !SameAsPrevCU ||
     268       41453 :       (&CURanges.back().getEnd()->getSection() !=
     269       41453 :        &Range.getEnd()->getSection())) {
     270       40300 :     CURanges.push_back(Range);
     271       40300 :     return;
     272             :   }
     273             : 
     274        4198 :   CURanges.back().setEnd(Range.getEnd());
     275             : }
     276             : 
     277        3263 : void DwarfCompileUnit::initStmtList() {
     278             :   // Define start line table label for each Compile Unit.
     279             :   MCSymbol *LineTableStartSym;
     280        3263 :   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
     281        3263 :   if (DD->useSectionsAsReferences()) {
     282           6 :     LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
     283             :   } else {
     284        3257 :     LineTableStartSym =
     285        6514 :         Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
     286             :   }
     287             : 
     288             :   // DW_AT_stmt_list is a offset of line number information for this
     289             :   // compile unit in debug_line section. For split dwarf this is
     290             :   // left in the skeleton CU and so not included.
     291             :   // The line table entries are not always emitted in assembly, so it
     292             :   // is not okay to use line_table_start here.
     293        3263 :   StmtListValue =
     294             :       addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
     295        3263 :                       TLOF.getDwarfLineSection()->getBeginSymbol());
     296        3263 : }
     297             : 
     298          20 : void DwarfCompileUnit::applyStmtList(DIE &D) {
     299          40 :   D.addValue(DIEValueAllocator, *StmtListValue);
     300          20 : }
     301             : 
     302       91448 : void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
     303             :                                        const MCSymbol *End) {
     304             :   assert(Begin && "Begin label should not be null!");
     305             :   assert(End && "End label should not be null!");
     306             :   assert(Begin->isDefined() && "Invalid starting label");
     307             :   assert(End->isDefined() && "Invalid end label");
     308             : 
     309       91448 :   addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
     310       91448 :   if (DD->getDwarfVersion() < 4)
     311         307 :     addLabelAddress(D, dwarf::DW_AT_high_pc, End);
     312             :   else
     313       91141 :     addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
     314       91448 : }
     315             : 
     316             : // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
     317             : // and DW_AT_high_pc attributes. If there are global variables in this
     318             : // scope then create and insert DIEs for these variables.
     319       43477 : DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
     320       43477 :   DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
     321             : 
     322       43477 :   attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
     323       43774 :   if (DD->useAppleExtensionAttributes() &&
     324         297 :       !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
     325             :           *DD->getCurrentFunction()))
     326         204 :     addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
     327             : 
     328             :   // Only include DW_AT_frame_base in full debug info
     329       43477 :   if (!includeMinimalInlineScopes()) {
     330       38941 :     const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo();
     331       38941 :     MachineLocation Location(RI->getFrameRegister(*Asm->MF));
     332       38941 :     if (RI->isPhysicalRegister(Location.getReg()))
     333       38941 :       addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
     334             :   }
     335             : 
     336             :   // Add name to the name table, we do this here because we're guaranteed
     337             :   // to have concrete versions of our DW_TAG_subprogram nodes.
     338       43477 :   DD->addSubprogramNames(SP, *SPDie);
     339             : 
     340       43477 :   return *SPDie;
     341             : }
     342             : 
     343             : // Construct a DIE for this scope.
     344      121977 : void DwarfCompileUnit::constructScopeDIE(
     345             :     LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
     346      121977 :   if (!Scope || !Scope->getScopeNode())
     347       20898 :     return;
     348             : 
     349             :   auto *DS = Scope->getScopeNode();
     350             : 
     351             :   assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
     352             :          "Only handle inlined subprograms here, use "
     353             :          "constructSubprogramScopeDIE for non-inlined "
     354             :          "subprograms");
     355             : 
     356             :   SmallVector<DIE *, 8> Children;
     357             : 
     358             :   // We try to create the scope DIE first, then the children DIEs. This will
     359             :   // avoid creating un-used children then removing them later when we find out
     360             :   // the scope DIE is null.
     361             :   DIE *ScopeDIE;
     362      243954 :   if (Scope->getParent() && isa<DISubprogram>(DS)) {
     363       98176 :     ScopeDIE = constructInlinedScopeDIE(Scope);
     364       98176 :     if (!ScopeDIE)
     365             :       return;
     366             :     // We create children when the scope DIE is not null.
     367       98176 :     createScopeChildrenDIE(Scope, Children);
     368             :   } else {
     369             :     // Early exit when we know the scope DIE is going to be null.
     370       23801 :     if (DD->isLexicalScopeDIENull(Scope))
     371       20898 :       return;
     372             : 
     373       23801 :     bool HasNonScopeChildren = false;
     374             : 
     375             :     // We create children here when we know the scope DIE is not going to be
     376             :     // null and the children will be added to the scope DIE.
     377       23801 :     createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);
     378             : 
     379             :     // If there are only other scopes as children, put them directly in the
     380             :     // parent instead, as this scope would serve no purpose.
     381       23801 :     if (!HasNonScopeChildren) {
     382       20898 :       FinalChildren.insert(FinalChildren.end(),
     383             :                            std::make_move_iterator(Children.begin()),
     384             :                            std::make_move_iterator(Children.end()));
     385       20898 :       return;
     386             :     }
     387        2903 :     ScopeDIE = constructLexicalScopeDIE(Scope);
     388             :     assert(ScopeDIE && "Scope DIE should not be null.");
     389             :   }
     390             : 
     391             :   // Add children
     392      265909 :   for (auto &I : Children)
     393       82415 :     ScopeDIE->addChild(std::move(I));
     394             : 
     395      101079 :   FinalChildren.push_back(std::move(ScopeDIE));
     396             : }
     397             : 
     398       55675 : void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
     399             :                                          SmallVector<RangeSpan, 2> Range) {
     400       55675 :   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
     401             : 
     402             :   // Emit offset in .debug_range as a relocatable label. emitDIE will handle
     403             :   // emitting it appropriately.
     404             :   const MCSymbol *RangeSectionSym =
     405       55675 :       TLOF.getDwarfRangesSection()->getBeginSymbol();
     406             : 
     407      222700 :   RangeSpanList List(Asm->createTempSymbol("debug_ranges"), std::move(Range));
     408             : 
     409             :   // Under fission, ranges are specified by constant offsets relative to the
     410             :   // CU's DW_AT_GNU_ranges_base.
     411       55675 :   if (isDwoUnit())
     412         133 :     addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
     413         133 :                     RangeSectionSym);
     414             :   else
     415       55542 :     addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
     416       55542 :                     RangeSectionSym);
     417             : 
     418             :   // Add the range list to the set of ranges to be emitted.
     419       55675 :   (Skeleton ? Skeleton : this)->CURangeLists.push_back(std::move(List));
     420       55675 : }
     421             : 
     422      103646 : void DwarfCompileUnit::attachRangesOrLowHighPC(
     423             :     DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
     424      103646 :   if (Ranges.size() == 1 || !DD->useRangesSection()) {
     425             :     const RangeSpan &Front = Ranges.front();
     426             :     const RangeSpan &Back = Ranges.back();
     427       47971 :     attachLowHighPC(Die, Front.getStart(), Back.getEnd());
     428             :   } else
     429      111350 :     addScopeRangeList(Die, std::move(Ranges));
     430      103646 : }
     431             : 
     432      100944 : void DwarfCompileUnit::attachRangesOrLowHighPC(
     433             :     DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
     434             :   SmallVector<RangeSpan, 2> List;
     435      100944 :   List.reserve(Ranges.size());
     436      536042 :   for (const InsnRange &R : Ranges)
     437      652647 :     List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
     438      435098 :                              DD->getLabelAfterInsn(R.second)));
     439      201888 :   attachRangesOrLowHighPC(Die, std::move(List));
     440      100944 : }
     441             : 
     442             : // This scope represents inlined body of a function. Construct DIE to
     443             : // represent this concrete inlined copy of the function.
     444       98176 : DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
     445             :   assert(Scope->getScopeNode());
     446       98176 :   auto *DS = Scope->getScopeNode();
     447       98176 :   auto *InlinedSP = getDISubprogram(DS);
     448             :   // Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
     449             :   // was inlined from another compile unit.
     450      196352 :   DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
     451             :   assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.");
     452             : 
     453       98176 :   auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
     454       98176 :   addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);
     455             : 
     456       98176 :   attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
     457             : 
     458             :   // Add the call site information to the DIE.
     459       98176 :   const DILocation *IA = Scope->getInlinedAt();
     460      196352 :   addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
     461       98176 :           getOrCreateSourceID(IA->getFile()));
     462      196352 :   addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
     463          10 :   if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
     464           8 :     addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
     465             :             IA->getDiscriminator());
     466             : 
     467             :   // Add name to the name table, we do this here because we're guaranteed
     468             :   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
     469       98176 :   DD->addSubprogramNames(InlinedSP, *ScopeDIE);
     470             : 
     471       98176 :   return ScopeDIE;
     472             : }
     473             : 
     474             : // Construct new DW_TAG_lexical_block for this scope and attach
     475             : // DW_AT_low_pc/DW_AT_high_pc labels.
     476        2903 : DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
     477        2903 :   if (DD->isLexicalScopeDIENull(Scope))
     478             :     return nullptr;
     479             : 
     480        2903 :   auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
     481        2903 :   if (Scope->isAbstractScope())
     482             :     return ScopeDIE;
     483             : 
     484        2768 :   attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());
     485             : 
     486        2768 :   return ScopeDIE;
     487             : }
     488             : 
     489             : /// constructVariableDIE - Construct a DIE for the given DbgVariable.
     490       92835 : DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
     491       92835 :   auto D = constructVariableDIEImpl(DV, Abstract);
     492             :   DV.setDIE(*D);
     493       92835 :   return D;
     494             : }
     495             : 
     496       92835 : DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
     497             :                                                 bool Abstract) {
     498             :   // Define variable debug information entry.
     499      185670 :   auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
     500       92835 :   insertDIE(DV.getVariable(), VariableDie);
     501             : 
     502       92835 :   if (Abstract) {
     503        7328 :     applyVariableAttributes(DV, *VariableDie);
     504        7328 :     return VariableDie;
     505             :   }
     506             : 
     507             :   // Add variable address.
     508             : 
     509       85507 :   unsigned Offset = DV.getDebugLocListIndex();
     510       85507 :   if (Offset != ~0U) {
     511       15449 :     addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
     512       15449 :     return VariableDie;
     513             :   }
     514             : 
     515             :   // Check if variable is described by a DBG_VALUE instruction.
     516       70058 :   if (const MachineInstr *DVInsn = DV.getMInsn()) {
     517             :     assert(DVInsn->getNumOperands() == 4);
     518        2160 :     if (DVInsn->getOperand(0).isReg()) {
     519         250 :       auto RegOp = DVInsn->getOperand(0);
     520         250 :       auto Op1 = DVInsn->getOperand(1);
     521             :       // If the second operand is an immediate, this is an indirect value.
     522             :       assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset");
     523             :       MachineLocation Location(RegOp.getReg(), Op1.isImm());
     524         250 :       addVariableAddress(DV, *VariableDie, Location);
     525         830 :     } else if (DVInsn->getOperand(0).isImm()) {
     526             :       // This variable is described by a single constant.
     527             :       // Check whether it has a DIExpression.
     528             :       auto *Expr = DV.getSingleExpression();
     529           8 :       if (Expr && Expr->getNumElements()) {
     530             :         DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     531           4 :         DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     532             :         // If there is an expression, emit raw unsigned bytes.
     533           4 :         DwarfExpr.addFragmentOffset(Expr);
     534           4 :         DwarfExpr.addUnsignedConstant(DVInsn->getOperand(0).getImm());
     535           4 :         DwarfExpr.addExpression(Expr);
     536           4 :         addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
     537             :       } else
     538         821 :         addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
     539           5 :     } else if (DVInsn->getOperand(0).isFPImm())
     540           4 :       addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
     541           1 :     else if (DVInsn->getOperand(0).isCImm())
     542           1 :       addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
     543             :                        DV.getType());
     544             : 
     545             :     return VariableDie;
     546             :   }
     547             : 
     548             :   // .. else use frame index.
     549       68978 :   if (!DV.hasFrameIndexExprs())
     550             :     return VariableDie;
     551             : 
     552             :   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     553       68431 :   DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     554      273730 :   for (auto &Fragment : DV.getFrameIndexExprs()) {
     555       68434 :     unsigned FrameReg = 0;
     556       68434 :     const DIExpression *Expr = Fragment.Expr;
     557       68434 :     const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
     558       68434 :     int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
     559       68434 :     DwarfExpr.addFragmentOffset(Expr);
     560             :     SmallVector<uint64_t, 8> Ops;
     561       68434 :     Ops.push_back(dwarf::DW_OP_plus_uconst);
     562       68434 :     Ops.push_back(Offset);
     563       68434 :     Ops.append(Expr->elements_begin(), Expr->elements_end());
     564             :     DIExpressionCursor Cursor(Ops);
     565             :     DwarfExpr.setMemoryLocationKind();
     566      136868 :     DwarfExpr.addMachineRegExpression(
     567       68434 :         *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg);
     568       68434 :     DwarfExpr.addExpression(std::move(Cursor));
     569             :   }
     570       68431 :   addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
     571             : 
     572             :   return VariableDie;
     573             : }
     574             : 
     575       92835 : DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
     576             :                                             const LexicalScope &Scope,
     577             :                                             DIE *&ObjectPointer) {
     578       92835 :   auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
     579       92835 :   if (DV.isObjectPointer())
     580       26321 :     ObjectPointer = Var;
     581       92835 :   return Var;
     582             : }
     583             : 
     584             : /// Return all DIVariables that appear in count: expressions.
     585       15866 : static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
     586             :   SmallVector<const DIVariable *, 2> Result;
     587       15866 :   auto *Array = dyn_cast<DICompositeType>(Var->getType());
     588        3030 :   if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
     589             :     return Result;
     590        1705 :   for (auto *El : Array->getElements()) {
     591             :     if (auto *Subrange = dyn_cast<DISubrange>(El)) {
     592         878 :       auto Count = Subrange->getCount();
     593          15 :       if (auto *Dependency = Count.dyn_cast<DIVariable *>())
     594          15 :         Result.push_back(Dependency);
     595             :     }
     596             :   }
     597             :   return Result;
     598             : }
     599             : 
     600             : /// Sort local variables so that variables appearing inside of helper
     601             : /// expressions come first.
     602             : static SmallVector<DbgVariable *, 8>
     603      182577 : sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
     604             :   SmallVector<DbgVariable *, 8> Result;
     605             :   SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
     606             :   // Map back from a DIVariable to its containing DbgVariable.
     607             :   SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar;
     608             :   // Set of DbgVariables in Result.
     609             :   SmallDenseSet<DbgVariable *, 8> Visited;
     610             :   // For cycle detection.
     611             :   SmallDenseSet<DbgVariable *, 8> Visiting;
     612             : 
     613             :   // Initialize the worklist and the DIVariable lookup table.
     614      198443 :   for (auto Var : reverse(Input)) {
     615       31732 :     DbgVar.insert({Var->getVariable(), Var});
     616       15866 :     WorkList.push_back({Var, 0});
     617             :   }
     618             : 
     619             :   // Perform a stable topological sort by doing a DFS.
     620      214324 :   while (!WorkList.empty()) {
     621       31747 :     auto Item = WorkList.back();
     622       31747 :     DbgVariable *Var = Item.getPointer();
     623             :     bool visitedAllDependencies = Item.getInt();
     624             :     WorkList.pop_back();
     625             : 
     626             :     // Dependency is in a different lexical scope or a global.
     627       31747 :     if (!Var)
     628       15884 :       continue;
     629             : 
     630             :     // Already handled.
     631          12 :     if (Visited.count(Var))
     632          12 :       continue;
     633             : 
     634             :     // Add to Result if all dependencies are visited.
     635       47598 :     if (visitedAllDependencies) {
     636             :       Visited.insert(Var);
     637       15866 :       Result.push_back(Var);
     638       15866 :       continue;
     639             :     }
     640             : 
     641             :     // Detect cycles.
     642             :     auto Res = Visiting.insert(Var);
     643       15866 :     if (!Res.second) {
     644             :       assert(false && "dependency cycle in local variables");
     645           0 :       return Result;
     646             :     }
     647             : 
     648             :     // Push dependencies and this node onto the worklist, so that this node is
     649             :     // visited again after all of its dependencies are handled.
     650       31732 :     WorkList.push_back({Var, 1});
     651       31762 :     for (auto *Dependency : dependencies(Var)) {
     652          15 :       auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
     653          30 :       WorkList.push_back({DbgVar[Dep], 0});
     654             :     }
     655             :   }
     656             :   return Result;
     657             : }
     658             : 
     659      182577 : DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
     660             :                                               SmallVectorImpl<DIE *> &Children,
     661             :                                               bool *HasNonScopeChildren) {
     662             :   assert(Children.empty());
     663      182577 :   DIE *ObjectPointer = nullptr;
     664             : 
     665             :   // Emit function arguments (order is significant).
     666      547731 :   auto Vars = DU->getScopeVariables().lookup(Scope);
     667      259546 :   for (auto &DV : Vars.Args)
     668       76969 :     Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));
     669             : 
     670             :   // Emit local variables.
     671      182577 :   auto Locals = sortLocalVars(Vars.Locals);
     672      214309 :   for (DbgVariable *DV : Locals)
     673       15866 :     Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));
     674             : 
     675             :   // Skip imported directives in gmlt-like data.
     676      182577 :   if (!includeMinimalInlineScopes()) {
     677             :     // There is no need to emit empty lexical block DIE.
     678      241207 :     for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
     679         304 :       Children.push_back(
     680         304 :           constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
     681             :   }
     682             : 
     683      182577 :   if (HasNonScopeChildren)
     684       23801 :     *HasNonScopeChildren = !Children.empty();
     685             : 
     686      426531 :   for (LexicalScope *LS : Scope->getChildren())
     687      121977 :     constructScopeDIE(LS, Children);
     688             : 
     689      365154 :   return ObjectPointer;
     690             : }
     691             : 
     692       43477 : void DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub, LexicalScope *Scope) {
     693       43477 :   DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
     694             : 
     695       43477 :   if (Scope) {
     696             :     assert(!Scope->getInlinedAt());
     697             :     assert(!Scope->isAbstractScope());
     698             :     // Collect lexical scope children first.
     699             :     // ObjectPointer might be a local (non-argument) local variable if it's a
     700             :     // block's synthetic this pointer.
     701       43421 :     if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
     702       19493 :       addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
     703             :   }
     704             : 
     705             :   // If this is a variadic function, add an unspecified parameter.
     706             :   DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
     707             : 
     708             :   // If we have a single element of null, it is a function that returns void.
     709             :   // If we have more than one elements and the last one is null, it is a
     710             :   // variadic function.
     711       78972 :   if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
     712          42 :       !includeMinimalInlineScopes())
     713             :     ScopeDIE.addChild(
     714          41 :         DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));
     715       43477 : }
     716             : 
     717       60600 : DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
     718             :                                                  DIE &ScopeDIE) {
     719             :   // We create children when the scope DIE is not null.
     720             :   SmallVector<DIE *, 8> Children;
     721       60600 :   DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);
     722             : 
     723             :   // Add children
     724      283902 :   for (auto &I : Children)
     725      111651 :     ScopeDIE.addChild(std::move(I));
     726             : 
     727       60600 :   return ObjectPointer;
     728             : }
     729             : 
     730       42510 : void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
     731             :     LexicalScope *Scope) {
     732       85020 :   DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
     733       42510 :   if (AbsDef)
     734             :     return;
     735             : 
     736       17179 :   auto *SP = cast<DISubprogram>(Scope->getScopeNode());
     737             : 
     738             :   DIE *ContextDIE;
     739             :   DwarfCompileUnit *ContextCU = this;
     740             : 
     741       17179 :   if (includeMinimalInlineScopes())
     742             :     ContextDIE = &getUnitDie();
     743             :   // Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
     744             :   // the important distinction that the debug node is not associated with the
     745             :   // DIE (since the debug node will be associated with the concrete DIE, if
     746             :   // any). It could be refactored to some common utility function.
     747             :   else if (auto *SPDecl = SP->getDeclaration()) {
     748             :     ContextDIE = &getUnitDie();
     749        2344 :     getOrCreateSubprogramDIE(SPDecl);
     750             :   } else {
     751        1470 :     ContextDIE = getOrCreateContextDIE(resolve(SP->getScope()));
     752             :     // The scope may be shared with a subprogram that has already been
     753             :     // constructed in another CU, in which case we need to construct this
     754             :     // subprogram in the same CU.
     755         735 :     ContextCU = DD->lookupCU(ContextDIE->getUnitDie());
     756             :   }
     757             : 
     758             :   // Passing null as the associated node because the abstract definition
     759             :   // shouldn't be found by lookup.
     760       17179 :   AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
     761       17179 :   ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);
     762             : 
     763       17179 :   if (!ContextCU->includeMinimalInlineScopes())
     764        3079 :     ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
     765       17179 :   if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
     766        1966 :     ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
     767             : }
     768             : 
     769      105472 : DIE *DwarfCompileUnit::constructImportedEntityDIE(
     770             :     const DIImportedEntity *Module) {
     771      105472 :   DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
     772      105472 :   insertDIE(Module, IMDie);
     773             :   DIE *EntityDie;
     774             :   auto *Entity = resolve(Module->getEntity());
     775             :   if (auto *NS = dyn_cast<DINamespace>(Entity))
     776         739 :     EntityDie = getOrCreateNameSpace(NS);
     777             :   else if (auto *M = dyn_cast<DIModule>(Entity))
     778           7 :     EntityDie = getOrCreateModule(M);
     779             :   else if (auto *SP = dyn_cast<DISubprogram>(Entity))
     780       87942 :     EntityDie = getOrCreateSubprogramDIE(SP);
     781             :   else if (auto *T = dyn_cast<DIType>(Entity))
     782       16444 :     EntityDie = getOrCreateTypeDIE(T);
     783             :   else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
     784         339 :     EntityDie = getOrCreateGlobalVariableDIE(GV, {});
     785             :   else
     786           1 :     EntityDie = getDIE(Entity);
     787             :   assert(EntityDie);
     788      105472 :   addSourceLine(*IMDie, Module->getLine(), Module->getFile());
     789      105472 :   addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
     790      105472 :   StringRef Name = Module->getName();
     791      105472 :   if (!Name.empty())
     792          39 :     addString(*IMDie, dwarf::DW_AT_name, Name);
     793             : 
     794      105472 :   return IMDie;
     795             : }
     796             : 
     797       51810 : void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
     798       51810 :   DIE *D = getDIE(SP);
     799       52060 :   if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
     800         250 :     if (D)
     801             :       // If this subprogram has an abstract definition, reference that
     802         245 :       addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
     803             :   } else {
     804             :     assert(D || includeMinimalInlineScopes());
     805       51560 :     if (D)
     806             :       // And attach the attributes
     807       43232 :       applySubprogramAttributesToDefinition(SP, *D);
     808             :   }
     809       51810 : }
     810             : 
     811       85507 : void DwarfCompileUnit::finishVariableDefinition(const DbgVariable &Var) {
     812       85507 :   DbgVariable *AbsVar = getExistingAbstractVariable(
     813      171014 :       InlinedVariable(Var.getVariable(), Var.getInlinedAt()));
     814       85507 :   auto *VariableDie = Var.getDIE();
     815       85507 :   if (AbsVar && AbsVar->getDIE()) {
     816       15932 :     addDIEEntry(*VariableDie, dwarf::DW_AT_abstract_origin,
     817             :                       *AbsVar->getDIE());
     818             :   } else
     819       69575 :     applyVariableAttributes(Var, *VariableDie);
     820       85507 : }
     821             : 
     822       85507 : DbgVariable *DwarfCompileUnit::getExistingAbstractVariable(InlinedVariable IV) {
     823             :   const DILocalVariable *Cleansed;
     824       85507 :   return getExistingAbstractVariable(IV, Cleansed);
     825             : }
     826             : 
     827             : // Find abstract variable, if any, associated with Var.
     828      184788 : DbgVariable *DwarfCompileUnit::getExistingAbstractVariable(
     829             :     InlinedVariable IV, const DILocalVariable *&Cleansed) {
     830             :   // More then one inlined variable corresponds to one abstract variable.
     831      184788 :   Cleansed = IV.first;
     832      184788 :   auto &AbstractVariables = getAbstractVariables();
     833      184788 :   auto I = AbstractVariables.find(Cleansed);
     834      184788 :   if (I != AbstractVariables.end())
     835       38200 :     return I->second.get();
     836             :   return nullptr;
     837             : }
     838             : 
     839        7328 : void DwarfCompileUnit::createAbstractVariable(const DILocalVariable *Var,
     840             :                                         LexicalScope *Scope) {
     841             :   assert(Scope && Scope->isAbstractScope());
     842        7328 :   auto AbsDbgVariable = llvm::make_unique<DbgVariable>(Var, /* IA */ nullptr);
     843       14656 :   DU->addScopeVariable(Scope, AbsDbgVariable.get());
     844       14656 :   getAbstractVariables()[Var] = std::move(AbsDbgVariable);
     845        7328 : }
     846             : 
     847        3868 : void DwarfCompileUnit::emitHeader(bool UseOffsets) {
     848             :   // Don't bother labeling the .dwo unit, as its offset isn't used.
     849        3868 :   if (!Skeleton && !DD->useSectionsAsReferences()) {
     850        6514 :     LabelBegin = Asm->createTempSymbol("cu_begin");
     851        6514 :     Asm->OutStreamer->EmitLabel(LabelBegin);
     852             :   }
     853             : 
     854        3868 :   dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
     855        3263 :                                 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
     856             :                                                       : dwarf::DW_UT_compile;
     857        3868 :   DwarfUnit::emitCommonHeader(UseOffsets, UT);
     858        3868 :   if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
     859           8 :     Asm->emitInt64(getDWOId());
     860        3868 : }
     861             : 
     862      148410 : bool DwarfCompileUnit::hasDwarfPubSections() const {
     863             :   // Opting in to GNU Pubnames/types overrides the default to ensure these are
     864             :   // generated for things like Gold's gdb_index generation.
     865      148410 :   if (CUNode->getGnuPubnames())
     866             :     return true;
     867             : 
     868      295175 :   return DD->tuneForGDB() && DD->usePubSections() &&
     869      146832 :          !includeMinimalInlineScopes();
     870             : }
     871             : 
     872             : /// addGlobalName - Add a new global name to the compile unit.
     873       68606 : void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
     874             :                                      const DIScope *Context) {
     875       68606 :   if (!hasDwarfPubSections())
     876       18968 :     return;
     877      148914 :   std::string FullName = getParentContextString(Context) + Name.str();
     878       99276 :   GlobalNames[FullName] = &Die;
     879             : }
     880             : 
     881           8 : void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name,
     882             :                                                 const DIScope *Context) {
     883           8 :   if (!hasDwarfPubSections())
     884           0 :     return;
     885          24 :   std::string FullName = getParentContextString(Context) + Name.str();
     886             :   // Insert, allowing the entry to remain as-is if it's already present
     887             :   // This way the CU-level type DIE is preferred over the "can't describe this
     888             :   // type as a unit offset because it's not really in the CU at all, it's only
     889             :   // in a type unit"
     890          16 :   GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
     891             : }
     892             : 
     893             : /// Add a new global type to the unit.
     894       73194 : void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
     895             :                                      const DIScope *Context) {
     896       73194 :   if (!hasDwarfPubSections())
     897         529 :     return;
     898      217995 :   std::string FullName = getParentContextString(Context) + Ty->getName().str();
     899      145330 :   GlobalTypes[FullName] = &Die;
     900             : }
     901             : 
     902          76 : void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
     903             :                                              const DIScope *Context) {
     904          76 :   if (!hasDwarfPubSections())
     905           0 :     return;
     906         228 :   std::string FullName = getParentContextString(Context) + Ty->getName().str();
     907             :   // Insert, allowing the entry to remain as-is if it's already present
     908             :   // This way the CU-level type DIE is preferred over the "can't describe this
     909             :   // type as a unit offset because it's not really in the CU at all, it's only
     910             :   // in a type unit"
     911         152 :   GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
     912             : }
     913             : 
     914             : /// addVariableAddress - Add DW_AT_location attribute for a
     915             : /// DbgVariable based on provided MachineLocation.
     916         250 : void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
     917             :                                           MachineLocation Location) {
     918             :   // addBlockByrefAddress is obsolete and will be removed soon.
     919             :   // The clang frontend always generates block byref variables with a
     920             :   // complex expression that encodes exactly what addBlockByrefAddress
     921             :   // would do.
     922             :   assert((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&
     923             :          "block byref variable without a complex expression");
     924         250 :   if (DV.hasComplexAddress())
     925          52 :     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
     926         198 :   else if (DV.isBlockByrefVariable())
     927           0 :     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
     928             :   else
     929         198 :     addAddress(Die, dwarf::DW_AT_location, Location);
     930         250 : }
     931             : 
     932             : /// Add an address attribute to a die based on the location provided.
     933       39139 : void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
     934             :                                   const MachineLocation &Location) {
     935       39139 :   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     936       39139 :   DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     937       39139 :   if (Location.isIndirect())
     938             :     DwarfExpr.setMemoryLocationKind();
     939             : 
     940             :   DIExpressionCursor Cursor({});
     941       39139 :   const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
     942       39139 :   if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
     943             :     return;
     944       39105 :   DwarfExpr.addExpression(std::move(Cursor));
     945             : 
     946             :   // Now attach the location information to the DIE.
     947       39105 :   addBlock(Die, Attribute, DwarfExpr.finalize());
     948             : }
     949             : 
     950             : /// Start with the address based on the location provided, and generate the
     951             : /// DWARF information necessary to find the actual variable given the extra
     952             : /// address information encoded in the DbgVariable, starting from the starting
     953             : /// location.  Add the DWARF information to the die.
     954          52 : void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
     955             :                                          dwarf::Attribute Attribute,
     956             :                                          const MachineLocation &Location) {
     957          52 :   DIELoc *Loc = new (DIEValueAllocator) DIELoc;
     958          52 :   DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
     959             :   const DIExpression *DIExpr = DV.getSingleExpression();
     960          52 :   DwarfExpr.addFragmentOffset(DIExpr);
     961          52 :   if (Location.isIndirect())
     962             :     DwarfExpr.setMemoryLocationKind();
     963             : 
     964             :   DIExpressionCursor Cursor(DIExpr);
     965          52 :   const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
     966          52 :   if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
     967             :     return;
     968          52 :   DwarfExpr.addExpression(std::move(Cursor));
     969             : 
     970             :   // Now attach the location information to the DIE.
     971          52 :   addBlock(Die, Attribute, DwarfExpr.finalize());
     972             : }
     973             : 
     974             : /// Add a Dwarf loclistptr attribute data and value.
     975       15449 : void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
     976             :                                        unsigned Index) {
     977       15449 :   dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
     978             :                                                 : dwarf::DW_FORM_data4;
     979       15449 :   Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
     980       15449 : }
     981             : 
     982       76903 : void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
     983             :                                                DIE &VariableDie) {
     984      153806 :   StringRef Name = Var.getName();
     985       76903 :   if (!Name.empty())
     986       74362 :     addString(VariableDie, dwarf::DW_AT_name, Name);
     987       76903 :   const auto *DIVar = Var.getVariable();
     988       76903 :   if (DIVar)
     989       76903 :     if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
     990          10 :       addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
     991             :               AlignInBytes);
     992             : 
     993       76903 :   addSourceLine(VariableDie, DIVar);
     994       76903 :   addType(VariableDie, Var.getType());
     995       76903 :   if (Var.isArtificial())
     996       21842 :     addFlag(VariableDie, dwarf::DW_AT_artificial);
     997       76903 : }
     998             : 
     999             : /// Add a Dwarf expression attribute data and value.
    1000          28 : void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
    1001             :                                const MCExpr *Expr) {
    1002          28 :   Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
    1003          28 : }
    1004             : 
    1005       60411 : void DwarfCompileUnit::applySubprogramAttributesToDefinition(
    1006             :     const DISubprogram *SP, DIE &SPDie) {
    1007             :   auto *SPDecl = SP->getDeclaration();
    1008             :   auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
    1009       60411 :   applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
    1010       60411 :   addGlobalName(SP->getName(), SPDie, Context);
    1011       60411 : }
    1012             : 
    1013     4821048 : bool DwarfCompileUnit::isDwoUnit() const {
    1014     4821048 :   return DD->useSplitDwarf() && Skeleton;
    1015             : }
    1016             : 
    1017      511174 : bool DwarfCompileUnit::includeMinimalInlineScopes() const {
    1018      846525 :   return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly ||
    1019      397148 :          (DD->useSplitDwarf() && !Skeleton);
    1020             : }

Generated by: LCOV version 1.13