/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h

Bug Summary

File:	include/llvm/CodeGen/DIE.h
Warning:	line 641, column 5 Forming reference to null pointer

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DwarfCompileUnit.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn350071/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/lib/CodeGen/AsmPrinter -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn350071=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-27-042839-1215-1 -x c++ /build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

→

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//===----------------------------------------------------------------------===//

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>

53using namespace llvm;

55DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
                                 AsmPrinter *A, DwarfDebug *DW,
                                 DwarfFile *DWU)
  : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID) {
insertDIE(Node, &getUnitDie());
MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
61}

63/// addLabelAddress - Add a dwarf label attribute data and value using
64/// DW_FORM_addr or DW_FORM_GNU_addr_index.
65void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                                     const MCSymbol *Label) {
// Don't use the address pool in non-fission or in the skeleton unit itself.
// FIXME: Once GDB supports this, it's probably worthwhile using the address
// pool from the skeleton - maybe even in non-fission (possibly fewer
// relocations by sharing them in the pool, but we have other ideas about how
// to reduce the number of relocations as well/instead).
if ((!DD->useSplitDwarf() || !Skeleton) && DD->getDwarfVersion() < 5)
8
←
Assuming the condition is true→
9
←
Assuming the condition is true→
10
←
Taking true branch→
  return addLocalLabelAddress(Die, Attribute, Label);
11
←
Calling 'DwarfCompileUnit::addLocalLabelAddress'→

if (Label)
  DD->addArangeLabel(SymbolCU(this, Label));

unsigned idx = DD->getAddressPool().getIndex(Label);
Die.addValue(DIEValueAllocator, Attribute,
             DD->getDwarfVersion() >= 5 ? dwarf::DW_FORM_addrx
                                        : dwarf::DW_FORM_GNU_addr_index,
             DIEInteger(idx));
83}

85void DwarfCompileUnit::addLocalLabelAddress(DIE &Die,
                                          dwarf::Attribute Attribute,
                                          const MCSymbol *Label) {
if (Label)
12
←
Taking true branch→
  DD->addArangeLabel(SymbolCU(this, Label));

if (Label)
13
←
Taking true branch→
  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
14
←
Calling 'DIEValueList::addValue'→
               DIELabel(Label));
else
  Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
               DIEInteger(0));
97}

99unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
// If we print assembly, we can't separate .file entries according to
// compile units. Thus all files will belong to the default compile unit.

// FIXME: add a better feature test than hasRawTextSupport. Even better,
// extend .file to support this.
unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
if (!File)
  return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID);
return Asm->OutStreamer->EmitDwarfFileDirective(
    0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
    File->getSource(), CUID);
111}

113DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
  const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
// Check for pre-existence.
if (DIE *Die = getDIE(GV))
  return Die;

assert(GV)((GV) ? static_cast<void> (0) : __assert_fail ("GV", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 119, __PRETTY_FUNCTION__));

auto *GVContext = GV->getScope();
auto *GTy = DD->resolve(GV->getType());

// Construct the context before querying for the existence of the DIE in
// case such construction creates the DIE.
DIE *ContextDIE = getOrCreateContextDIE(GVContext);

// Add to map.
DIE *VariableDIE = &createAndAddDIE(GV->getTag(), *ContextDIE, GV);
DIScope *DeclContext;
if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
  DeclContext = resolve(SDMDecl->getScope());
  assert(SDMDecl->isStaticMember() && "Expected static member decl")((SDMDecl->isStaticMember() && "Expected static member decl"
) ? static_cast<void> (0) : __assert_fail ("SDMDecl->isStaticMember() && \"Expected static member decl\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 133, __PRETTY_FUNCTION__));
  assert(GV->isDefinition())((GV->isDefinition()) ? static_cast<void> (0) : __assert_fail
 ("GV->isDefinition()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 134, __PRETTY_FUNCTION__));
  // We need the declaration DIE that is in the static member's class.
  DIE *VariableSpecDIE = getOrCreateStaticMemberDIE(SDMDecl);
  addDIEEntry(*VariableDIE, dwarf::DW_AT_specification, *VariableSpecDIE);
  // If the global variable's type is different from the one in the class
  // member type, assume that it's more specific and also emit it.
  if (GTy != DD->resolve(SDMDecl->getBaseType()))
    addType(*VariableDIE, GTy);
} else {
  DeclContext = GV->getScope();
  // Add name and type.
  addString(*VariableDIE, dwarf::DW_AT_name, GV->getDisplayName());
  addType(*VariableDIE, GTy);

  // Add scoping info.
  if (!GV->isLocalToUnit())
    addFlag(*VariableDIE, dwarf::DW_AT_external);

  // Add line number info.
  addSourceLine(*VariableDIE, GV);
}

if (!GV->isDefinition())
  addFlag(*VariableDIE, dwarf::DW_AT_declaration);
else
  addGlobalName(GV->getName(), *VariableDIE, DeclContext);

if (uint32_t AlignInBytes = GV->getAlignInBytes())
  addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
          AlignInBytes);

if (MDTuple *TP = GV->getTemplateParams())
  addTemplateParams(*VariableDIE, DINodeArray(TP));

// Add location.
bool addToAccelTable = false;
DIELoc *Loc = nullptr;
std::unique_ptr<DIEDwarfExpression> DwarfExpr;
for (const auto &GE : GlobalExprs) {
  const GlobalVariable *Global = GE.Var;
  const DIExpression *Expr = GE.Expr;

  // For compatibility with DWARF 3 and earlier,
  // DW_AT_location(DW_OP_constu, X, DW_OP_stack_value) becomes
  // DW_AT_const_value(X).
  if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {
    addToAccelTable = true;
    addConstantValue(*VariableDIE, /*Unsigned=*/true, Expr->getElement(1));
    break;
  }

  // We cannot describe the location of dllimport'd variables: the
  // computation of their address requires loads from the IAT.
  if (Global && Global->hasDLLImportStorageClass())
    continue;

  // Nothing to describe without address or constant.
  if (!Global && (!Expr || !Expr->isConstant()))
    continue;

  if (Global && Global->isThreadLocal() &&
      !Asm->getObjFileLowering().supportDebugThreadLocalLocation())
    continue;

  if (!Loc) {
    addToAccelTable = true;
    Loc = new (DIEValueAllocator) DIELoc;
    DwarfExpr = llvm::make_unique<DIEDwarfExpression>(*Asm, *this, *Loc);
  }

  if (Expr)
    DwarfExpr->addFragmentOffset(Expr);

  if (Global) {
    const MCSymbol *Sym = Asm->getSymbol(Global);
    if (Global->isThreadLocal()) {
      if (Asm->TM.useEmulatedTLS()) {
        // TODO: add debug info for emulated thread local mode.
      } else {
        // FIXME: Make this work with -gsplit-dwarf.
        unsigned PointerSize = Asm->getDataLayout().getPointerSize();
        assert((PointerSize == 4 || PointerSize == 8) &&(((PointerSize == 4 || PointerSize == 8) && "Add support for other sizes if necessary"
) ? static_cast<void> (0) : __assert_fail ("(PointerSize == 4 || PointerSize == 8) && \"Add support for other sizes if necessary\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 216, __PRETTY_FUNCTION__))
               "Add support for other sizes if necessary")(((PointerSize == 4 || PointerSize == 8) && "Add support for other sizes if necessary"
) ? static_cast<void> (0) : __assert_fail ("(PointerSize == 4 || PointerSize == 8) && \"Add support for other sizes if necessary\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 216, __PRETTY_FUNCTION__));
        // Based on GCC's support for TLS:
        if (!DD->useSplitDwarf()) {
          // 1) Start with a constNu of the appropriate pointer size
          addUInt(*Loc, dwarf::DW_FORM_data1,
                  PointerSize == 4 ? dwarf::DW_OP_const4u
                                   : dwarf::DW_OP_const8u);
          // 2) containing the (relocated) offset of the TLS variable
          //    within the module's TLS block.
          addExpr(*Loc, dwarf::DW_FORM_udata,
                  Asm->getObjFileLowering().getDebugThreadLocalSymbol(Sym));
        } else {
          addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_const_index);
          addUInt(*Loc, dwarf::DW_FORM_udata,
                  DD->getAddressPool().getIndex(Sym, /* TLS */ true));
        }
        // 3) followed by an OP to make the debugger do a TLS lookup.
        addUInt(*Loc, dwarf::DW_FORM_data1,
                DD->useGNUTLSOpcode() ? dwarf::DW_OP_GNU_push_tls_address
                                      : dwarf::DW_OP_form_tls_address);
      }
    } else {
      DD->addArangeLabel(SymbolCU(this, Sym));
      addOpAddress(*Loc, Sym);
    }
  }
  // Global variables attached to symbols are memory locations.
  // It would be better if this were unconditional, but malformed input that
  // mixes non-fragments and fragments for the same variable is too expensive
  // to detect in the verifier.
  if (DwarfExpr->isUnknownLocation())
    DwarfExpr->setMemoryLocationKind();
  DwarfExpr->addExpression(Expr);
}
if (Loc)
  addBlock(*VariableDIE, dwarf::DW_AT_location, DwarfExpr->finalize());

if (DD->useAllLinkageNames())
  addLinkageName(*VariableDIE, GV->getLinkageName());

if (addToAccelTable) {
  DD->addAccelName(*CUNode, GV->getName(), *VariableDIE);

  // If the linkage name is different than the name, go ahead and output
  // that as well into the name table.
  if (GV->getLinkageName() != "" && GV->getName() != GV->getLinkageName() &&
      DD->useAllLinkageNames())
    DD->addAccelName(*CUNode, GV->getLinkageName(), *VariableDIE);
}

return VariableDIE;
267}

269void DwarfCompileUnit::addRange(RangeSpan Range) {
bool SameAsPrevCU = this == DD->getPrevCU();
DD->setPrevCU(this);
// If we have no current ranges just add the range and return, otherwise,
// check the current section and CU against the previous section and CU we
// emitted into and the subprogram was contained within. If these are the
// same then extend our current range, otherwise add this as a new range.
if (CURanges.empty() || !SameAsPrevCU ||
    (&CURanges.back().getEnd()->getSection() !=
     &Range.getEnd()->getSection())) {
  CURanges.push_back(Range);
  DD->addSectionLabel(Range.getStart());
  return;
}

CURanges.back().setEnd(Range.getEnd());
285}

287void DwarfCompileUnit::initStmtList() {
if (CUNode->isDebugDirectivesOnly())
  return;

// Define start line table label for each Compile Unit.
MCSymbol *LineTableStartSym;
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
if (DD->useSectionsAsReferences()) {
  LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
} else {
  LineTableStartSym =
      Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
}

// DW_AT_stmt_list is a offset of line number information for this
// compile unit in debug_line section. For split dwarf this is
// left in the skeleton CU and so not included.
// The line table entries are not always emitted in assembly, so it
// is not okay to use line_table_start here.
StmtListValue =
    addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
                    TLOF.getDwarfLineSection()->getBeginSymbol());
309}

311void DwarfCompileUnit::applyStmtList(DIE &D) {
D.addValue(DIEValueAllocator, *StmtListValue);
313}

315void DwarfCompileUnit::attachLowHighPC(DIE &D, const MCSymbol *Begin,
                                     const MCSymbol *End) {
assert(Begin && "Begin label should not be null!")((Begin && "Begin label should not be null!") ? static_cast
<void> (0) : __assert_fail ("Begin && \"Begin label should not be null!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 317, __PRETTY_FUNCTION__));
assert(End && "End label should not be null!")((End && "End label should not be null!") ? static_cast
<void> (0) : __assert_fail ("End && \"End label should not be null!\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 318, __PRETTY_FUNCTION__));
assert(Begin->isDefined() && "Invalid starting label")((Begin->isDefined() && "Invalid starting label") ?
 static_cast<void> (0) : __assert_fail ("Begin->isDefined() && \"Invalid starting label\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 319, __PRETTY_FUNCTION__));
assert(End->isDefined() && "Invalid end label")((End->isDefined() && "Invalid end label") ? static_cast
<void> (0) : __assert_fail ("End->isDefined() && \"Invalid end label\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 320, __PRETTY_FUNCTION__));

addLabelAddress(D, dwarf::DW_AT_low_pc, Begin);
if (DD->getDwarfVersion() < 4)
  addLabelAddress(D, dwarf::DW_AT_high_pc, End);
else
  addLabelDelta(D, dwarf::DW_AT_high_pc, End, Begin);
327}

329// Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
330// and DW_AT_high_pc attributes. If there are global variables in this
331// scope then create and insert DIEs for these variables.
332DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());

attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
if (DD->useAppleExtensionAttributes() &&
    !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
        *DD->getCurrentFunction()))
  addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);

// Only include DW_AT_frame_base in full debug info
if (!includeMinimalInlineScopes()) {
  if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) {
    DIELoc *Loc = new (DIEValueAllocator) DIELoc;
    addUInt(*Loc, dwarf::DW_FORM_data1, dwarf::DW_OP_call_frame_cfa);
    addBlock(*SPDie, dwarf::DW_AT_frame_base, Loc);
  } else {
    const TargetRegisterInfo *RI = Asm->MF->getSubtarget().getRegisterInfo();
    MachineLocation Location(RI->getFrameRegister(*Asm->MF));
    if (RI->isPhysicalRegister(Location.getReg()))
      addAddress(*SPDie, dwarf::DW_AT_frame_base, Location);
  }
}

// Add name to the name table, we do this here because we're guaranteed
// to have concrete versions of our DW_TAG_subprogram nodes.
DD->addSubprogramNames(*CUNode, SP, *SPDie);

return *SPDie;
360}

362// Construct a DIE for this scope.
363void DwarfCompileUnit::constructScopeDIE(
  LexicalScope *Scope, SmallVectorImpl<DIE *> &FinalChildren) {
if (!Scope || !Scope->getScopeNode())
  return;

auto *DS = Scope->getScopeNode();

assert((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
 "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined "
 "subprograms") ? static_cast<void> (0) : __assert_fail
 ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 373, __PRETTY_FUNCTION__))
       "Only handle inlined subprograms here, use "(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
 "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined "
 "subprograms") ? static_cast<void> (0) : __assert_fail
 ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 373, __PRETTY_FUNCTION__))
       "constructSubprogramScopeDIE for non-inlined "(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
 "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined "
 "subprograms") ? static_cast<void> (0) : __assert_fail
 ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 373, __PRETTY_FUNCTION__))
       "subprograms")(((Scope->getInlinedAt() || !isa<DISubprogram>(DS)) &&
 "Only handle inlined subprograms here, use " "constructSubprogramScopeDIE for non-inlined "
 "subprograms") ? static_cast<void> (0) : __assert_fail
 ("(Scope->getInlinedAt() || !isa<DISubprogram>(DS)) && \"Only handle inlined subprograms here, use \" \"constructSubprogramScopeDIE for non-inlined \" \"subprograms\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 373, __PRETTY_FUNCTION__));

SmallVector<DIE *, 8> Children;

// We try to create the scope DIE first, then the children DIEs. This will
// avoid creating un-used children then removing them later when we find out
// the scope DIE is null.
DIE *ScopeDIE;
if (Scope->getParent() && isa<DISubprogram>(DS)) {
  ScopeDIE = constructInlinedScopeDIE(Scope);
  if (!ScopeDIE)
    return;
  // We create children when the scope DIE is not null.
  createScopeChildrenDIE(Scope, Children);
} else {
  // Early exit when we know the scope DIE is going to be null.
  if (DD->isLexicalScopeDIENull(Scope))
    return;

  bool HasNonScopeChildren = false;

  // We create children here when we know the scope DIE is not going to be
  // null and the children will be added to the scope DIE.
  createScopeChildrenDIE(Scope, Children, &HasNonScopeChildren);

  // If there are only other scopes as children, put them directly in the
  // parent instead, as this scope would serve no purpose.
  if (!HasNonScopeChildren) {
    FinalChildren.insert(FinalChildren.end(),
                         std::make_move_iterator(Children.begin()),
                         std::make_move_iterator(Children.end()));
    return;
  }
  ScopeDIE = constructLexicalScopeDIE(Scope);
  assert(ScopeDIE && "Scope DIE should not be null.")((ScopeDIE && "Scope DIE should not be null.") ? static_cast
<void> (0) : __assert_fail ("ScopeDIE && \"Scope DIE should not be null.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 407, __PRETTY_FUNCTION__));
}

// Add children
for (auto &I : Children)
  ScopeDIE->addChild(std::move(I));

FinalChildren.push_back(std::move(ScopeDIE));
415}

417void DwarfCompileUnit::addScopeRangeList(DIE &ScopeDIE,
                                       SmallVector<RangeSpan, 2> Range) {
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();

// Emit the offset into .debug_ranges or .debug_rnglists as a relocatable
// label. emitDIE() will handle emitting it appropriately.
const MCSymbol *RangeSectionSym =
    DD->getDwarfVersion() >= 5
        ? TLOF.getDwarfRnglistsSection()->getBeginSymbol()
        : TLOF.getDwarfRangesSection()->getBeginSymbol();

HasRangeLists = true;

// Add the range list to the set of ranges to be emitted.
auto IndexAndList =
    (DD->getDwarfVersion() < 5 && Skeleton ? Skeleton->DU : DU)
        ->addRange(*(Skeleton ? Skeleton : this), std::move(Range));

uint32_t Index = IndexAndList.first;
auto &List = *IndexAndList.second;

// Under fission, ranges are specified by constant offsets relative to the
// CU's DW_AT_GNU_ranges_base.
// FIXME: For DWARF v5, do not generate the DW_AT_ranges attribute under
// fission until we support the forms using the .debug_addr section
// (DW_RLE_startx_endx etc.).
if (DD->getDwarfVersion() >= 5)
  addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_rnglistx, Index);
else if (isDwoUnit())
  addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                  RangeSectionSym);
else
  addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                  RangeSectionSym);
451}

453void DwarfCompileUnit::attachRangesOrLowHighPC(
  DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
if (Ranges.size() == 1 || !DD->useRangesSection()) {
  const RangeSpan &Front = Ranges.front();
  const RangeSpan &Back = Ranges.back();
  attachLowHighPC(Die, Front.getStart(), Back.getEnd());
} else
  addScopeRangeList(Die, std::move(Ranges));
461}

463void DwarfCompileUnit::attachRangesOrLowHighPC(
  DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
SmallVector<RangeSpan, 2> List;
List.reserve(Ranges.size());
for (const InsnRange &R : Ranges)
  List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
                           DD->getLabelAfterInsn(R.second)));
attachRangesOrLowHighPC(Die, std::move(List));
471}

473// This scope represents inlined body of a function. Construct DIE to
474// represent this concrete inlined copy of the function.
475DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
assert(Scope->getScopeNode())((Scope->getScopeNode()) ? static_cast<void> (0) : __assert_fail
 ("Scope->getScopeNode()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 476, __PRETTY_FUNCTION__));
auto *DS = Scope->getScopeNode();
auto *InlinedSP = getDISubprogram(DS);
// Find the subprogram's DwarfCompileUnit in the SPMap in case the subprogram
// was inlined from another compile unit.
DIE *OriginDIE = getAbstractSPDies()[InlinedSP];
assert(OriginDIE && "Unable to find original DIE for an inlined subprogram.")((OriginDIE && "Unable to find original DIE for an inlined subprogram."
) ? static_cast<void> (0) : __assert_fail ("OriginDIE && \"Unable to find original DIE for an inlined subprogram.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 482, __PRETTY_FUNCTION__));

auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_inlined_subroutine);
addDIEEntry(*ScopeDIE, dwarf::DW_AT_abstract_origin, *OriginDIE);

attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());

// Add the call site information to the DIE.
const DILocation *IA = Scope->getInlinedAt();
addUInt(*ScopeDIE, dwarf::DW_AT_call_file, None,
        getOrCreateSourceID(IA->getFile()));
addUInt(*ScopeDIE, dwarf::DW_AT_call_line, None, IA->getLine());
if (IA->getDiscriminator() && DD->getDwarfVersion() >= 4)
  addUInt(*ScopeDIE, dwarf::DW_AT_GNU_discriminator, None,
          IA->getDiscriminator());

// Add name to the name table, we do this here because we're guaranteed
// to have concrete versions of our DW_TAG_inlined_subprogram nodes.
DD->addSubprogramNames(*CUNode, InlinedSP, *ScopeDIE);

return ScopeDIE;
503}

505// Construct new DW_TAG_lexical_block for this scope and attach
506// DW_AT_low_pc/DW_AT_high_pc labels.
507DIE *DwarfCompileUnit::constructLexicalScopeDIE(LexicalScope *Scope) {
if (DD->isLexicalScopeDIENull(Scope))
  return nullptr;

auto ScopeDIE = DIE::get(DIEValueAllocator, dwarf::DW_TAG_lexical_block);
if (Scope->isAbstractScope())
  return ScopeDIE;

attachRangesOrLowHighPC(*ScopeDIE, Scope->getRanges());

return ScopeDIE;
518}

520/// constructVariableDIE - Construct a DIE for the given DbgVariable.
521DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV, bool Abstract) {
auto D = constructVariableDIEImpl(DV, Abstract);
DV.setDIE(*D);
return D;
525}

527DIE *DwarfCompileUnit::constructLabelDIE(DbgLabel &DL,
                                       const LexicalScope &Scope) {
auto LabelDie = DIE::get(DIEValueAllocator, DL.getTag());
insertDIE(DL.getLabel(), LabelDie);
DL.setDIE(*LabelDie);

if (Scope.isAbstractScope())
  applyLabelAttributes(DL, *LabelDie);

return LabelDie;
537}

539DIE *DwarfCompileUnit::constructVariableDIEImpl(const DbgVariable &DV,
                                              bool Abstract) {
// Define variable debug information entry.
auto VariableDie = DIE::get(DIEValueAllocator, DV.getTag());
insertDIE(DV.getVariable(), VariableDie);

if (Abstract) {
  applyVariableAttributes(DV, *VariableDie);
  return VariableDie;
}

// Add variable address.

unsigned Offset = DV.getDebugLocListIndex();
if (Offset != ~0U) {
  addLocationList(*VariableDie, dwarf::DW_AT_location, Offset);
  return VariableDie;
}

// Check if variable is described by a DBG_VALUE instruction.
if (const MachineInstr *DVInsn = DV.getMInsn()) {
  assert(DVInsn->getNumOperands() == 4)((DVInsn->getNumOperands() == 4) ? static_cast<void>
 (0) : __assert_fail ("DVInsn->getNumOperands() == 4", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 560, __PRETTY_FUNCTION__));
  if (DVInsn->getOperand(0).isReg()) {
    auto RegOp = DVInsn->getOperand(0);
    auto Op1 = DVInsn->getOperand(1);
    // If the second operand is an immediate, this is an indirect value.
    assert((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset")(((!Op1.isImm() || (Op1.getImm() == 0)) && "unexpected offset"
) ? static_cast<void> (0) : __assert_fail ("(!Op1.isImm() || (Op1.getImm() == 0)) && \"unexpected offset\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 565, __PRETTY_FUNCTION__));
    MachineLocation Location(RegOp.getReg(), Op1.isImm());
    addVariableAddress(DV, *VariableDie, Location);
  } else if (DVInsn->getOperand(0).isImm()) {
    // This variable is described by a single constant.
    // Check whether it has a DIExpression.
    auto *Expr = DV.getSingleExpression();
    if (Expr && Expr->getNumElements()) {
      DIELoc *Loc = new (DIEValueAllocator) DIELoc;
      DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
      // If there is an expression, emit raw unsigned bytes.
      DwarfExpr.addFragmentOffset(Expr);
      DwarfExpr.addUnsignedConstant(DVInsn->getOperand(0).getImm());
      DwarfExpr.addExpression(Expr);
      addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());
    } else
      addConstantValue(*VariableDie, DVInsn->getOperand(0), DV.getType());
  } else if (DVInsn->getOperand(0).isFPImm())
    addConstantFPValue(*VariableDie, DVInsn->getOperand(0));
  else if (DVInsn->getOperand(0).isCImm())
    addConstantValue(*VariableDie, DVInsn->getOperand(0).getCImm(),
                     DV.getType());

  return VariableDie;
}

// .. else use frame index.
if (!DV.hasFrameIndexExprs())
  return VariableDie;

DIELoc *Loc = new (DIEValueAllocator) DIELoc;
DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
for (auto &Fragment : DV.getFrameIndexExprs()) {
  unsigned FrameReg = 0;
  const DIExpression *Expr = Fragment.Expr;
  const TargetFrameLowering *TFI = Asm->MF->getSubtarget().getFrameLowering();
  int Offset = TFI->getFrameIndexReference(*Asm->MF, Fragment.FI, FrameReg);
  DwarfExpr.addFragmentOffset(Expr);
  SmallVector<uint64_t, 8> Ops;
  Ops.push_back(dwarf::DW_OP_plus_uconst);
  Ops.push_back(Offset);
  Ops.append(Expr->elements_begin(), Expr->elements_end());
  DIExpressionCursor Cursor(Ops);
  DwarfExpr.setMemoryLocationKind();
  if (const MCSymbol *FrameSymbol = Asm->getFunctionFrameSymbol())
    addOpAddress(*Loc, FrameSymbol);
  else
    DwarfExpr.addMachineRegExpression(
        *Asm->MF->getSubtarget().getRegisterInfo(), Cursor, FrameReg);
  DwarfExpr.addExpression(std::move(Cursor));
}
addBlock(*VariableDie, dwarf::DW_AT_location, DwarfExpr.finalize());

return VariableDie;
619}

621DIE *DwarfCompileUnit::constructVariableDIE(DbgVariable &DV,
                                          const LexicalScope &Scope,
                                          DIE *&ObjectPointer) {
auto Var = constructVariableDIE(DV, Scope.isAbstractScope());
if (DV.isObjectPointer())
  ObjectPointer = Var;
return Var;
628}

630/// Return all DIVariables that appear in count: expressions.
631static SmallVector<const DIVariable *, 2> dependencies(DbgVariable *Var) {
SmallVector<const DIVariable *, 2> Result;
auto *Array = dyn_cast<DICompositeType>(Var->getType());
if (!Array || Array->getTag() != dwarf::DW_TAG_array_type)
  return Result;
for (auto *El : Array->getElements()) {
  if (auto *Subrange = dyn_cast<DISubrange>(El)) {
    auto Count = Subrange->getCount();
    if (auto *Dependency = Count.dyn_cast<DIVariable *>())
      Result.push_back(Dependency);
  }
}
return Result;
644}

646/// Sort local variables so that variables appearing inside of helper
647/// expressions come first.
648static SmallVector<DbgVariable *, 8>
649sortLocalVars(SmallVectorImpl<DbgVariable *> &Input) {
SmallVector<DbgVariable *, 8> Result;
SmallVector<PointerIntPair<DbgVariable *, 1>, 8> WorkList;
// Map back from a DIVariable to its containing DbgVariable.
SmallDenseMap<const DILocalVariable *, DbgVariable *> DbgVar;
// Set of DbgVariables in Result.
SmallDenseSet<DbgVariable *, 8> Visited;
// For cycle detection.
SmallDenseSet<DbgVariable *, 8> Visiting;

// Initialize the worklist and the DIVariable lookup table.
for (auto Var : reverse(Input)) {
  DbgVar.insert({Var->getVariable(), Var});
  WorkList.push_back({Var, 0});
}

// Perform a stable topological sort by doing a DFS.
while (!WorkList.empty()) {
  auto Item = WorkList.back();
  DbgVariable *Var = Item.getPointer();
  bool visitedAllDependencies = Item.getInt();
  WorkList.pop_back();

  // Dependency is in a different lexical scope or a global.
  if (!Var)
    continue;

  // Already handled.
  if (Visited.count(Var))
    continue;

  // Add to Result if all dependencies are visited.
  if (visitedAllDependencies) {
    Visited.insert(Var);
    Result.push_back(Var);
    continue;
  }

  // Detect cycles.
  auto Res = Visiting.insert(Var);
  if (!Res.second) {
    assert(false && "dependency cycle in local variables")((false && "dependency cycle in local variables") ? static_cast
<void> (0) : __assert_fail ("false && \"dependency cycle in local variables\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 690, __PRETTY_FUNCTION__));
    return Result;
  }

  // Push dependencies and this node onto the worklist, so that this node is
  // visited again after all of its dependencies are handled.
  WorkList.push_back({Var, 1});
  for (auto *Dependency : dependencies(Var)) {
    auto Dep = dyn_cast_or_null<const DILocalVariable>(Dependency);
    WorkList.push_back({DbgVar[Dep], 0});
  }
}
return Result;
703}

705DIE *DwarfCompileUnit::createScopeChildrenDIE(LexicalScope *Scope,
                                            SmallVectorImpl<DIE *> &Children,
                                            bool *HasNonScopeChildren) {
assert(Children.empty())((Children.empty()) ? static_cast<void> (0) : __assert_fail
 ("Children.empty()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 708, __PRETTY_FUNCTION__));
DIE *ObjectPointer = nullptr;

// Emit function arguments (order is significant).
auto Vars = DU->getScopeVariables().lookup(Scope);
for (auto &DV : Vars.Args)
  Children.push_back(constructVariableDIE(*DV.second, *Scope, ObjectPointer));

// Emit local variables.
auto Locals = sortLocalVars(Vars.Locals);
for (DbgVariable *DV : Locals)
  Children.push_back(constructVariableDIE(*DV, *Scope, ObjectPointer));

// Skip imported directives in gmlt-like data.
if (!includeMinimalInlineScopes()) {
  // There is no need to emit empty lexical block DIE.
  for (const auto *IE : ImportedEntities[Scope->getScopeNode()])
    Children.push_back(
        constructImportedEntityDIE(cast<DIImportedEntity>(IE)));
}

if (HasNonScopeChildren)
  *HasNonScopeChildren = !Children.empty();

for (DbgLabel *DL : DU->getScopeLabels().lookup(Scope))
  Children.push_back(constructLabelDIE(*DL, *Scope));

for (LexicalScope *LS : Scope->getChildren())
  constructScopeDIE(LS, Children);

return ObjectPointer;
739}

741DIE &DwarfCompileUnit::constructSubprogramScopeDIE(const DISubprogram *Sub,
                                                 LexicalScope *Scope) {
DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);

if (Scope) {
  assert(!Scope->getInlinedAt())((!Scope->getInlinedAt()) ? static_cast<void> (0) : __assert_fail
 ("!Scope->getInlinedAt()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 746, __PRETTY_FUNCTION__));
  assert(!Scope->isAbstractScope())((!Scope->isAbstractScope()) ? static_cast<void> (0)
 : __assert_fail ("!Scope->isAbstractScope()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 747, __PRETTY_FUNCTION__));
  // Collect lexical scope children first.
  // ObjectPointer might be a local (non-argument) local variable if it's a
  // block's synthetic this pointer.
  if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
    addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
}

// If this is a variadic function, add an unspecified parameter.
DITypeRefArray FnArgs = Sub->getType()->getTypeArray();

// If we have a single element of null, it is a function that returns void.
// If we have more than one elements and the last one is null, it is a
// variadic function.
if (FnArgs.size() > 1 && !FnArgs[FnArgs.size() - 1] &&
    !includeMinimalInlineScopes())
  ScopeDIE.addChild(
      DIE::get(DIEValueAllocator, dwarf::DW_TAG_unspecified_parameters));

return ScopeDIE;
767}

769DIE *DwarfCompileUnit::createAndAddScopeChildren(LexicalScope *Scope,
                                               DIE &ScopeDIE) {
// We create children when the scope DIE is not null.
SmallVector<DIE *, 8> Children;
DIE *ObjectPointer = createScopeChildrenDIE(Scope, Children);

// Add children
for (auto &I : Children)
  ScopeDIE.addChild(std::move(I));

return ObjectPointer;
780}

782void DwarfCompileUnit::constructAbstractSubprogramScopeDIE(
  LexicalScope *Scope) {
DIE *&AbsDef = getAbstractSPDies()[Scope->getScopeNode()];
if (AbsDef)
  return;

auto *SP = cast<DISubprogram>(Scope->getScopeNode());

DIE *ContextDIE;
DwarfCompileUnit *ContextCU = this;

if (includeMinimalInlineScopes())
  ContextDIE = &getUnitDie();
// Some of this is duplicated from DwarfUnit::getOrCreateSubprogramDIE, with
// the important distinction that the debug node is not associated with the
// DIE (since the debug node will be associated with the concrete DIE, if
// any). It could be refactored to some common utility function.
else if (auto *SPDecl = SP->getDeclaration()) {
  ContextDIE = &getUnitDie();
  getOrCreateSubprogramDIE(SPDecl);
} else {
  ContextDIE = getOrCreateContextDIE(resolve(SP->getScope()));
  // The scope may be shared with a subprogram that has already been
  // constructed in another CU, in which case we need to construct this
  // subprogram in the same CU.
  ContextCU = DD->lookupCU(ContextDIE->getUnitDie());
}

// Passing null as the associated node because the abstract definition
// shouldn't be found by lookup.
AbsDef = &ContextCU->createAndAddDIE(dwarf::DW_TAG_subprogram, *ContextDIE, nullptr);
ContextCU->applySubprogramAttributesToDefinition(SP, *AbsDef);

if (!ContextCU->includeMinimalInlineScopes())
  ContextCU->addUInt(*AbsDef, dwarf::DW_AT_inline, None, dwarf::DW_INL_inlined);
if (DIE *ObjectPointer = ContextCU->createAndAddScopeChildren(Scope, *AbsDef))
  ContextCU->addDIEEntry(*AbsDef, dwarf::DW_AT_object_pointer, *ObjectPointer);
819}

821DIE &DwarfCompileUnit::constructCallSiteEntryDIE(DIE &ScopeDIE,
                                               const DISubprogram &CalleeSP,
                                               bool IsTail,
                                               const MCExpr *PCOffset) {
// Insert a call site entry DIE within ScopeDIE.
DIE &CallSiteDIE =
    createAndAddDIE(dwarf::DW_TAG_call_site, ScopeDIE, nullptr);

// For the purposes of showing tail call frames in backtraces, a key piece of
// information is DW_AT_call_origin, a pointer to the callee DIE.
DIE *CalleeDIE = getOrCreateSubprogramDIE(&CalleeSP);
assert(CalleeDIE && "Could not create DIE for call site entry origin")((CalleeDIE && "Could not create DIE for call site entry origin"
) ? static_cast<void> (0) : __assert_fail ("CalleeDIE && \"Could not create DIE for call site entry origin\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 832, __PRETTY_FUNCTION__));
addDIEEntry(CallSiteDIE, dwarf::DW_AT_call_origin, *CalleeDIE);

if (IsTail) {
  // Attach DW_AT_call_tail_call to tail calls for standards compliance.
  addFlag(CallSiteDIE, dwarf::DW_AT_call_tail_call);
} else {
  // Attach the return PC to allow the debugger to disambiguate call paths
  // from one function to another.
  assert(PCOffset && "Missing return PC information for a call")((PCOffset && "Missing return PC information for a call"
) ? static_cast<void> (0) : __assert_fail ("PCOffset && \"Missing return PC information for a call\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 841, __PRETTY_FUNCTION__));
  addAddressExpr(CallSiteDIE, dwarf::DW_AT_call_return_pc, PCOffset);
}
return CallSiteDIE;
845}

847DIE *DwarfCompileUnit::constructImportedEntityDIE(
  const DIImportedEntity *Module) {
DIE *IMDie = DIE::get(DIEValueAllocator, (dwarf::Tag)Module->getTag());
insertDIE(Module, IMDie);
DIE *EntityDie;
auto *Entity = resolve(Module->getEntity());
if (auto *NS = dyn_cast<DINamespace>(Entity))
  EntityDie = getOrCreateNameSpace(NS);
else if (auto *M = dyn_cast<DIModule>(Entity))
  EntityDie = getOrCreateModule(M);
else if (auto *SP = dyn_cast<DISubprogram>(Entity))
  EntityDie = getOrCreateSubprogramDIE(SP);
else if (auto *T = dyn_cast<DIType>(Entity))
  EntityDie = getOrCreateTypeDIE(T);
else if (auto *GV = dyn_cast<DIGlobalVariable>(Entity))
  EntityDie = getOrCreateGlobalVariableDIE(GV, {});
else
  EntityDie = getDIE(Entity);
assert(EntityDie)((EntityDie) ? static_cast<void> (0) : __assert_fail ("EntityDie"
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 865, __PRETTY_FUNCTION__));
addSourceLine(*IMDie, Module->getLine(), Module->getFile());
addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
StringRef Name = Module->getName();
if (!Name.empty())
  addString(*IMDie, dwarf::DW_AT_name, Name);

return IMDie;
873}

875void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
DIE *D = getDIE(SP);
if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
  if (D)
    // If this subprogram has an abstract definition, reference that
    addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
} else {
  assert(D || includeMinimalInlineScopes())((D || includeMinimalInlineScopes()) ? static_cast<void>
 (0) : __assert_fail ("D || includeMinimalInlineScopes()", "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 882, __PRETTY_FUNCTION__));
  if (D)
    // And attach the attributes
    applySubprogramAttributesToDefinition(SP, *D);
}
887}

889void DwarfCompileUnit::finishEntityDefinition(const DbgEntity *Entity) {
DbgEntity *AbsEntity = getExistingAbstractEntity(Entity->getEntity());

auto *Die = Entity->getDIE();
/// Label may be used to generate DW_AT_low_pc, so put it outside
/// if/else block.
const DbgLabel *Label = nullptr;
if (AbsEntity && AbsEntity->getDIE()) {
1
Assuming 'AbsEntity' is non-null→
2
←
Assuming the condition is true→
3
←
Taking true branch→
  addDIEEntry(*Die, dwarf::DW_AT_abstract_origin, *AbsEntity->getDIE());
  Label = dyn_cast<const DbgLabel>(Entity);
} else {
  if (const DbgVariable *Var = dyn_cast<const DbgVariable>(Entity))
    applyVariableAttributes(*Var, *Die);
  else if ((Label = dyn_cast<const DbgLabel>(Entity)))
    applyLabelAttributes(*Label, *Die);
  else
    llvm_unreachable("DbgEntity must be DbgVariable or DbgLabel.")::llvm::llvm_unreachable_internal("DbgEntity must be DbgVariable or DbgLabel."
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 905);
}

if (Label)
4
←
Taking true branch→
  if (const auto *Sym = Label->getSymbol())
5
←
Assuming 'Sym' is non-null→
6
←
Taking true branch→
    addLabelAddress(*Die, dwarf::DW_AT_low_pc, Sym);
7
←
Calling 'DwarfCompileUnit::addLabelAddress'→
911}

913DbgEntity *DwarfCompileUnit::getExistingAbstractEntity(const DINode *Node) {
auto &AbstractEntities = getAbstractEntities();
auto I = AbstractEntities.find(Node);
if (I != AbstractEntities.end())
  return I->second.get();
return nullptr;
919}

921void DwarfCompileUnit::createAbstractEntity(const DINode *Node,
                                          LexicalScope *Scope) {
assert(Scope && Scope->isAbstractScope())((Scope && Scope->isAbstractScope()) ? static_cast
<void> (0) : __assert_fail ("Scope && Scope->isAbstractScope()"
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 923, __PRETTY_FUNCTION__));
auto &Entity = getAbstractEntities()[Node];
if (isa<const DILocalVariable>(Node)) {
  Entity = llvm::make_unique<DbgVariable>(
                      cast<const DILocalVariable>(Node), nullptr /* IA */);;
  DU->addScopeVariable(Scope, cast<DbgVariable>(Entity.get()));
} else if (isa<const DILabel>(Node)) {
  Entity = llvm::make_unique<DbgLabel>(
                      cast<const DILabel>(Node), nullptr /* IA */);
  DU->addScopeLabel(Scope, cast<DbgLabel>(Entity.get()));
}
934}

936void DwarfCompileUnit::emitHeader(bool UseOffsets) {
// Don't bother labeling the .dwo unit, as its offset isn't used.
if (!Skeleton && !DD->useSectionsAsReferences()) {
  LabelBegin = Asm->createTempSymbol("cu_begin");
  Asm->OutStreamer->EmitLabel(LabelBegin);
}

dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
                              : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
                                                    : dwarf::DW_UT_compile;
DwarfUnit::emitCommonHeader(UseOffsets, UT);
if (DD->getDwarfVersion() >= 5 && UT != dwarf::DW_UT_compile)
  Asm->emitInt64(getDWOId());
949}

951bool DwarfCompileUnit::hasDwarfPubSections() const {
switch (CUNode->getNameTableKind()) {
case DICompileUnit::DebugNameTableKind::None:
  return false;
  // Opting in to GNU Pubnames/types overrides the default to ensure these are
  // generated for things like Gold's gdb_index generation.
case DICompileUnit::DebugNameTableKind::GNU:
  return true;
case DICompileUnit::DebugNameTableKind::Default:
  return DD->tuneForGDB() && !includeMinimalInlineScopes() &&
         !CUNode->isDebugDirectivesOnly();
}
llvm_unreachable("Unhandled DICompileUnit::DebugNameTableKind enum")::llvm::llvm_unreachable_internal("Unhandled DICompileUnit::DebugNameTableKind enum"
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 963);
964}

966/// addGlobalName - Add a new global name to the compile unit.
967void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
                                   const DIScope *Context) {
if (!hasDwarfPubSections())
  return;
std::string FullName = getParentContextString(Context) + Name.str();
GlobalNames[FullName] = &Die;
973}

975void DwarfCompileUnit::addGlobalNameForTypeUnit(StringRef Name,
                                              const DIScope *Context) {
if (!hasDwarfPubSections())
  return;
std::string FullName = getParentContextString(Context) + Name.str();
// Insert, allowing the entry to remain as-is if it's already present
// This way the CU-level type DIE is preferred over the "can't describe this
// type as a unit offset because it's not really in the CU at all, it's only
// in a type unit"
GlobalNames.insert(std::make_pair(std::move(FullName), &getUnitDie()));
985}

987/// Add a new global type to the unit.
988void DwarfCompileUnit::addGlobalType(const DIType *Ty, const DIE &Die,
                                   const DIScope *Context) {
if (!hasDwarfPubSections())
  return;
std::string FullName = getParentContextString(Context) + Ty->getName().str();
GlobalTypes[FullName] = &Die;
994}

996void DwarfCompileUnit::addGlobalTypeUnitType(const DIType *Ty,
                                           const DIScope *Context) {
if (!hasDwarfPubSections())
  return;
std::string FullName = getParentContextString(Context) + Ty->getName().str();
// Insert, allowing the entry to remain as-is if it's already present
// This way the CU-level type DIE is preferred over the "can't describe this
// type as a unit offset because it's not really in the CU at all, it's only
// in a type unit"
GlobalTypes.insert(std::make_pair(std::move(FullName), &getUnitDie()));
1006}

1008/// addVariableAddress - Add DW_AT_location attribute for a
1009/// DbgVariable based on provided MachineLocation.
1010void DwarfCompileUnit::addVariableAddress(const DbgVariable &DV, DIE &Die,
                                        MachineLocation Location) {
// addBlockByrefAddress is obsolete and will be removed soon.
// The clang frontend always generates block byref variables with a
// complex expression that encodes exactly what addBlockByrefAddress
// would do.
assert((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&(((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&
 "block byref variable without a complex expression") ? static_cast
<void> (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 1017, __PRETTY_FUNCTION__))
       "block byref variable without a complex expression")(((!DV.isBlockByrefVariable() || DV.hasComplexAddress()) &&
 "block byref variable without a complex expression") ? static_cast
<void> (0) : __assert_fail ("(!DV.isBlockByrefVariable() || DV.hasComplexAddress()) && \"block byref variable without a complex expression\""
, "/build/llvm-toolchain-snapshot-8~svn350071/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp"
, 1017, __PRETTY_FUNCTION__));
if (DV.hasComplexAddress())
  addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
else
  addAddress(Die, dwarf::DW_AT_location, Location);
1022}

1024/// Add an address attribute to a die based on the location provided.
1025void DwarfCompileUnit::addAddress(DIE &Die, dwarf::Attribute Attribute,
                                const MachineLocation &Location) {
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
if (Location.isIndirect())
  DwarfExpr.setMemoryLocationKind();

DIExpressionCursor Cursor({});
const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
  return;
DwarfExpr.addExpression(std::move(Cursor));

// Now attach the location information to the DIE.
addBlock(Die, Attribute, DwarfExpr.finalize());
1040}

1042/// Start with the address based on the location provided, and generate the
1043/// DWARF information necessary to find the actual variable given the extra
1044/// address information encoded in the DbgVariable, starting from the starting
1045/// location.  Add the DWARF information to the die.
1046void DwarfCompileUnit::addComplexAddress(const DbgVariable &DV, DIE &Die,
                                       dwarf::Attribute Attribute,
                                       const MachineLocation &Location) {
DIELoc *Loc = new (DIEValueAllocator) DIELoc;
DIEDwarfExpression DwarfExpr(*Asm, *this, *Loc);
const DIExpression *DIExpr = DV.getSingleExpression();
DwarfExpr.addFragmentOffset(DIExpr);
if (Location.isIndirect())
  DwarfExpr.setMemoryLocationKind();

DIExpressionCursor Cursor(DIExpr);
const TargetRegisterInfo &TRI = *Asm->MF->getSubtarget().getRegisterInfo();
if (!DwarfExpr.addMachineRegExpression(TRI, Cursor, Location.getReg()))
  return;
DwarfExpr.addExpression(std::move(Cursor));

// Now attach the location information to the DIE.
addBlock(Die, Attribute, DwarfExpr.finalize());
1064}

1066/// Add a Dwarf loclistptr attribute data and value.
1067void DwarfCompileUnit::addLocationList(DIE &Die, dwarf::Attribute Attribute,
                                     unsigned Index) {
dwarf::Form Form = DD->getDwarfVersion() >= 4 ? dwarf::DW_FORM_sec_offset
                                              : dwarf::DW_FORM_data4;
Die.addValue(DIEValueAllocator, Attribute, Form, DIELocList(Index));
1072}

1074void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
                                             DIE &VariableDie) {
StringRef Name = Var.getName();
if (!Name.empty())
  addString(VariableDie, dwarf::DW_AT_name, Name);
const auto *DIVar = Var.getVariable();
if (DIVar)
  if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
    addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
            AlignInBytes);

addSourceLine(VariableDie, DIVar);
addType(VariableDie, Var.getType());
if (Var.isArtificial())
  addFlag(VariableDie, dwarf::DW_AT_artificial);
1089}

1091void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label,
                                          DIE &LabelDie) {
StringRef Name = Label.getName();
if (!Name.empty())
  addString(LabelDie, dwarf::DW_AT_name, Name);
const auto *DILabel = Label.getLabel();
addSourceLine(LabelDie, DILabel);
1098}

1100/// Add a Dwarf expression attribute data and value.
1101void DwarfCompileUnit::addExpr(DIELoc &Die, dwarf::Form Form,
                             const MCExpr *Expr) {
Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, Form, DIEExpr(Expr));
1104}

1106void DwarfCompileUnit::addAddressExpr(DIE &Die, dwarf::Attribute Attribute,
                                    const MCExpr *Expr) {
Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_addr,
             DIEExpr(Expr));
1110}

1112void DwarfCompileUnit::applySubprogramAttributesToDefinition(
  const DISubprogram *SP, DIE &SPDie) {
auto *SPDecl = SP->getDeclaration();
auto *Context = resolve(SPDecl ? SPDecl->getScope() : SP->getScope());
applySubprogramAttributes(SP, SPDie, includeMinimalInlineScopes());
addGlobalName(SP->getName(), SPDie, Context);
1118}

1120bool DwarfCompileUnit::isDwoUnit() const {
return DD->useSplitDwarf() && Skeleton;
1122}

1124bool DwarfCompileUnit::includeMinimalInlineScopes() const {
return getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly ||
       (DD->useSplitDwarf() && !Skeleton);
1127}

1129void DwarfCompileUnit::addAddrTableBase() {
const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
MCSymbol *Label = DD->getAddressPool().getLabel();
addSectionLabel(getUnitDie(),
                getDwarfVersion() >= 5 ? dwarf::DW_AT_addr_base
                                       : dwarf::DW_AT_GNU_addr_base,
                Label, TLOF.getDwarfAddrSection()->getBeginSymbol());
1136}

←

/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h

1//===- lib/CodeGen/DIE.h - DWARF Info Entries -------------------*- C++ -*-===//
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// Data structures for DWARF info entries.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
15#define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H

17#include "llvm/ADT/FoldingSet.h"
18#include "llvm/ADT/PointerIntPair.h"
19#include "llvm/ADT/PointerUnion.h"
20#include "llvm/ADT/SmallVector.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/ADT/iterator.h"
23#include "llvm/ADT/iterator_range.h"
24#include "llvm/BinaryFormat/Dwarf.h"
25#include "llvm/CodeGen/DwarfStringPoolEntry.h"
26#include "llvm/Support/AlignOf.h"
27#include "llvm/Support/Allocator.h"
28#include <cassert>
29#include <cstddef>
30#include <cstdint>
31#include <iterator>
32#include <new>
33#include <type_traits>
34#include <utility>
35#include <vector>

37namespace llvm {

39class AsmPrinter;
40class DIE;
41class DIEUnit;
42class MCExpr;
43class MCSection;
44class MCSymbol;
45class raw_ostream;

47//===--------------------------------------------------------------------===//
48/// Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation.
49class DIEAbbrevData {
/// Dwarf attribute code.
dwarf::Attribute Attribute;

/// Dwarf form code.
dwarf::Form Form;

/// Dwarf attribute value for DW_FORM_implicit_const
int64_t Value = 0;

59public:
DIEAbbrevData(dwarf::Attribute A, dwarf::Form F)
    : Attribute(A), Form(F) {}
DIEAbbrevData(dwarf::Attribute A, int64_t V)
    : Attribute(A), Form(dwarf::DW_FORM_implicit_const), Value(V) {}

/// Accessors.
/// @{
dwarf::Attribute getAttribute() const { return Attribute; }
dwarf::Form getForm() const { return Form; }
int64_t getValue() const { return Value; }
/// @}

/// Used to gather unique data for the abbreviation folding set.
void Profile(FoldingSetNodeID &ID) const;
74};

76//===--------------------------------------------------------------------===//
77/// Dwarf abbreviation, describes the organization of a debug information
78/// object.
79class DIEAbbrev : public FoldingSetNode {
/// Unique number for node.
unsigned Number;

/// Dwarf tag code.
dwarf::Tag Tag;

/// Whether or not this node has children.
///
/// This cheats a bit in all of the uses since the values in the standard
/// are 0 and 1 for no children and children respectively.
bool Children;

/// Raw data bytes for abbreviation.
SmallVector<DIEAbbrevData, 12> Data;

95public:
DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}

/// Accessors.
/// @{
dwarf::Tag getTag() const { return Tag; }
unsigned getNumber() const { return Number; }
bool hasChildren() const { return Children; }
const SmallVectorImpl<DIEAbbrevData> &getData() const { return Data; }
void setChildrenFlag(bool hasChild) { Children = hasChild; }
void setNumber(unsigned N) { Number = N; }
/// @}

/// Adds another set of attribute information to the abbreviation.
void AddAttribute(dwarf::Attribute Attribute, dwarf::Form Form) {
  Data.push_back(DIEAbbrevData(Attribute, Form));
}

/// Adds attribute with DW_FORM_implicit_const value
void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {
  Data.push_back(DIEAbbrevData(Attribute, Value));
}

/// Used to gather unique data for the abbreviation folding set.
void Profile(FoldingSetNodeID &ID) const;

/// Print the abbreviation using the specified asm printer.
void Emit(const AsmPrinter *AP) const;

void print(raw_ostream &O) const;
void dump() const;
126};

128//===--------------------------------------------------------------------===//
129/// Helps unique DIEAbbrev objects and assigns abbreviation numbers.
130///
131/// This class will unique the DIE abbreviations for a llvm::DIE object and
132/// assign a unique abbreviation number to each unique DIEAbbrev object it
133/// finds. The resulting collection of DIEAbbrev objects can then be emitted
134/// into the .debug_abbrev section.
135class DIEAbbrevSet {
/// The bump allocator to use when creating DIEAbbrev objects in the uniqued
/// storage container.
BumpPtrAllocator &Alloc;
/// FoldingSet that uniques the abbreviations.
FoldingSet<DIEAbbrev> AbbreviationsSet;
/// A list of all the unique abbreviations in use.
std::vector<DIEAbbrev *> Abbreviations;

144public:
DIEAbbrevSet(BumpPtrAllocator &A) : Alloc(A) {}
~DIEAbbrevSet();

/// Generate the abbreviation declaration for a DIE and return a pointer to
/// the generated abbreviation.
///
/// \param Die the debug info entry to generate the abbreviation for.
/// \returns A reference to the uniqued abbreviation declaration that is
/// owned by this class.
DIEAbbrev &uniqueAbbreviation(DIE &Die);

/// Print all abbreviations using the specified asm printer.
void Emit(const AsmPrinter *AP, MCSection *Section) const;
158};

160//===--------------------------------------------------------------------===//
161/// An integer value DIE.
162///
163class DIEInteger {
uint64_t Integer;

166public:
explicit DIEInteger(uint64_t I) : Integer(I) {}

/// Choose the best form for integer.
static dwarf::Form BestForm(bool IsSigned, uint64_t Int) {
  if (IsSigned) {
    const int64_t SignedInt = Int;
    if ((char)Int == SignedInt)
      return dwarf::DW_FORM_data1;
    if ((short)Int == SignedInt)
      return dwarf::DW_FORM_data2;
    if ((int)Int == SignedInt)
      return dwarf::DW_FORM_data4;
  } else {
    if ((unsigned char)Int == Int)
      return dwarf::DW_FORM_data1;
    if ((unsigned short)Int == Int)
      return dwarf::DW_FORM_data2;
    if ((unsigned int)Int == Int)
      return dwarf::DW_FORM_data4;
  }
  return dwarf::DW_FORM_data8;
}

uint64_t getValue() const { return Integer; }
void setValue(uint64_t Val) { Integer = Val; }

void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
197};

199//===--------------------------------------------------------------------===//
200/// An expression DIE.
201class DIEExpr {
const MCExpr *Expr;

204public:
explicit DIEExpr(const MCExpr *E) : Expr(E) {}

/// Get MCExpr.
const MCExpr *getValue() const { return Expr; }

void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
214};

216//===--------------------------------------------------------------------===//
217/// A label DIE.
218class DIELabel {
const MCSymbol *Label;

221public:
explicit DIELabel(const MCSymbol *L) : Label(L) {}

/// Get MCSymbol.
const MCSymbol *getValue() const { return Label; }

void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
231};

233//===--------------------------------------------------------------------===//
234/// A simple label difference DIE.
235///
236class DIEDelta {
const MCSymbol *LabelHi;
const MCSymbol *LabelLo;

240public:
DIEDelta(const MCSymbol *Hi, const MCSymbol *Lo) : LabelHi(Hi), LabelLo(Lo) {}

void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
247};

249//===--------------------------------------------------------------------===//
250/// A container for string pool string values.
251///
252/// This class is used with the DW_FORM_strp and DW_FORM_GNU_str_index forms.
253class DIEString {
DwarfStringPoolEntryRef S;

256public:
DIEString(DwarfStringPoolEntryRef S) : S(S) {}

/// Grab the string out of the object.
StringRef getString() const { return S.getString(); }

void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
266};

268//===--------------------------------------------------------------------===//
269/// A container for inline string values.
270///
271/// This class is used with the DW_FORM_string form.
272class DIEInlineString {
StringRef S;

275public:
template <typename Allocator>
explicit DIEInlineString(StringRef Str, Allocator &A) : S(Str.copy(A)) {}

~DIEInlineString() = default;

/// Grab the string out of the object.
StringRef getString() const { return S; }

void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
288};

290//===--------------------------------------------------------------------===//
291/// A pointer to another debug information entry.  An instance of this class can
292/// also be used as a proxy for a debug information entry not yet defined
293/// (ie. types.)
294class DIEEntry {
DIE *Entry;

297public:
DIEEntry() = delete;
explicit DIEEntry(DIE &E) : Entry(&E) {}

DIE &getEntry() const { return *Entry; }

void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
307};

309//===--------------------------------------------------------------------===//
310/// Represents a pointer to a location list in the debug_loc
311/// section.
312class DIELocList {
/// Index into the .debug_loc vector.
size_t Index;

316public:
DIELocList(size_t I) : Index(I) {}

/// Grab the current index out.
size_t getValue() const { return Index; }

void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
326};

328//===--------------------------------------------------------------------===//
329/// A debug information entry value. Some of these roughly correlate
330/// to DWARF attribute classes.
331class DIEBlock;
332class DIELoc;
333class DIEValue {
334public:
enum Type {
  isNone,
337#define HANDLE_DIEVALUE(T) is##T,
338#include "llvm/CodeGen/DIEValue.def"
};

341private:
/// Type of data stored in the value.
Type Ty = isNone;
dwarf::Attribute Attribute = (dwarf::Attribute)0;
dwarf::Form Form = (dwarf::Form)0;

/// Storage for the value.
///
/// All values that aren't standard layout (or are larger than 8 bytes)
/// should be stored by reference instead of by value.
using ValTy = AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,
                                    DIEDelta *, DIEEntry, DIEBlock *,
                                    DIELoc *, DIELocList>;

static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||
                  sizeof(ValTy) <= sizeof(void *),
              "Expected all large types to be stored via pointer");

/// Underlying stored value.
ValTy Val;

template <class T> void construct(T V) {
  static_assert(std::is_standard_layout<T>::value ||
                    std::is_pointer<T>::value,
                "Expected standard layout or pointer");
  new (reinterpret_cast<void *>(Val.buffer)) T(V);
}

template <class T> T *get() { return reinterpret_cast<T *>(Val.buffer); }
template <class T> const T *get() const {
  return reinterpret_cast<const T *>(Val.buffer);
}
template <class T> void destruct() { get<T>()->~T(); }

/// Destroy the underlying value.
///
/// This should get optimized down to a no-op.  We could skip it if we could
/// add a static assert on \a std::is_trivially_copyable(), but we currently
/// support versions of GCC that don't understand that.
void destroyVal() {
  switch (Ty) {
  case isNone:
    return;
384#define HANDLE_DIEVALUE_SMALL(T)                                               \
case is##T:                                                                  \
  destruct<DIE##T>();                                                        \
  return;
388#define HANDLE_DIEVALUE_LARGE(T)                                               \
case is##T:                                                                  \
  destruct<const DIE##T *>();                                                \
  return;
392#include "llvm/CodeGen/DIEValue.def"
  }
}

/// Copy the underlying value.
///
/// This should get optimized down to a simple copy.  We need to actually
/// construct the value, rather than calling memcpy, to satisfy strict
/// aliasing rules.
void copyVal(const DIEValue &X) {
  switch (Ty) {
  case isNone:
    return;
405#define HANDLE_DIEVALUE_SMALL(T)                                               \
case is##T:                                                                  \
  construct<DIE##T>(*X.get<DIE##T>());                                       \
  return;
409#define HANDLE_DIEVALUE_LARGE(T)                                               \
case is##T:                                                                  \
  construct<const DIE##T *>(*X.get<const DIE##T *>());                       \
  return;
413#include "llvm/CodeGen/DIEValue.def"
  }
}

417public:
DIEValue() = default;

DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
  copyVal(X);
}

DIEValue &operator=(const DIEValue &X) {
  destroyVal();
  Ty = X.Ty;
  Attribute = X.Attribute;
  Form = X.Form;
  copyVal(X);
  return *this;
}

~DIEValue() { destroyVal(); }

435#define HANDLE_DIEVALUE_SMALL(T)                                               \
DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T &V)      \
    : Ty(is##T), Attribute(Attribute), Form(Form) {                          \
  construct<DIE##T>(V);                                                      \
}
440#define HANDLE_DIEVALUE_LARGE(T)                                               \
DIEValue(dwarf::Attribute Attribute, dwarf::Form Form, const DIE##T *V)      \
    : Ty(is##T), Attribute(Attribute), Form(Form) {                          \
  assert(V && "Expected valid value")((V && "Expected valid value") ? static_cast<void>
 (0) : __assert_fail ("V && \"Expected valid value\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h"
, 443, __PRETTY_FUNCTION__));                                       \
  construct<const DIE##T *>(V);                                              \
}
446#include "llvm/CodeGen/DIEValue.def"

/// Accessors.
/// @{
Type getType() const { return Ty; }
dwarf::Attribute getAttribute() const { return Attribute; }
dwarf::Form getForm() const { return Form; }
explicit operator bool() const { return Ty; }
/// @}

456#define HANDLE_DIEVALUE_SMALL(T)                                               \
const DIE##T &getDIE##T() const {                                            \
  assert(getType() == is##T && "Expected " #T)((getType() == is##T && "Expected " #T) ? static_cast
<void> (0) : __assert_fail ("getType() == is##T && \"Expected \" #T"
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h"
, 458, __PRETTY_FUNCTION__));                              \
  return *get<DIE##T>();                                                     \
}
461#define HANDLE_DIEVALUE_LARGE(T)                                               \
const DIE##T &getDIE##T() const {                                            \
  assert(getType() == is##T && "Expected " #T)((getType() == is##T && "Expected " #T) ? static_cast
<void> (0) : __assert_fail ("getType() == is##T && \"Expected \" #T"
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h"
, 463, __PRETTY_FUNCTION__));                              \
  return **get<const DIE##T *>();                                            \
}
466#include "llvm/CodeGen/DIEValue.def"

/// Emit value via the Dwarf writer.
void EmitValue(const AsmPrinter *AP) const;

/// Return the size of a value in bytes.
unsigned SizeOf(const AsmPrinter *AP) const;

void print(raw_ostream &O) const;
void dump() const;
476};

478struct IntrusiveBackListNode {
PointerIntPair<IntrusiveBackListNode *, 1> Next;

IntrusiveBackListNode() : Next(this, true) {}

IntrusiveBackListNode *getNext() const {
  return Next.getInt() ? nullptr : Next.getPointer();
}
486};

488struct IntrusiveBackListBase {
using Node = IntrusiveBackListNode;

Node *Last = nullptr;

bool empty() const { return !Last; }

void push_back(Node &N) {
  assert(N.Next.getPointer() == &N && "Expected unlinked node")((N.Next.getPointer() == &N && "Expected unlinked node"
) ? static_cast<void> (0) : __assert_fail ("N.Next.getPointer() == &N && \"Expected unlinked node\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h"
, 496, __PRETTY_FUNCTION__));
  assert(N.Next.getInt() == true && "Expected unlinked node")((N.Next.getInt() == true && "Expected unlinked node"
) ? static_cast<void> (0) : __assert_fail ("N.Next.getInt() == true && \"Expected unlinked node\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h"
, 497, __PRETTY_FUNCTION__));

  if (Last) {
    N.Next = Last->Next;
    Last->Next.setPointerAndInt(&N, false);
  }
  Last = &N;
}
505};

507template <class T> class IntrusiveBackList : IntrusiveBackListBase {
508public:
using IntrusiveBackListBase::empty;

void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
T &back() { return *static_cast<T *>(Last); }
const T &back() const { return *static_cast<T *>(Last); }

class const_iterator;
class iterator
    : public iterator_facade_base<iterator, std::forward_iterator_tag, T> {
  friend class const_iterator;

  Node *N = nullptr;

public:
  iterator() = default;
  explicit iterator(T *N) : N(N) {}

  iterator &operator++() {
    N = N->getNext();
    return *this;
  }

  explicit operator bool() const { return N; }
  T &operator*() const { return *static_cast<T *>(N); }

  bool operator==(const iterator &X) const { return N == X.N; }
  bool operator!=(const iterator &X) const { return N != X.N; }
};

class const_iterator
    : public iterator_facade_base<const_iterator, std::forward_iterator_tag,
                                  const T> {
  const Node *N = nullptr;

public:
  const_iterator() = default;
  // Placate MSVC by explicitly scoping 'iterator'.
  const_iterator(typename IntrusiveBackList<T>::iterator X) : N(X.N) {}
  explicit const_iterator(const T *N) : N(N) {}

  const_iterator &operator++() {
    N = N->getNext();
    return *this;
  }

  explicit operator bool() const { return N; }
  const T &operator*() const { return *static_cast<const T *>(N); }

  bool operator==(const const_iterator &X) const { return N == X.N; }
  bool operator!=(const const_iterator &X) const { return N != X.N; }
};

iterator begin() {
  return Last ? iterator(static_cast<T *>(Last->Next.getPointer())) : end();
}
const_iterator begin() const {
  return const_cast<IntrusiveBackList *>(this)->begin();
}
iterator end() { return iterator(); }
const_iterator end() const { return const_iterator(); }

static iterator toIterator(T &N) { return iterator(&N); }
static const_iterator toIterator(const T &N) { return const_iterator(&N); }
572};

574/// A list of DIE values.
575///
576/// This is a singly-linked list, but instead of reversing the order of
577/// insertion, we keep a pointer to the back of the list so we can push in
578/// order.
579///
580/// There are two main reasons to choose a linked list over a customized
581/// vector-like data structure.
582///
583///  1. For teardown efficiency, we want DIEs to be BumpPtrAllocated.  Using a
584///     linked list here makes this way easier to accomplish.
585///  2. Carrying an extra pointer per \a DIEValue isn't expensive.  45% of DIEs
586///     have 2 or fewer values, and 90% have 5 or fewer.  A vector would be
587///     over-allocated by 50% on average anyway, the same cost as the
588///     linked-list node.
589class DIEValueList {
struct Node : IntrusiveBackListNode {
  DIEValue V;

  explicit Node(DIEValue V) : V(V) {}
};

using ListTy = IntrusiveBackList<Node>;

ListTy List;

600public:
class const_value_iterator;
class value_iterator
    : public iterator_adaptor_base<value_iterator, ListTy::iterator,
                                   std::forward_iterator_tag, DIEValue> {
  friend class const_value_iterator;

  using iterator_adaptor =
      iterator_adaptor_base<value_iterator, ListTy::iterator,
                            std::forward_iterator_tag, DIEValue>;

public:
  value_iterator() = default;
  explicit value_iterator(ListTy::iterator X) : iterator_adaptor(X) {}

  explicit operator bool() const { return bool(wrapped()); }
  DIEValue &operator*() const { return wrapped()->V; }
};

class const_value_iterator : public iterator_adaptor_base<
                                 const_value_iterator, ListTy::const_iterator,
                                 std::forward_iterator_tag, const DIEValue> {
  using iterator_adaptor =
      iterator_adaptor_base<const_value_iterator, ListTy::const_iterator,
                            std::forward_iterator_tag, const DIEValue>;

public:
  const_value_iterator() = default;
  const_value_iterator(DIEValueList::value_iterator X)
      : iterator_adaptor(X.wrapped()) {}
  explicit const_value_iterator(ListTy::const_iterator X)
      : iterator_adaptor(X) {}

  explicit operator bool() const { return bool(wrapped()); }
  const DIEValue &operator*() const { return wrapped()->V; }
};

using value_range = iterator_range<value_iterator>;
using const_value_range = iterator_range<const_value_iterator>;

value_iterator addValue(BumpPtrAllocator &Alloc, const DIEValue &V) {
  List.push_back(*new (Alloc) Node(V));
16
←
Forming reference to null pointer
  return value_iterator(ListTy::toIterator(List.back()));
}
template <class T>
value_iterator addValue(BumpPtrAllocator &Alloc, dwarf::Attribute Attribute,
                  dwarf::Form Form, T &&Value) {
  return addValue(Alloc, DIEValue(Attribute, Form, std::forward<T>(Value)));
15
←
Calling 'DIEValueList::addValue'→
}

value_range values() {
  return make_range(value_iterator(List.begin()), value_iterator(List.end()));
}
const_value_range values() const {
  return make_range(const_value_iterator(List.begin()),
                    const_value_iterator(List.end()));
}
657};

659//===--------------------------------------------------------------------===//
660/// A structured debug information entry.  Has an abbreviation which
661/// describes its organization.
662class DIE : IntrusiveBackListNode, public DIEValueList {
friend class IntrusiveBackList<DIE>;
friend class DIEUnit;

/// Dwarf unit relative offset.
unsigned Offset = 0;
/// Size of instance + children.
unsigned Size = 0;
unsigned AbbrevNumber = ~0u;
/// Dwarf tag code.
dwarf::Tag Tag = (dwarf::Tag)0;
/// Set to true to force a DIE to emit an abbreviation that says it has
/// children even when it doesn't. This is used for unit testing purposes.
bool ForceChildren = false;
/// Children DIEs.
IntrusiveBackList<DIE> Children;

/// The owner is either the parent DIE for children of other DIEs, or a
/// DIEUnit which contains this DIE as its unit DIE.
PointerUnion<DIE *, DIEUnit *> Owner;

explicit DIE(dwarf::Tag Tag) : Tag(Tag) {}

685public:
DIE() = delete;
DIE(const DIE &RHS) = delete;
DIE(DIE &&RHS) = delete;
DIE &operator=(const DIE &RHS) = delete;
DIE &operator=(const DIE &&RHS) = delete;

static DIE *get(BumpPtrAllocator &Alloc, dwarf::Tag Tag) {
  return new (Alloc) DIE(Tag);
}

// Accessors.
unsigned getAbbrevNumber() const { return AbbrevNumber; }
dwarf::Tag getTag() const { return Tag; }
/// Get the compile/type unit relative offset of this DIE.
unsigned getOffset() const { return Offset; }
unsigned getSize() const { return Size; }
bool hasChildren() const { return ForceChildren || !Children.empty(); }
void setForceChildren(bool B) { ForceChildren = B; }

using child_iterator = IntrusiveBackList<DIE>::iterator;
using const_child_iterator = IntrusiveBackList<DIE>::const_iterator;
using child_range = iterator_range<child_iterator>;
using const_child_range = iterator_range<const_child_iterator>;

child_range children() {
  return make_range(Children.begin(), Children.end());
}
const_child_range children() const {
  return make_range(Children.begin(), Children.end());
}

DIE *getParent() const;

/// Generate the abbreviation for this DIE.
///
/// Calculate the abbreviation for this, which should be uniqued and
/// eventually used to call \a setAbbrevNumber().
DIEAbbrev generateAbbrev() const;

/// Set the abbreviation number for this DIE.
void setAbbrevNumber(unsigned I) { AbbrevNumber = I; }

/// Get the absolute offset within the .debug_info or .debug_types section
/// for this DIE.
unsigned getDebugSectionOffset() const;

/// Compute the offset of this DIE and all its children.
///
/// This function gets called just before we are going to generate the debug
/// information and gives each DIE a chance to figure out its CU relative DIE
/// offset, unique its abbreviation and fill in the abbreviation code, and
/// return the unit offset that points to where the next DIE will be emitted
/// within the debug unit section. After this function has been called for all
/// DIE objects, the DWARF can be generated since all DIEs will be able to
/// properly refer to other DIE objects since all DIEs have calculated their
/// offsets.
///
/// \param AP AsmPrinter to use when calculating sizes.
/// \param AbbrevSet the abbreviation used to unique DIE abbreviations.
/// \param CUOffset the compile/type unit relative offset in bytes.
/// \returns the offset for the DIE that follows this DIE within the
/// current compile/type unit.
unsigned computeOffsetsAndAbbrevs(const AsmPrinter *AP,
                                  DIEAbbrevSet &AbbrevSet, unsigned CUOffset);

/// Climb up the parent chain to get the compile unit or type unit DIE that
/// this DIE belongs to.
///
/// \returns the compile or type unit DIE that owns this DIE, or NULL if
/// this DIE hasn't been added to a unit DIE.
const DIE *getUnitDie() const;

/// Climb up the parent chain to get the compile unit or type unit that this
/// DIE belongs to.
///
/// \returns the DIEUnit that represents the compile or type unit that owns
/// this DIE, or NULL if this DIE hasn't been added to a unit DIE.
const DIEUnit *getUnit() const;

void setOffset(unsigned O) { Offset = O; }
void setSize(unsigned S) { Size = S; }

/// Add a child to the DIE.
DIE &addChild(DIE *Child) {
  assert(!Child->getParent() && "Child should be orphaned")((!Child->getParent() && "Child should be orphaned"
) ? static_cast<void> (0) : __assert_fail ("!Child->getParent() && \"Child should be orphaned\""
, "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h"
, 770, __PRETTY_FUNCTION__));
  Child->Owner = this;
  Children.push_back(*Child);
  return Children.back();
}

/// Find a value in the DIE with the attribute given.
///
/// Returns a default-constructed DIEValue (where \a DIEValue::getType()
/// gives \a DIEValue::isNone) if no such attribute exists.
DIEValue findAttribute(dwarf::Attribute Attribute) const;

void print(raw_ostream &O, unsigned IndentCount = 0) const;
void dump() const;
784};

786//===--------------------------------------------------------------------===//
787/// Represents a compile or type unit.
788class DIEUnit {
/// The compile unit or type unit DIE. This variable must be an instance of
/// DIE so that we can calculate the DIEUnit from any DIE by traversing the
/// parent backchain and getting the Unit DIE, and then casting itself to a
/// DIEUnit. This allows us to be able to find the DIEUnit for any DIE without
/// having to store a pointer to the DIEUnit in each DIE instance.
DIE Die;
/// The section this unit will be emitted in. This may or may not be set to
/// a valid section depending on the client that is emitting DWARF.
MCSection *Section;
uint64_t Offset; /// .debug_info or .debug_types absolute section offset.
uint32_t Length; /// The length in bytes of all of the DIEs in this unit.
const uint16_t Version; /// The Dwarf version number for this unit.
const uint8_t AddrSize; /// The size in bytes of an address for this unit.
802protected:
~DIEUnit() = default;

805public:
DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag);
DIEUnit(const DIEUnit &RHS) = delete;
DIEUnit(DIEUnit &&RHS) = delete;
void operator=(const DIEUnit &RHS) = delete;
void operator=(const DIEUnit &&RHS) = delete;
/// Set the section that this DIEUnit will be emitted into.
///
/// This function is used by some clients to set the section. Not all clients
/// that emit DWARF use this section variable.
void setSection(MCSection *Section) {
  assert(!this->Section)((!this->Section) ? static_cast<void> (0) : __assert_fail
 ("!this->Section", "/build/llvm-toolchain-snapshot-8~svn350071/include/llvm/CodeGen/DIE.h"
, 816, __PRETTY_FUNCTION__));
  this->Section = Section;
}

virtual const MCSymbol *getCrossSectionRelativeBaseAddress() const {
  return nullptr;
}

/// Return the section that this DIEUnit will be emitted into.
///
/// \returns Section pointer which can be NULL.
MCSection *getSection() const { return Section; }
void setDebugSectionOffset(unsigned O) { Offset = O; }
unsigned getDebugSectionOffset() const { return Offset; }
void setLength(uint64_t L) { Length = L; }
uint64_t getLength() const { return Length; }
uint16_t getDwarfVersion() const { return Version; }
uint16_t getAddressSize() const { return AddrSize; }
DIE &getUnitDie() { return Die; }
const DIE &getUnitDie() const { return Die; }
836};

838struct BasicDIEUnit final : DIEUnit {
BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag)
    : DIEUnit(Version, AddrSize, UnitTag) {}
841};

843//===--------------------------------------------------------------------===//
844/// DIELoc - Represents an expression location.
845//
846class DIELoc : public DIEValueList {
mutable unsigned Size = 0; // Size in bytes excluding size header.

849public:
DIELoc() = default;

/// ComputeSize - Calculate the size of the location expression.
///
unsigned ComputeSize(const AsmPrinter *AP) const;

/// BestForm - Choose the best form for data.
///
dwarf::Form BestForm(unsigned DwarfVersion) const {
  if (DwarfVersion > 3)
    return dwarf::DW_FORM_exprloc;
  // Pre-DWARF4 location expressions were blocks and not exprloc.
  if ((unsigned char)Size == Size)
    return dwarf::DW_FORM_block1;
  if ((unsigned short)Size == Size)
    return dwarf::DW_FORM_block2;
  if ((unsigned int)Size == Size)
    return dwarf::DW_FORM_block4;
  return dwarf::DW_FORM_block;
}

void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
875};

877//===--------------------------------------------------------------------===//
878/// DIEBlock - Represents a block of values.
879//
880class DIEBlock : public DIEValueList {
mutable unsigned Size = 0; // Size in bytes excluding size header.

883public:
DIEBlock() = default;

/// ComputeSize - Calculate the size of the location expression.
///
unsigned ComputeSize(const AsmPrinter *AP) const;

/// BestForm - Choose the best form for data.
///
dwarf::Form BestForm() const {
  if ((unsigned char)Size == Size)
    return dwarf::DW_FORM_block1;
  if ((unsigned short)Size == Size)
    return dwarf::DW_FORM_block2;
  if ((unsigned int)Size == Size)
    return dwarf::DW_FORM_block4;
  return dwarf::DW_FORM_block;
}

void EmitValue(const AsmPrinter *Asm, dwarf::Form Form) const;
unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;

void print(raw_ostream &O) const;
906};

908} // end namespace llvm

910#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H