/build/llvm-toolchain-snapshot-8~svn345461/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 DwarfLinker.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 -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~svn345461/build-llvm/tools/dsymutil -I /build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/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~svn345461/build-llvm/tools/dsymutil -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp

→

1//===- tools/dsymutil/DwarfLinker.cpp - Dwarf debug info linker -----------===//
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//===----------------------------------------------------------------------===//

10#include "DwarfLinker.h"
11#include "BinaryHolder.h"
12#include "DebugMap.h"
13#include "DeclContext.h"
14#include "DwarfStreamer.h"
15#include "MachOUtils.h"
16#include "NonRelocatableStringpool.h"
17#include "dsymutil.h"
18#include "llvm/ADT/ArrayRef.h"
19#include "llvm/ADT/BitVector.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/DenseMapInfo.h"
22#include "llvm/ADT/DenseSet.h"
23#include "llvm/ADT/FoldingSet.h"
24#include "llvm/ADT/Hashing.h"
25#include "llvm/ADT/IntervalMap.h"
26#include "llvm/ADT/None.h"
27#include "llvm/ADT/Optional.h"
28#include "llvm/ADT/PointerIntPair.h"
29#include "llvm/ADT/STLExtras.h"
30#include "llvm/ADT/SmallString.h"
31#include "llvm/ADT/StringMap.h"
32#include "llvm/ADT/StringRef.h"
33#include "llvm/ADT/Triple.h"
34#include "llvm/ADT/Twine.h"
35#include "llvm/BinaryFormat/Dwarf.h"
36#include "llvm/BinaryFormat/MachO.h"
37#include "llvm/CodeGen/AccelTable.h"
38#include "llvm/CodeGen/AsmPrinter.h"
39#include "llvm/CodeGen/DIE.h"
40#include "llvm/Config/config.h"
41#include "llvm/DebugInfo/DIContext.h"
42#include "llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h"
43#include "llvm/DebugInfo/DWARF/DWARFContext.h"
44#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
45#include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
46#include "llvm/DebugInfo/DWARF/DWARFDebugRangeList.h"
47#include "llvm/DebugInfo/DWARF/DWARFDie.h"
48#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
49#include "llvm/DebugInfo/DWARF/DWARFSection.h"
50#include "llvm/DebugInfo/DWARF/DWARFUnit.h"
51#include "llvm/MC/MCAsmBackend.h"
52#include "llvm/MC/MCAsmInfo.h"
53#include "llvm/MC/MCCodeEmitter.h"
54#include "llvm/MC/MCContext.h"
55#include "llvm/MC/MCDwarf.h"
56#include "llvm/MC/MCInstrInfo.h"
57#include "llvm/MC/MCObjectFileInfo.h"
58#include "llvm/MC/MCObjectWriter.h"
59#include "llvm/MC/MCRegisterInfo.h"
60#include "llvm/MC/MCSection.h"
61#include "llvm/MC/MCStreamer.h"
62#include "llvm/MC/MCSubtargetInfo.h"
63#include "llvm/MC/MCTargetOptions.h"
64#include "llvm/Object/MachO.h"
65#include "llvm/Object/ObjectFile.h"
66#include "llvm/Object/SymbolicFile.h"
67#include "llvm/Support/Allocator.h"
68#include "llvm/Support/Casting.h"
69#include "llvm/Support/Compiler.h"
70#include "llvm/Support/DJB.h"
71#include "llvm/Support/DataExtractor.h"
72#include "llvm/Support/Error.h"
73#include "llvm/Support/ErrorHandling.h"
74#include "llvm/Support/ErrorOr.h"
75#include "llvm/Support/FileSystem.h"
76#include "llvm/Support/Format.h"
77#include "llvm/Support/LEB128.h"
78#include "llvm/Support/MathExtras.h"
79#include "llvm/Support/MemoryBuffer.h"
80#include "llvm/Support/Path.h"
81#include "llvm/Support/TargetRegistry.h"
82#include "llvm/Support/ThreadPool.h"
83#include "llvm/Support/ToolOutputFile.h"
84#include "llvm/Support/WithColor.h"
85#include "llvm/Support/raw_ostream.h"
86#include "llvm/Target/TargetMachine.h"
87#include "llvm/Target/TargetOptions.h"
88#include <algorithm>
89#include <cassert>
90#include <cinttypes>
91#include <climits>
92#include <cstdint>
93#include <cstdlib>
94#include <cstring>
95#include <limits>
96#include <map>
97#include <memory>
98#include <string>
99#include <system_error>
100#include <tuple>
101#include <utility>
102#include <vector>

104// For GNU Hurd
105#if defined(__GNU__) && !defined(PATH_MAX4096)
106# define PATH_MAX4096 4096
107#endif

109namespace llvm {
110namespace dsymutil {

112/// Similar to DWARFUnitSection::getUnitForOffset(), but returning our
113/// CompileUnit object instead.
114static CompileUnit *getUnitForOffset(const UnitListTy &Units, unsigned Offset) {
auto CU = std::upper_bound(
    Units.begin(), Units.end(), Offset,
    [](uint32_t LHS, const std::unique_ptr<CompileUnit> &RHS) {
      return LHS < RHS->getOrigUnit().getNextUnitOffset();
    });
return CU != Units.end() ? CU->get() : nullptr;
121}

123/// Resolve the DIE attribute reference that has been extracted in \p RefValue.
124/// The resulting DIE might be in another CompileUnit which is stored into \p
125/// ReferencedCU. \returns null if resolving fails for any reason.
126static DWARFDie resolveDIEReference(const DwarfLinker &Linker,
                                  const DebugMapObject &DMO,
                                  const UnitListTy &Units,
                                  const DWARFFormValue &RefValue,
                                  const DWARFUnit &Unit, const DWARFDie &DIE,
                                  CompileUnit *&RefCU) {
assert(RefValue.isFormClass(DWARFFormValue::FC_Reference))((RefValue.isFormClass(DWARFFormValue::FC_Reference)) ? static_cast
<void> (0) : __assert_fail ("RefValue.isFormClass(DWARFFormValue::FC_Reference)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 132, __PRETTY_FUNCTION__));
uint64_t RefOffset = *RefValue.getAsReference();

if ((RefCU = getUnitForOffset(Units, RefOffset)))
  if (const auto RefDie = RefCU->getOrigUnit().getDIEForOffset(RefOffset)) {
    // In a file with broken references, an attribute might point to a NULL
    // DIE.
    if (!RefDie.isNULL())
      return RefDie;
  }

Linker.reportWarning("could not find referenced DIE", DMO, &DIE);
return DWARFDie();
145}

147/// \returns whether the passed \a Attr type might contain a DIE reference
148/// suitable for ODR uniquing.
149static bool isODRAttribute(uint16_t Attr) {
switch (Attr) {
default:
  return false;
case dwarf::DW_AT_type:
case dwarf::DW_AT_containing_type:
case dwarf::DW_AT_specification:
case dwarf::DW_AT_abstract_origin:
case dwarf::DW_AT_import:
  return true;
}
llvm_unreachable("Improper attribute.")::llvm::llvm_unreachable_internal("Improper attribute.", "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 160);
161}

163static bool isTypeTag(uint16_t Tag) {
switch (Tag) {
case dwarf::DW_TAG_array_type:
case dwarf::DW_TAG_class_type:
case dwarf::DW_TAG_enumeration_type:
case dwarf::DW_TAG_pointer_type:
case dwarf::DW_TAG_reference_type:
case dwarf::DW_TAG_string_type:
case dwarf::DW_TAG_structure_type:
case dwarf::DW_TAG_subroutine_type:
case dwarf::DW_TAG_typedef:
case dwarf::DW_TAG_union_type:
case dwarf::DW_TAG_ptr_to_member_type:
case dwarf::DW_TAG_set_type:
case dwarf::DW_TAG_subrange_type:
case dwarf::DW_TAG_base_type:
case dwarf::DW_TAG_const_type:
case dwarf::DW_TAG_constant:
case dwarf::DW_TAG_file_type:
case dwarf::DW_TAG_namelist:
case dwarf::DW_TAG_packed_type:
case dwarf::DW_TAG_volatile_type:
case dwarf::DW_TAG_restrict_type:
case dwarf::DW_TAG_atomic_type:
case dwarf::DW_TAG_interface_type:
case dwarf::DW_TAG_unspecified_type:
case dwarf::DW_TAG_shared_type:
  return true;
default:
  break;
}
return false;
195}

197bool DwarfLinker::DIECloner::getDIENames(const DWARFDie &Die,
                                       AttributesInfo &Info,
                                       OffsetsStringPool &StringPool,
                                       bool StripTemplate) {
// This function will be called on DIEs having low_pcs and
// ranges. As getting the name might be more expansive, filter out
// blocks directly.
if (Die.getTag() == dwarf::DW_TAG_lexical_block)
  return false;

// FIXME: a bit wasteful as the first getName might return the
// short name.
if (!Info.MangledName)
  if (const char *MangledName = Die.getName(DINameKind::LinkageName))
    Info.MangledName = StringPool.getEntry(MangledName);

if (!Info.Name)
  if (const char *Name = Die.getName(DINameKind::ShortName))
    Info.Name = StringPool.getEntry(Name);

if (StripTemplate && Info.Name && Info.MangledName != Info.Name) {
  // FIXME: dsymutil compatibility. This is wrong for operator<
  auto Split = Info.Name.getString().split('<');
  if (!Split.second.empty())
    Info.NameWithoutTemplate = StringPool.getEntry(Split.first);
}

return Info.Name || Info.MangledName;
225}

227/// Report a warning to the user, optionally including information about a
228/// specific \p DIE related to the warning.
229void DwarfLinker::reportWarning(const Twine &Warning, const DebugMapObject &DMO,
                              const DWARFDie *DIE) const {
StringRef Context = DMO.getObjectFilename();
warn(Warning, Context);

if (!Options.Verbose || !DIE)
  return;

DIDumpOptions DumpOpts;
DumpOpts.RecurseDepth = 0;
DumpOpts.Verbose = Options.Verbose;

WithColor::note() << "    in DIE:\n";
DIE->dump(errs(), 6 /* Indent */, DumpOpts);
243}

245bool DwarfLinker::createStreamer(const Triple &TheTriple,
                               raw_fd_ostream &OutFile) {
if (Options.NoOutput)
  return true;

Streamer = llvm::make_unique<DwarfStreamer>(OutFile, Options);
return Streamer->init(TheTriple);
252}

254/// Recursive helper to build the global DeclContext information and
255/// gather the child->parent relationships in the original compile unit.
256///
257/// \return true when this DIE and all of its children are only
258/// forward declarations to types defined in external clang modules
259/// (i.e., forward declarations that are children of a DW_TAG_module).
260static bool analyzeContextInfo(const DWARFDie &DIE, unsigned ParentIdx,
                             CompileUnit &CU, DeclContext *CurrentDeclContext,
                             UniquingStringPool &StringPool,
                             DeclContextTree &Contexts,
                             uint64_t ModulesEndOffset,
                             bool InImportedModule = false) {
unsigned MyIdx = CU.getOrigUnit().getDIEIndex(DIE);
CompileUnit::DIEInfo &Info = CU.getInfo(MyIdx);

// Clang imposes an ODR on modules(!) regardless of the language:
//  "The module-id should consist of only a single identifier,
//   which provides the name of the module being defined. Each
//   module shall have a single definition."
//
// This does not extend to the types inside the modules:
//  "[I]n C, this implies that if two structs are defined in
//   different submodules with the same name, those two types are
//   distinct types (but may be compatible types if their
//   definitions match)."
//
// We treat non-C++ modules like namespaces for this reason.
if (DIE.getTag() == dwarf::DW_TAG_module && ParentIdx == 0 &&
    dwarf::toString(DIE.find(dwarf::DW_AT_name), "") !=
        CU.getClangModuleName()) {
  InImportedModule = true;
}

Info.ParentIdx = ParentIdx;
bool InClangModule = CU.isClangModule() || InImportedModule;
if (CU.hasODR() || InClangModule) {
  if (CurrentDeclContext) {
    auto PtrInvalidPair = Contexts.getChildDeclContext(
        *CurrentDeclContext, DIE, CU, StringPool, InClangModule);
    CurrentDeclContext = PtrInvalidPair.getPointer();
    Info.Ctxt =
        PtrInvalidPair.getInt() ? nullptr : PtrInvalidPair.getPointer();
    if (Info.Ctxt)
      Info.Ctxt->setDefinedInClangModule(InClangModule);
  } else
    Info.Ctxt = CurrentDeclContext = nullptr;
}

Info.Prune = InImportedModule;
if (DIE.hasChildren())
  for (auto Child : DIE.children())
    Info.Prune &=
        analyzeContextInfo(Child, MyIdx, CU, CurrentDeclContext, StringPool,
                           Contexts, ModulesEndOffset, InImportedModule);

// Prune this DIE if it is either a forward declaration inside a
// DW_TAG_module or a DW_TAG_module that contains nothing but
// forward declarations.
Info.Prune &= (DIE.getTag() == dwarf::DW_TAG_module) ||
              (isTypeTag(DIE.getTag()) &&
               dwarf::toUnsigned(DIE.find(dwarf::DW_AT_declaration), 0));

// Only prune forward declarations inside a DW_TAG_module for which a
// definition exists elsewhere.
if (ModulesEndOffset == 0)
  Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset();
else
  Info.Prune &= Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset() > 0 &&
                Info.Ctxt->getCanonicalDIEOffset() <= ModulesEndOffset;

return Info.Prune;
325} // namespace dsymutil

327static bool dieNeedsChildrenToBeMeaningful(uint32_t Tag) {
switch (Tag) {
default:
  return false;
case dwarf::DW_TAG_subprogram:
case dwarf::DW_TAG_lexical_block:
case dwarf::DW_TAG_subroutine_type:
case dwarf::DW_TAG_structure_type:
case dwarf::DW_TAG_class_type:
case dwarf::DW_TAG_union_type:
  return true;
}
llvm_unreachable("Invalid Tag")::llvm::llvm_unreachable_internal("Invalid Tag", "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 339);
340}

342void DwarfLinker::startDebugObject(LinkContext &Context) {
// Iterate over the debug map entries and put all the ones that are
// functions (because they have a size) into the Ranges map. This map is
// very similar to the FunctionRanges that are stored in each unit, with 2
// notable differences:
//
//  1. Obviously this one is global, while the other ones are per-unit.
//
//  2. This one contains not only the functions described in the DIE
//     tree, but also the ones that are only in the debug map.
//
// The latter information is required to reproduce dsymutil's logic while
// linking line tables. The cases where this information matters look like
// bugs that need to be investigated, but for now we need to reproduce
// dsymutil's behavior.
// FIXME: Once we understood exactly if that information is needed,
// maybe totally remove this (or try to use it to do a real
// -gline-tables-only on Darwin.
for (const auto &Entry : Context.DMO.symbols()) {
  const auto &Mapping = Entry.getValue();
  if (Mapping.Size && Mapping.ObjectAddress)
    Context.Ranges[*Mapping.ObjectAddress] = DebugMapObjectRange(
        *Mapping.ObjectAddress + Mapping.Size,
        int64_t(Mapping.BinaryAddress) - *Mapping.ObjectAddress);
}
367}

369void DwarfLinker::endDebugObject(LinkContext &Context) {
Context.Clear();

for (auto I = DIEBlocks.begin(), E = DIEBlocks.end(); I != E; ++I)
  (*I)->~DIEBlock();
for (auto I = DIELocs.begin(), E = DIELocs.end(); I != E; ++I)
  (*I)->~DIELoc();

DIEBlocks.clear();
DIELocs.clear();
DIEAlloc.Reset();
380}

382static bool isMachOPairedReloc(uint64_t RelocType, uint64_t Arch) {
switch (Arch) {
case Triple::x86:
  return RelocType == MachO::GENERIC_RELOC_SECTDIFF ||
         RelocType == MachO::GENERIC_RELOC_LOCAL_SECTDIFF;
case Triple::x86_64:
  return RelocType == MachO::X86_64_RELOC_SUBTRACTOR;
case Triple::arm:
case Triple::thumb:
  return RelocType == MachO::ARM_RELOC_SECTDIFF ||
         RelocType == MachO::ARM_RELOC_LOCAL_SECTDIFF ||
         RelocType == MachO::ARM_RELOC_HALF ||
         RelocType == MachO::ARM_RELOC_HALF_SECTDIFF;
case Triple::aarch64:
  return RelocType == MachO::ARM64_RELOC_SUBTRACTOR;
default:
  return false;
}
400}

402/// Iterate over the relocations of the given \p Section and
403/// store the ones that correspond to debug map entries into the
404/// ValidRelocs array.
405void DwarfLinker::RelocationManager::findValidRelocsMachO(
  const object::SectionRef &Section, const object::MachOObjectFile &Obj,
  const DebugMapObject &DMO) {
StringRef Contents;
Section.getContents(Contents);
DataExtractor Data(Contents, Obj.isLittleEndian(), 0);
bool SkipNext = false;

for (const object::RelocationRef &Reloc : Section.relocations()) {
  if (SkipNext) {
    SkipNext = false;
    continue;
  }

  object::DataRefImpl RelocDataRef = Reloc.getRawDataRefImpl();
  MachO::any_relocation_info MachOReloc = Obj.getRelocation(RelocDataRef);

  if (isMachOPairedReloc(Obj.getAnyRelocationType(MachOReloc),
                         Obj.getArch())) {
    SkipNext = true;
    Linker.reportWarning("unsupported relocation in debug_info section.",
                         DMO);
    continue;
  }

  unsigned RelocSize = 1 << Obj.getAnyRelocationLength(MachOReloc);
  uint64_t Offset64 = Reloc.getOffset();
  if ((RelocSize != 4 && RelocSize != 8)) {
    Linker.reportWarning("unsupported relocation in debug_info section.",
                         DMO);
    continue;
  }
  uint32_t Offset = Offset64;
  // Mach-o uses REL relocations, the addend is at the relocation offset.
  uint64_t Addend = Data.getUnsigned(&Offset, RelocSize);
  uint64_t SymAddress;
  int64_t SymOffset;

  if (Obj.isRelocationScattered(MachOReloc)) {
    // The address of the base symbol for scattered relocations is
    // stored in the reloc itself. The actual addend will store the
    // base address plus the offset.
    SymAddress = Obj.getScatteredRelocationValue(MachOReloc);
    SymOffset = int64_t(Addend) - SymAddress;
  } else {
    SymAddress = Addend;
    SymOffset = 0;
  }

  auto Sym = Reloc.getSymbol();
  if (Sym != Obj.symbol_end()) {
    Expected<StringRef> SymbolName = Sym->getName();
    if (!SymbolName) {
      consumeError(SymbolName.takeError());
      Linker.reportWarning("error getting relocation symbol name.", DMO);
      continue;
    }
    if (const auto *Mapping = DMO.lookupSymbol(*SymbolName))
      ValidRelocs.emplace_back(Offset64, RelocSize, Addend, Mapping);
  } else if (const auto *Mapping = DMO.lookupObjectAddress(SymAddress)) {
    // Do not store the addend. The addend was the address of the symbol in
    // the object file, the address in the binary that is stored in the debug
    // map doesn't need to be offset.
    ValidRelocs.emplace_back(Offset64, RelocSize, SymOffset, Mapping);
  }
}
471}

473/// Dispatch the valid relocation finding logic to the
474/// appropriate handler depending on the object file format.
475bool DwarfLinker::RelocationManager::findValidRelocs(
  const object::SectionRef &Section, const object::ObjectFile &Obj,
  const DebugMapObject &DMO) {
// Dispatch to the right handler depending on the file type.
if (auto *MachOObj = dyn_cast<object::MachOObjectFile>(&Obj))
  findValidRelocsMachO(Section, *MachOObj, DMO);
else
  Linker.reportWarning(
      Twine("unsupported object file type: ") + Obj.getFileName(), DMO);

if (ValidRelocs.empty())
  return false;

// Sort the relocations by offset. We will walk the DIEs linearly in
// the file, this allows us to just keep an index in the relocation
// array that we advance during our walk, rather than resorting to
// some associative container. See DwarfLinker::NextValidReloc.
llvm::sort(ValidRelocs);
return true;
494}

496/// Look for relocations in the debug_info section that match
497/// entries in the debug map. These relocations will drive the Dwarf
498/// link by indicating which DIEs refer to symbols present in the
499/// linked binary.
500/// \returns whether there are any valid relocations in the debug info.
501bool DwarfLinker::RelocationManager::findValidRelocsInDebugInfo(
  const object::ObjectFile &Obj, const DebugMapObject &DMO) {
// Find the debug_info section.
for (const object::SectionRef &Section : Obj.sections()) {
  StringRef SectionName;
  Section.getName(SectionName);
  SectionName = SectionName.substr(SectionName.find_first_not_of("._"));
  if (SectionName != "debug_info")
    continue;
  return findValidRelocs(Section, Obj, DMO);
}
return false;
513}

515/// Checks that there is a relocation against an actual debug
516/// map entry between \p StartOffset and \p NextOffset.
517///
518/// This function must be called with offsets in strictly ascending
519/// order because it never looks back at relocations it already 'went past'.
520/// \returns true and sets Info.InDebugMap if it is the case.
521bool DwarfLinker::RelocationManager::hasValidRelocation(
  uint32_t StartOffset, uint32_t EndOffset, CompileUnit::DIEInfo &Info) {
assert(NextValidReloc == 0 ||((NextValidReloc == 0 || StartOffset > ValidRelocs[NextValidReloc
 - 1].Offset) ? static_cast<void> (0) : __assert_fail (
"NextValidReloc == 0 || StartOffset > ValidRelocs[NextValidReloc - 1].Offset"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 524, __PRETTY_FUNCTION__))
       StartOffset > ValidRelocs[NextValidReloc - 1].Offset)((NextValidReloc == 0 || StartOffset > ValidRelocs[NextValidReloc
 - 1].Offset) ? static_cast<void> (0) : __assert_fail (
"NextValidReloc == 0 || StartOffset > ValidRelocs[NextValidReloc - 1].Offset"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 524, __PRETTY_FUNCTION__));
if (NextValidReloc >= ValidRelocs.size())
  return false;

uint64_t RelocOffset = ValidRelocs[NextValidReloc].Offset;

// We might need to skip some relocs that we didn't consider. For
// example the high_pc of a discarded DIE might contain a reloc that
// is in the list because it actually corresponds to the start of a
// function that is in the debug map.
while (RelocOffset < StartOffset && NextValidReloc < ValidRelocs.size() - 1)
  RelocOffset = ValidRelocs[++NextValidReloc].Offset;

if (RelocOffset < StartOffset || RelocOffset >= EndOffset)
  return false;

const auto &ValidReloc = ValidRelocs[NextValidReloc++];
const auto &Mapping = ValidReloc.Mapping->getValue();
uint64_t ObjectAddress = Mapping.ObjectAddress
                             ? uint64_t(*Mapping.ObjectAddress)
                             : std::numeric_limits<uint64_t>::max();
if (Linker.Options.Verbose)
  outs() << "Found valid debug map entry: " << ValidReloc.Mapping->getKey()
         << " "
         << format("\t%016" PRIx64"l" "x" " => %016" PRIx64"l" "x", ObjectAddress,
                   uint64_t(Mapping.BinaryAddress));

Info.AddrAdjust = int64_t(Mapping.BinaryAddress) + ValidReloc.Addend;
if (Mapping.ObjectAddress)
  Info.AddrAdjust -= ObjectAddress;
Info.InDebugMap = true;
return true;
556}

558/// Get the starting and ending (exclusive) offset for the
559/// attribute with index \p Idx descibed by \p Abbrev. \p Offset is
560/// supposed to point to the position of the first attribute described
561/// by \p Abbrev.
562/// \return [StartOffset, EndOffset) as a pair.
563static std::pair<uint32_t, uint32_t>
564getAttributeOffsets(const DWARFAbbreviationDeclaration *Abbrev, unsigned Idx,
                  unsigned Offset, const DWARFUnit &Unit) {
DataExtractor Data = Unit.getDebugInfoExtractor();

for (unsigned i = 0; i < Idx; ++i)
  DWARFFormValue::skipValue(Abbrev->getFormByIndex(i), Data, &Offset,
                            Unit.getFormParams());

uint32_t End = Offset;
DWARFFormValue::skipValue(Abbrev->getFormByIndex(Idx), Data, &End,
                          Unit.getFormParams());

return std::make_pair(Offset, End);
577}

579/// Check if a variable describing DIE should be kept.
580/// \returns updated TraversalFlags.
581unsigned DwarfLinker::shouldKeepVariableDIE(RelocationManager &RelocMgr,
                                          const DWARFDie &DIE,
                                          CompileUnit &Unit,
                                          CompileUnit::DIEInfo &MyInfo,
                                          unsigned Flags) {
const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();

// Global variables with constant value can always be kept.
if (!(Flags & TF_InFunctionScope) &&
    Abbrev->findAttributeIndex(dwarf::DW_AT_const_value)) {
  MyInfo.InDebugMap = true;
  return Flags | TF_Keep;
}

Optional<uint32_t> LocationIdx =
    Abbrev->findAttributeIndex(dwarf::DW_AT_location);
if (!LocationIdx)
  return Flags;

uint32_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
const DWARFUnit &OrigUnit = Unit.getOrigUnit();
uint32_t LocationOffset, LocationEndOffset;
std::tie(LocationOffset, LocationEndOffset) =
    getAttributeOffsets(Abbrev, *LocationIdx, Offset, OrigUnit);

// See if there is a relocation to a valid debug map entry inside
// this variable's location. The order is important here. We want to
// always check in the variable has a valid relocation, so that the
// DIEInfo is filled. However, we don't want a static variable in a
// function to force us to keep the enclosing function.
if (!RelocMgr.hasValidRelocation(LocationOffset, LocationEndOffset, MyInfo) ||
    (Flags & TF_InFunctionScope))
  return Flags;

if (Options.Verbose) {
  DIDumpOptions DumpOpts;
  DumpOpts.RecurseDepth = 0;
  DumpOpts.Verbose = Options.Verbose;
  DIE.dump(outs(), 8 /* Indent */, DumpOpts);
}

return Flags | TF_Keep;
623}

625/// Check if a function describing DIE should be kept.
626/// \returns updated TraversalFlags.
627unsigned DwarfLinker::shouldKeepSubprogramDIE(
  RelocationManager &RelocMgr, RangesTy &Ranges, const DWARFDie &DIE,
  const DebugMapObject &DMO, CompileUnit &Unit, CompileUnit::DIEInfo &MyInfo,
  unsigned Flags) {
const auto *Abbrev = DIE.getAbbreviationDeclarationPtr();

Flags |= TF_InFunctionScope;

Optional<uint32_t> LowPcIdx = Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
if (!LowPcIdx)
  return Flags;

uint32_t Offset = DIE.getOffset() + getULEB128Size(Abbrev->getCode());
DWARFUnit &OrigUnit = Unit.getOrigUnit();
uint32_t LowPcOffset, LowPcEndOffset;
std::tie(LowPcOffset, LowPcEndOffset) =
    getAttributeOffsets(Abbrev, *LowPcIdx, Offset, OrigUnit);

auto LowPc = dwarf::toAddress(DIE.find(dwarf::DW_AT_low_pc));
assert(LowPc.hasValue() && "low_pc attribute is not an address.")((LowPc.hasValue() && "low_pc attribute is not an address."
) ? static_cast<void> (0) : __assert_fail ("LowPc.hasValue() && \"low_pc attribute is not an address.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 646, __PRETTY_FUNCTION__));
if (!LowPc ||
    !RelocMgr.hasValidRelocation(LowPcOffset, LowPcEndOffset, MyInfo))
  return Flags;

if (Options.Verbose) {
  DIDumpOptions DumpOpts;
  DumpOpts.RecurseDepth = 0;
  DumpOpts.Verbose = Options.Verbose;
  DIE.dump(outs(), 8 /* Indent */, DumpOpts);
}

if (DIE.getTag() == dwarf::DW_TAG_label) {
  if (Unit.hasLabelAt(*LowPc))
    return Flags;
  // FIXME: dsymutil-classic compat. dsymutil-classic doesn't consider labels
  // that don't fall into the CU's aranges. This is wrong IMO. Debug info
  // generation bugs aside, this is really wrong in the case of labels, where
  // a label marking the end of a function will have a PC == CU's high_pc.
  if (dwarf::toAddress(OrigUnit.getUnitDIE().find(dwarf::DW_AT_high_pc))
          .getValueOr(UINT64_MAX(18446744073709551615UL)) <= LowPc)
    return Flags;
  Unit.addLabelLowPc(*LowPc, MyInfo.AddrAdjust);
  return Flags | TF_Keep;
}

Flags |= TF_Keep;

Optional<uint64_t> HighPc = DIE.getHighPC(*LowPc);
if (!HighPc) {
  reportWarning("Function without high_pc. Range will be discarded.\n", DMO,
                &DIE);
  return Flags;
}

// Replace the debug map range with a more accurate one.
Ranges[*LowPc] = DebugMapObjectRange(*HighPc, MyInfo.AddrAdjust);
Unit.addFunctionRange(*LowPc, *HighPc, MyInfo.AddrAdjust);
return Flags;
685}

687/// Check if a DIE should be kept.
688/// \returns updated TraversalFlags.
689unsigned DwarfLinker::shouldKeepDIE(RelocationManager &RelocMgr,
                                  RangesTy &Ranges, const DWARFDie &DIE,
                                  const DebugMapObject &DMO,
                                  CompileUnit &Unit,
                                  CompileUnit::DIEInfo &MyInfo,
                                  unsigned Flags) {
switch (DIE.getTag()) {
case dwarf::DW_TAG_constant:
case dwarf::DW_TAG_variable:
  return shouldKeepVariableDIE(RelocMgr, DIE, Unit, MyInfo, Flags);
case dwarf::DW_TAG_subprogram:
case dwarf::DW_TAG_label:
  return shouldKeepSubprogramDIE(RelocMgr, Ranges, DIE, DMO, Unit, MyInfo,
                                 Flags);
case dwarf::DW_TAG_imported_module:
case dwarf::DW_TAG_imported_declaration:
case dwarf::DW_TAG_imported_unit:
  // We always want to keep these.
  return Flags | TF_Keep;
default:
  break;
}

return Flags;
713}

715/// Mark the passed DIE as well as all the ones it depends on
716/// as kept.
717///
718/// This function is called by lookForDIEsToKeep on DIEs that are
719/// newly discovered to be needed in the link. It recursively calls
720/// back to lookForDIEsToKeep while adding TF_DependencyWalk to the
721/// TraversalFlags to inform it that it's not doing the primary DIE
722/// tree walk.
723void DwarfLinker::keepDIEAndDependencies(
  RelocationManager &RelocMgr, RangesTy &Ranges, const UnitListTy &Units,
  const DWARFDie &Die, CompileUnit::DIEInfo &MyInfo,
  const DebugMapObject &DMO, CompileUnit &CU, bool UseODR) {
DWARFUnit &Unit = CU.getOrigUnit();
MyInfo.Keep = true;

// We're looking for incomplete types.
MyInfo.Incomplete = Die.getTag() != dwarf::DW_TAG_subprogram &&
                    Die.getTag() != dwarf::DW_TAG_member &&
                    dwarf::toUnsigned(Die.find(dwarf::DW_AT_declaration), 0);

// First mark all the parent chain as kept.
unsigned AncestorIdx = MyInfo.ParentIdx;
while (!CU.getInfo(AncestorIdx).Keep) {
  unsigned ODRFlag = UseODR ? TF_ODR : 0;
  lookForDIEsToKeep(RelocMgr, Ranges, Units, Unit.getDIEAtIndex(AncestorIdx),
                    DMO, CU,
                    TF_ParentWalk | TF_Keep | TF_DependencyWalk | ODRFlag);
  AncestorIdx = CU.getInfo(AncestorIdx).ParentIdx;
}

// Then we need to mark all the DIEs referenced by this DIE's
// attributes as kept.
DWARFDataExtractor Data = Unit.getDebugInfoExtractor();
const auto *Abbrev = Die.getAbbreviationDeclarationPtr();
uint32_t Offset = Die.getOffset() + getULEB128Size(Abbrev->getCode());

// Mark all DIEs referenced through attributes as kept.
for (const auto &AttrSpec : Abbrev->attributes()) {
  DWARFFormValue Val(AttrSpec.Form);

  if (!Val.isFormClass(DWARFFormValue::FC_Reference) ||
      AttrSpec.Attr == dwarf::DW_AT_sibling) {
    DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
                              Unit.getFormParams());
    continue;
  }

  Val.extractValue(Data, &Offset, Unit.getFormParams(), &Unit);
  CompileUnit *ReferencedCU;
  if (auto RefDie = resolveDIEReference(*this, DMO, Units, Val, Unit, Die,
                                        ReferencedCU)) {
    uint32_t RefIdx = ReferencedCU->getOrigUnit().getDIEIndex(RefDie);
    CompileUnit::DIEInfo &Info = ReferencedCU->getInfo(RefIdx);
    bool IsModuleRef = Info.Ctxt && Info.Ctxt->getCanonicalDIEOffset() &&
                       Info.Ctxt->isDefinedInClangModule();
    // If the referenced DIE has a DeclContext that has already been
    // emitted, then do not keep the one in this CU. We'll link to
    // the canonical DIE in cloneDieReferenceAttribute.
    // FIXME: compatibility with dsymutil-classic. UseODR shouldn't
    // be necessary and could be advantageously replaced by
    // ReferencedCU->hasODR() && CU.hasODR().
    // FIXME: compatibility with dsymutil-classic. There is no
    // reason not to unique ref_addr references.
    if (AttrSpec.Form != dwarf::DW_FORM_ref_addr && (UseODR || IsModuleRef) &&
        Info.Ctxt &&
        Info.Ctxt != ReferencedCU->getInfo(Info.ParentIdx).Ctxt &&
        Info.Ctxt->getCanonicalDIEOffset() && isODRAttribute(AttrSpec.Attr))
      continue;

    // Keep a module forward declaration if there is no definition.
    if (!(isODRAttribute(AttrSpec.Attr) && Info.Ctxt &&
          Info.Ctxt->getCanonicalDIEOffset()))
      Info.Prune = false;

    unsigned ODRFlag = UseODR ? TF_ODR : 0;
    lookForDIEsToKeep(RelocMgr, Ranges, Units, RefDie, DMO, *ReferencedCU,
                      TF_Keep | TF_DependencyWalk | ODRFlag);

    // The incomplete property is propagated if the current DIE is complete
    // but references an incomplete DIE.
    if (Info.Incomplete && !MyInfo.Incomplete &&
        (Die.getTag() == dwarf::DW_TAG_typedef ||
         Die.getTag() == dwarf::DW_TAG_member ||
         Die.getTag() == dwarf::DW_TAG_reference_type ||
         Die.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
         Die.getTag() == dwarf::DW_TAG_pointer_type))
      MyInfo.Incomplete = true;
  }
}
804}

806namespace {
807/// This class represents an item in the work list. In addition to it's obvious
808/// purpose of representing the state associated with a particular run of the
809/// work loop, it also serves as a marker to indicate that we should run the
810/// "continuation" code.
811///
812/// Originally, the latter was lambda which allowed arbitrary code to be run.
813/// Because we always need to run the exact same code, it made more sense to
814/// use a boolean and repurpose the already existing DIE field.
815struct WorklistItem {
DWARFDie Die;
unsigned Flags;
bool IsContinuation;
CompileUnit::DIEInfo *ChildInfo = nullptr;

/// Construct a classic worklist item.
WorklistItem(DWARFDie Die, unsigned Flags)
    : Die(Die), Flags(Flags), IsContinuation(false){};

/// Creates a continuation marker.
WorklistItem(DWARFDie Die) : Die(Die), IsContinuation(true){};
827};
828} // namespace

830// Helper that updates the completeness of the current DIE. It depends on the
831// fact that the incompletness of its children is already computed.
832static void updateIncompleteness(const DWARFDie &Die,
                               CompileUnit::DIEInfo &ChildInfo,
                               CompileUnit &CU) {
// Only propagate incomplete members.
if (Die.getTag() != dwarf::DW_TAG_structure_type &&
    Die.getTag() != dwarf::DW_TAG_class_type)
  return;

unsigned Idx = CU.getOrigUnit().getDIEIndex(Die);
CompileUnit::DIEInfo &MyInfo = CU.getInfo(Idx);

if (MyInfo.Incomplete)
  return;

if (ChildInfo.Incomplete || ChildInfo.Prune)
  MyInfo.Incomplete = true;
848}

850/// Recursively walk the \p DIE tree and look for DIEs to
851/// keep. Store that information in \p CU's DIEInfo.
852///
853/// This function is the entry point of the DIE selection
854/// algorithm. It is expected to walk the DIE tree in file order and
855/// (though the mediation of its helper) call hasValidRelocation() on
856/// each DIE that might be a 'root DIE' (See DwarfLinker class
857/// comment).
858/// While walking the dependencies of root DIEs, this function is
859/// also called, but during these dependency walks the file order is
860/// not respected. The TF_DependencyWalk flag tells us which kind of
861/// traversal we are currently doing.
862///
863/// The return value indicates whether the DIE is incomplete.
864void DwarfLinker::lookForDIEsToKeep(RelocationManager &RelocMgr,
                                  RangesTy &Ranges, const UnitListTy &Units,
                                  const DWARFDie &Die,
                                  const DebugMapObject &DMO, CompileUnit &CU,
                                  unsigned Flags) {
// LIFO work list.
SmallVector<WorklistItem, 4> Worklist;
Worklist.emplace_back(Die, Flags);

while (!Worklist.empty()) {
  WorklistItem Current = Worklist.back();
  Worklist.pop_back();

  if (Current.IsContinuation) {
    updateIncompleteness(Current.Die, *Current.ChildInfo, CU);
    continue;
  }

  unsigned Idx = CU.getOrigUnit().getDIEIndex(Current.Die);
  CompileUnit::DIEInfo &MyInfo = CU.getInfo(Idx);

  // At this point we are guaranteed to have a continuation marker before us
  // in the worklist, except for the last DIE.
  if (!Worklist.empty())
    Worklist.back().ChildInfo = &MyInfo;

  if (MyInfo.Prune)
    continue;

  // If the Keep flag is set, we are marking a required DIE's dependencies.
  // If our target is already marked as kept, we're all set.
  bool AlreadyKept = MyInfo.Keep;
  if ((Current.Flags & TF_DependencyWalk) && AlreadyKept)
    continue;

  // We must not call shouldKeepDIE while called from keepDIEAndDependencies,
  // because it would screw up the relocation finding logic.
  if (!(Current.Flags & TF_DependencyWalk))
    Current.Flags = shouldKeepDIE(RelocMgr, Ranges, Current.Die, DMO, CU,
                                  MyInfo, Current.Flags);

  // If it is a newly kept DIE mark it as well as all its dependencies as
  // kept.
  if (!AlreadyKept && (Current.Flags & TF_Keep)) {
    bool UseOdr = (Current.Flags & TF_DependencyWalk)
                      ? (Current.Flags & TF_ODR)
                      : CU.hasODR();
    keepDIEAndDependencies(RelocMgr, Ranges, Units, Current.Die, MyInfo, DMO,
                           CU, UseOdr);
  }

  // The TF_ParentWalk flag tells us that we are currently walking up
  // the parent chain of a required DIE, and we don't want to mark all
  // the children of the parents as kept (consider for example a
  // DW_TAG_namespace node in the parent chain). There are however a
  // set of DIE types for which we want to ignore that directive and still
  // walk their children.
  if (dieNeedsChildrenToBeMeaningful(Current.Die.getTag()))
    Current.Flags &= ~TF_ParentWalk;

  if (!Current.Die.hasChildren() || (Current.Flags & TF_ParentWalk))
    continue;

  // Add children in reverse order to the worklist to effectively process
  // them in order.
  for (auto Child : reverse(Current.Die.children())) {
    // Add continuation marker before every child to calculate incompleteness
    // after the last child is processed. We can't store this information in
    // the same item because we might have to process other continuations
    // first.
    Worklist.emplace_back(Current.Die);
    Worklist.emplace_back(Child, Current.Flags);
  }
}
938}

940/// Assign an abbreviation number to \p Abbrev.
941///
942/// Our DIEs get freed after every DebugMapObject has been processed,
943/// thus the FoldingSet we use to unique DIEAbbrevs cannot refer to
944/// the instances hold by the DIEs. When we encounter an abbreviation
945/// that we don't know, we create a permanent copy of it.
946void DwarfLinker::AssignAbbrev(DIEAbbrev &Abbrev) {
// Check the set for priors.
FoldingSetNodeID ID;
Abbrev.Profile(ID);
void *InsertToken;
DIEAbbrev *InSet = AbbreviationsSet.FindNodeOrInsertPos(ID, InsertToken);

// If it's newly added.
if (InSet) {
  // Assign existing abbreviation number.
  Abbrev.setNumber(InSet->getNumber());
} else {
  // Add to abbreviation list.
  Abbreviations.push_back(
      llvm::make_unique<DIEAbbrev>(Abbrev.getTag(), Abbrev.hasChildren()));
  for (const auto &Attr : Abbrev.getData())
    Abbreviations.back()->AddAttribute(Attr.getAttribute(), Attr.getForm());
  AbbreviationsSet.InsertNode(Abbreviations.back().get(), InsertToken);
  // Assign the unique abbreviation number.
  Abbrev.setNumber(Abbreviations.size());
  Abbreviations.back()->setNumber(Abbreviations.size());
}
968}

970unsigned DwarfLinker::DIECloner::cloneStringAttribute(
  DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
  const DWARFUnit &U, OffsetsStringPool &StringPool, AttributesInfo &Info) {
// Switch everything to out of line strings.
const char *String = *Val.getAsCString();
auto StringEntry = StringPool.getEntry(String);

// Update attributes info.
if (AttrSpec.Attr == dwarf::DW_AT_name)
  Info.Name = StringEntry;
else if (AttrSpec.Attr == dwarf::DW_AT_MIPS_linkage_name ||
         AttrSpec.Attr == dwarf::DW_AT_linkage_name)
  Info.MangledName = StringEntry;

Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr), dwarf::DW_FORM_strp,
             DIEInteger(StringEntry.getOffset()));

return 4;
988}

990unsigned DwarfLinker::DIECloner::cloneDieReferenceAttribute(
  DIE &Die, const DWARFDie &InputDIE, AttributeSpec AttrSpec,
  unsigned AttrSize, const DWARFFormValue &Val, const DebugMapObject &DMO,
  CompileUnit &Unit) {
const DWARFUnit &U = Unit.getOrigUnit();
uint32_t Ref = *Val.getAsReference();
DIE *NewRefDie = nullptr;
CompileUnit *RefUnit = nullptr;
DeclContext *Ctxt = nullptr;

DWARFDie RefDie =
    resolveDIEReference(Linker, DMO, CompileUnits, Val, U, InputDIE, RefUnit);

// If the referenced DIE is not found,  drop the attribute.
if (!RefDie || AttrSpec.Attr == dwarf::DW_AT_sibling)
  return 0;

unsigned Idx = RefUnit->getOrigUnit().getDIEIndex(RefDie);
CompileUnit::DIEInfo &RefInfo = RefUnit->getInfo(Idx);

// If we already have emitted an equivalent DeclContext, just point
// at it.
if (isODRAttribute(AttrSpec.Attr)) {
  Ctxt = RefInfo.Ctxt;
  if (Ctxt && Ctxt->getCanonicalDIEOffset()) {
    DIEInteger Attr(Ctxt->getCanonicalDIEOffset());
    Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                 dwarf::DW_FORM_ref_addr, Attr);
    return U.getRefAddrByteSize();
  }
}

if (!RefInfo.Clone) {
  assert(Ref > InputDIE.getOffset())((Ref > InputDIE.getOffset()) ? static_cast<void> (0
) : __assert_fail ("Ref > InputDIE.getOffset()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1023, __PRETTY_FUNCTION__));
  // We haven't cloned this DIE yet. Just create an empty one and
  // store it. It'll get really cloned when we process it.
  RefInfo.Clone = DIE::get(DIEAlloc, dwarf::Tag(RefDie.getTag()));
}
NewRefDie = RefInfo.Clone;

if (AttrSpec.Form == dwarf::DW_FORM_ref_addr ||
    (Unit.hasODR() && isODRAttribute(AttrSpec.Attr))) {
  // We cannot currently rely on a DIEEntry to emit ref_addr
  // references, because the implementation calls back to DwarfDebug
  // to find the unit offset. (We don't have a DwarfDebug)
  // FIXME: we should be able to design DIEEntry reliance on
  // DwarfDebug away.
  uint64_t Attr;
  if (Ref < InputDIE.getOffset()) {
    // We must have already cloned that DIE.
    uint32_t NewRefOffset =
        RefUnit->getStartOffset() + NewRefDie->getOffset();
    Attr = NewRefOffset;
    Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                 dwarf::DW_FORM_ref_addr, DIEInteger(Attr));
  } else {
    // A forward reference. Note and fixup later.
    Attr = 0xBADDEF;
    Unit.noteForwardReference(
        NewRefDie, RefUnit, Ctxt,
        Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                     dwarf::DW_FORM_ref_addr, DIEInteger(Attr)));
  }
  return U.getRefAddrByteSize();
}

Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
             dwarf::Form(AttrSpec.Form), DIEEntry(*NewRefDie));
return AttrSize;
1059}

1061unsigned DwarfLinker::DIECloner::cloneBlockAttribute(DIE &Die,
                                                   AttributeSpec AttrSpec,
                                                   const DWARFFormValue &Val,
                                                   unsigned AttrSize) {
DIEValueList *Attr;
DIEValue Value;
DIELoc *Loc = nullptr;
DIEBlock *Block = nullptr;
// Just copy the block data over.
if (AttrSpec.Form == dwarf::DW_FORM_exprloc) {
  Loc = new (DIEAlloc) DIELoc;
  Linker.DIELocs.push_back(Loc);
} else {
  Block = new (DIEAlloc) DIEBlock;
  Linker.DIEBlocks.push_back(Block);
}
Attr = Loc ? static_cast<DIEValueList *>(Loc)
           : static_cast<DIEValueList *>(Block);

if (Loc)
  Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
                   dwarf::Form(AttrSpec.Form), Loc);
else
  Value = DIEValue(dwarf::Attribute(AttrSpec.Attr),
                   dwarf::Form(AttrSpec.Form), Block);
ArrayRef<uint8_t> Bytes = *Val.getAsBlock();
for (auto Byte : Bytes)
  Attr->addValue(DIEAlloc, static_cast<dwarf::Attribute>(0),
                 dwarf::DW_FORM_data1, DIEInteger(Byte));
// FIXME: If DIEBlock and DIELoc just reuses the Size field of
// the DIE class, this if could be replaced by
// Attr->setSize(Bytes.size()).
if (Linker.Streamer) {
  auto *AsmPrinter = &Linker.Streamer->getAsmPrinter();
  if (Loc)
    Loc->ComputeSize(AsmPrinter);
  else
    Block->ComputeSize(AsmPrinter);
}
Die.addValue(DIEAlloc, Value);
return AttrSize;
1102}

1104unsigned DwarfLinker::DIECloner::cloneAddressAttribute(
  DIE &Die, AttributeSpec AttrSpec, const DWARFFormValue &Val,
  const CompileUnit &Unit, AttributesInfo &Info) {
uint64_t Addr = *Val.getAsAddress();

if (LLVM_UNLIKELY(Linker.Options.Update)__builtin_expect((bool)(Linker.Options.Update), false)) {
  if (AttrSpec.Attr == dwarf::DW_AT_low_pc)
    Info.HasLowPc = true;
  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
               dwarf::Form(AttrSpec.Form), DIEInteger(Addr));
  return Unit.getOrigUnit().getAddressByteSize();
}

if (AttrSpec.Attr == dwarf::DW_AT_low_pc) {
  if (Die.getTag() == dwarf::DW_TAG_inlined_subroutine ||
      Die.getTag() == dwarf::DW_TAG_lexical_block)
    // The low_pc of a block or inline subroutine might get
    // relocated because it happens to match the low_pc of the
    // enclosing subprogram. To prevent issues with that, always use
    // the low_pc from the input DIE if relocations have been applied.
    Addr = (Info.OrigLowPc != std::numeric_limits<uint64_t>::max()
                ? Info.OrigLowPc
                : Addr) +
           Info.PCOffset;
  else if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
    Addr = Unit.getLowPc();
    if (Addr == std::numeric_limits<uint64_t>::max())
      return 0;
  }
  Info.HasLowPc = true;
} else if (AttrSpec.Attr == dwarf::DW_AT_high_pc) {
  if (Die.getTag() == dwarf::DW_TAG_compile_unit) {
    if (uint64_t HighPc = Unit.getHighPc())
      Addr = HighPc;
    else
      return 0;
  } else
    // If we have a high_pc recorded for the input DIE, use
    // it. Otherwise (when no relocations where applied) just use the
    // one we just decoded.
    Addr = (Info.OrigHighPc ? Info.OrigHighPc : Addr) + Info.PCOffset;
}

Die.addValue(DIEAlloc, static_cast<dwarf::Attribute>(AttrSpec.Attr),
             static_cast<dwarf::Form>(AttrSpec.Form), DIEInteger(Addr));
return Unit.getOrigUnit().getAddressByteSize();
1150}

1152unsigned DwarfLinker::DIECloner::cloneScalarAttribute(
  DIE &Die, const DWARFDie &InputDIE, const DebugMapObject &DMO,
  CompileUnit &Unit, AttributeSpec AttrSpec, const DWARFFormValue &Val,
  unsigned AttrSize, AttributesInfo &Info) {
uint64_t Value;

if (LLVM_UNLIKELY(Linker.Options.Update)__builtin_expect((bool)(Linker.Options.Update), false)) {
  if (auto OptionalValue = Val.getAsUnsignedConstant())
    Value = *OptionalValue;
  else if (auto OptionalValue = Val.getAsSignedConstant())
    Value = *OptionalValue;
  else if (auto OptionalValue = Val.getAsSectionOffset())
    Value = *OptionalValue;
  else {
    Linker.reportWarning(
        "Unsupported scalar attribute form. Dropping attribute.", DMO,
        &InputDIE);
    return 0;
  }
  if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
    Info.IsDeclaration = true;
  Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
               dwarf::Form(AttrSpec.Form), DIEInteger(Value));
  return AttrSize;
}

if (AttrSpec.Attr == dwarf::DW_AT_high_pc &&
    Die.getTag() == dwarf::DW_TAG_compile_unit) {
  if (Unit.getLowPc() == -1ULL)
    return 0;
  // Dwarf >= 4 high_pc is an size, not an address.
  Value = Unit.getHighPc() - Unit.getLowPc();
} else if (AttrSpec.Form == dwarf::DW_FORM_sec_offset)
  Value = *Val.getAsSectionOffset();
else if (AttrSpec.Form == dwarf::DW_FORM_sdata)
  Value = *Val.getAsSignedConstant();
else if (auto OptionalValue = Val.getAsUnsignedConstant())
  Value = *OptionalValue;
else {
  Linker.reportWarning(
      "Unsupported scalar attribute form. Dropping attribute.", DMO,
      &InputDIE);
  return 0;
}
PatchLocation Patch =
    Die.addValue(DIEAlloc, dwarf::Attribute(AttrSpec.Attr),
                 dwarf::Form(AttrSpec.Form), DIEInteger(Value));
if (AttrSpec.Attr == dwarf::DW_AT_ranges) {
  Unit.noteRangeAttribute(Die, Patch);
  Info.HasRanges = true;
}

// A more generic way to check for location attributes would be
// nice, but it's very unlikely that any other attribute needs a
// location list.
else if (AttrSpec.Attr == dwarf::DW_AT_location ||
         AttrSpec.Attr == dwarf::DW_AT_frame_base)
  Unit.noteLocationAttribute(Patch, Info.PCOffset);
else if (AttrSpec.Attr == dwarf::DW_AT_declaration && Value)
  Info.IsDeclaration = true;

return AttrSize;
1214}

1216/// Clone \p InputDIE's attribute described by \p AttrSpec with
1217/// value \p Val, and add it to \p Die.
1218/// \returns the size of the cloned attribute.
1219unsigned DwarfLinker::DIECloner::cloneAttribute(
  DIE &Die, const DWARFDie &InputDIE, const DebugMapObject &DMO,
  CompileUnit &Unit, OffsetsStringPool &StringPool, const DWARFFormValue &Val,
  const AttributeSpec AttrSpec, unsigned AttrSize, AttributesInfo &Info) {
const DWARFUnit &U = Unit.getOrigUnit();

switch (AttrSpec.Form) {
case dwarf::DW_FORM_strp:
case dwarf::DW_FORM_string:
  return cloneStringAttribute(Die, AttrSpec, Val, U, StringPool, Info);
case dwarf::DW_FORM_ref_addr:
case dwarf::DW_FORM_ref1:
case dwarf::DW_FORM_ref2:
case dwarf::DW_FORM_ref4:
case dwarf::DW_FORM_ref8:
  return cloneDieReferenceAttribute(Die, InputDIE, AttrSpec, AttrSize, Val,
                                    DMO, Unit);
case dwarf::DW_FORM_block:
case dwarf::DW_FORM_block1:
case dwarf::DW_FORM_block2:
case dwarf::DW_FORM_block4:
case dwarf::DW_FORM_exprloc:
  return cloneBlockAttribute(Die, AttrSpec, Val, AttrSize);
case dwarf::DW_FORM_addr:
  return cloneAddressAttribute(Die, AttrSpec, Val, Unit, Info);
case dwarf::DW_FORM_data1:
case dwarf::DW_FORM_data2:
case dwarf::DW_FORM_data4:
case dwarf::DW_FORM_data8:
case dwarf::DW_FORM_udata:
case dwarf::DW_FORM_sdata:
case dwarf::DW_FORM_sec_offset:
case dwarf::DW_FORM_flag:
case dwarf::DW_FORM_flag_present:
  return cloneScalarAttribute(Die, InputDIE, DMO, Unit, AttrSpec, Val,
                              AttrSize, Info);
default:
  Linker.reportWarning(
      "Unsupported attribute form in cloneAttribute. Dropping.", DMO,
      &InputDIE);
}

return 0;
1262}

1264/// Apply the valid relocations found by findValidRelocs() to
1265/// the buffer \p Data, taking into account that Data is at \p BaseOffset
1266/// in the debug_info section.
1267///
1268/// Like for findValidRelocs(), this function must be called with
1269/// monotonic \p BaseOffset values.
1270///
1271/// \returns whether any reloc has been applied.
1272bool DwarfLinker::RelocationManager::applyValidRelocs(
  MutableArrayRef<char> Data, uint32_t BaseOffset, bool isLittleEndian) {
assert((NextValidReloc == 0 ||(((NextValidReloc == 0 || BaseOffset > ValidRelocs[NextValidReloc
 - 1].Offset) && "BaseOffset should only be increasing."
) ? static_cast<void> (0) : __assert_fail ("(NextValidReloc == 0 || BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) && \"BaseOffset should only be increasing.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1276, __PRETTY_FUNCTION__))
        BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) &&(((NextValidReloc == 0 || BaseOffset > ValidRelocs[NextValidReloc
 - 1].Offset) && "BaseOffset should only be increasing."
) ? static_cast<void> (0) : __assert_fail ("(NextValidReloc == 0 || BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) && \"BaseOffset should only be increasing.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1276, __PRETTY_FUNCTION__))
       "BaseOffset should only be increasing.")(((NextValidReloc == 0 || BaseOffset > ValidRelocs[NextValidReloc
 - 1].Offset) && "BaseOffset should only be increasing."
) ? static_cast<void> (0) : __assert_fail ("(NextValidReloc == 0 || BaseOffset > ValidRelocs[NextValidReloc - 1].Offset) && \"BaseOffset should only be increasing.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1276, __PRETTY_FUNCTION__));
if (NextValidReloc >= ValidRelocs.size())
  return false;

// Skip relocs that haven't been applied.
while (NextValidReloc < ValidRelocs.size() &&
       ValidRelocs[NextValidReloc].Offset < BaseOffset)
  ++NextValidReloc;

bool Applied = false;
uint64_t EndOffset = BaseOffset + Data.size();
while (NextValidReloc < ValidRelocs.size() &&
       ValidRelocs[NextValidReloc].Offset >= BaseOffset &&
       ValidRelocs[NextValidReloc].Offset < EndOffset) {
  const auto &ValidReloc = ValidRelocs[NextValidReloc++];
  assert(ValidReloc.Offset - BaseOffset < Data.size())((ValidReloc.Offset - BaseOffset < Data.size()) ? static_cast
<void> (0) : __assert_fail ("ValidReloc.Offset - BaseOffset < Data.size()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1291, __PRETTY_FUNCTION__));
  assert(ValidReloc.Offset - BaseOffset + ValidReloc.Size <= Data.size())((ValidReloc.Offset - BaseOffset + ValidReloc.Size <= Data
.size()) ? static_cast<void> (0) : __assert_fail ("ValidReloc.Offset - BaseOffset + ValidReloc.Size <= Data.size()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1292, __PRETTY_FUNCTION__));
  char Buf[8];
  uint64_t Value = ValidReloc.Mapping->getValue().BinaryAddress;
  Value += ValidReloc.Addend;
  for (unsigned i = 0; i != ValidReloc.Size; ++i) {
    unsigned Index = isLittleEndian ? i : (ValidReloc.Size - i - 1);
    Buf[i] = uint8_t(Value >> (Index * 8));
  }
  assert(ValidReloc.Size <= sizeof(Buf))((ValidReloc.Size <= sizeof(Buf)) ? static_cast<void>
 (0) : __assert_fail ("ValidReloc.Size <= sizeof(Buf)", "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1300, __PRETTY_FUNCTION__));
  memcpy(&Data[ValidReloc.Offset - BaseOffset], Buf, ValidReloc.Size);
  Applied = true;
}

return Applied;
1306}

1308static bool isObjCSelector(StringRef Name) {
return Name.size() > 2 && (Name[0] == '-' || Name[0] == '+') &&
       (Name[1] == '[');
1311}

1313void DwarfLinker::DIECloner::addObjCAccelerator(CompileUnit &Unit,
                                              const DIE *Die,
                                              DwarfStringPoolEntryRef Name,
                                              OffsetsStringPool &StringPool,
                                              bool SkipPubSection) {
assert(isObjCSelector(Name.getString()) && "not an objc selector")((isObjCSelector(Name.getString()) && "not an objc selector"
) ? static_cast<void> (0) : __assert_fail ("isObjCSelector(Name.getString()) && \"not an objc selector\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1318, __PRETTY_FUNCTION__));
// Objective C method or class function.
// "- [Class(Category) selector :withArg ...]"
StringRef ClassNameStart(Name.getString().drop_front(2));
size_t FirstSpace = ClassNameStart.find(' ');
if (FirstSpace == StringRef::npos)
  return;

StringRef SelectorStart(ClassNameStart.data() + FirstSpace + 1);
if (!SelectorStart.size())
  return;

StringRef Selector(SelectorStart.data(), SelectorStart.size() - 1);
Unit.addNameAccelerator(Die, StringPool.getEntry(Selector), SkipPubSection);

// Add an entry for the class name that points to this
// method/class function.
StringRef ClassName(ClassNameStart.data(), FirstSpace);
Unit.addObjCAccelerator(Die, StringPool.getEntry(ClassName), SkipPubSection);

if (ClassName[ClassName.size() - 1] == ')') {
  size_t OpenParens = ClassName.find('(');
  if (OpenParens != StringRef::npos) {
    StringRef ClassNameNoCategory(ClassName.data(), OpenParens);
    Unit.addObjCAccelerator(Die, StringPool.getEntry(ClassNameNoCategory),
                            SkipPubSection);

    std::string MethodNameNoCategory(Name.getString().data(), OpenParens + 2);
    // FIXME: The missing space here may be a bug, but
    //        dsymutil-classic also does it this way.
    MethodNameNoCategory.append(SelectorStart);
    Unit.addNameAccelerator(Die, StringPool.getEntry(MethodNameNoCategory),
                            SkipPubSection);
  }
}
1353}

1355static bool
1356shouldSkipAttribute(DWARFAbbreviationDeclaration::AttributeSpec AttrSpec,
                  uint16_t Tag, bool InDebugMap, bool SkipPC,
                  bool InFunctionScope) {
switch (AttrSpec.Attr) {
default:
  return false;
case dwarf::DW_AT_low_pc:
case dwarf::DW_AT_high_pc:
case dwarf::DW_AT_ranges:
  return SkipPC;
case dwarf::DW_AT_location:
case dwarf::DW_AT_frame_base:
  // FIXME: for some reason dsymutil-classic keeps the location attributes
  // when they are of block type (i.e. not location lists). This is totally
  // wrong for globals where we will keep a wrong address. It is mostly
  // harmless for locals, but there is no point in keeping these anyway when
  // the function wasn't linked.
  return (SkipPC || (!InFunctionScope && Tag == dwarf::DW_TAG_variable &&
                     !InDebugMap)) &&
         !DWARFFormValue(AttrSpec.Form).isFormClass(DWARFFormValue::FC_Block);
}
1377}

1379DIE *DwarfLinker::DIECloner::cloneDIE(const DWARFDie &InputDIE,
                                    const DebugMapObject &DMO,
                                    CompileUnit &Unit,
                                    OffsetsStringPool &StringPool,
                                    int64_t PCOffset, uint32_t OutOffset,
                                    unsigned Flags, DIE *Die) {
DWARFUnit &U = Unit.getOrigUnit();
unsigned Idx = U.getDIEIndex(InputDIE);
CompileUnit::DIEInfo &Info = Unit.getInfo(Idx);

// Should the DIE appear in the output?
if (!Unit.getInfo(Idx).Keep)
  return nullptr;

uint32_t Offset = InputDIE.getOffset();
assert(!(Die && Info.Clone) && "Can't supply a DIE and a cloned DIE")((!(Die && Info.Clone) && "Can't supply a DIE and a cloned DIE"
) ? static_cast<void> (0) : __assert_fail ("!(Die && Info.Clone) && \"Can't supply a DIE and a cloned DIE\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1394, __PRETTY_FUNCTION__));
if (!Die) {
  // The DIE might have been already created by a forward reference
  // (see cloneDieReferenceAttribute()).
  if (!Info.Clone)
    Info.Clone = DIE::get(DIEAlloc, dwarf::Tag(InputDIE.getTag()));
  Die = Info.Clone;
}

assert(Die->getTag() == InputDIE.getTag())((Die->getTag() == InputDIE.getTag()) ? static_cast<void
> (0) : __assert_fail ("Die->getTag() == InputDIE.getTag()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1403, __PRETTY_FUNCTION__));
Die->setOffset(OutOffset);
if ((Unit.hasODR() || Unit.isClangModule()) && !Info.Incomplete &&
    Die->getTag() != dwarf::DW_TAG_namespace && Info.Ctxt &&
    Info.Ctxt != Unit.getInfo(Info.ParentIdx).Ctxt &&
    !Info.Ctxt->getCanonicalDIEOffset()) {
  // We are about to emit a DIE that is the root of its own valid
  // DeclContext tree. Make the current offset the canonical offset
  // for this context.
  Info.Ctxt->setCanonicalDIEOffset(OutOffset + Unit.getStartOffset());
}

// Extract and clone every attribute.
DWARFDataExtractor Data = U.getDebugInfoExtractor();
// Point to the next DIE (generally there is always at least a NULL
// entry after the current one). If this is a lone
// DW_TAG_compile_unit without any children, point to the next unit.
uint32_t NextOffset = (Idx + 1 < U.getNumDIEs())
                          ? U.getDIEAtIndex(Idx + 1).getOffset()
                          : U.getNextUnitOffset();
AttributesInfo AttrInfo;

// We could copy the data only if we need to apply a relocation to it. After
// testing, it seems there is no performance downside to doing the copy
// unconditionally, and it makes the code simpler.
SmallString<40> DIECopy(Data.getData().substr(Offset, NextOffset - Offset));
Data =
    DWARFDataExtractor(DIECopy, Data.isLittleEndian(), Data.getAddressSize());
// Modify the copy with relocated addresses.
if (RelocMgr.applyValidRelocs(DIECopy, Offset, Data.isLittleEndian())) {
  // If we applied relocations, we store the value of high_pc that was
  // potentially stored in the input DIE. If high_pc is an address
  // (Dwarf version == 2), then it might have been relocated to a
  // totally unrelated value (because the end address in the object
  // file might be start address of another function which got moved
  // independently by the linker). The computation of the actual
  // high_pc value is done in cloneAddressAttribute().
  AttrInfo.OrigHighPc =
      dwarf::toAddress(InputDIE.find(dwarf::DW_AT_high_pc), 0);
  // Also store the low_pc. It might get relocated in an
  // inline_subprogram that happens at the beginning of its
  // inlining function.
  AttrInfo.OrigLowPc = dwarf::toAddress(InputDIE.find(dwarf::DW_AT_low_pc),
                                        std::numeric_limits<uint64_t>::max());
}

// Reset the Offset to 0 as we will be working on the local copy of
// the data.
Offset = 0;

const auto *Abbrev = InputDIE.getAbbreviationDeclarationPtr();
Offset += getULEB128Size(Abbrev->getCode());

// We are entering a subprogram. Get and propagate the PCOffset.
if (Die->getTag() == dwarf::DW_TAG_subprogram)
  PCOffset = Info.AddrAdjust;
AttrInfo.PCOffset = PCOffset;

if (Abbrev->getTag() == dwarf::DW_TAG_subprogram) {
  Flags |= TF_InFunctionScope;
  if (!Info.InDebugMap && LLVM_LIKELY(!Options.Update)__builtin_expect((bool)(!Options.Update), true))
    Flags |= TF_SkipPC;
}

bool Copied = false;
for (const auto &AttrSpec : Abbrev->attributes()) {
  if (LLVM_LIKELY(!Options.Update)__builtin_expect((bool)(!Options.Update), true) &&
      shouldSkipAttribute(AttrSpec, Die->getTag(), Info.InDebugMap,
                          Flags & TF_SkipPC, Flags & TF_InFunctionScope)) {
    DWARFFormValue::skipValue(AttrSpec.Form, Data, &Offset,
                              U.getFormParams());
    // FIXME: dsymutil-classic keeps the old abbreviation around
    // even if it's not used. We can remove this (and the copyAbbrev
    // helper) as soon as bit-for-bit compatibility is not a goal anymore.
    if (!Copied) {
      copyAbbrev(*InputDIE.getAbbreviationDeclarationPtr(), Unit.hasODR());
      Copied = true;
    }
    continue;
  }

  DWARFFormValue Val(AttrSpec.Form);
  uint32_t AttrSize = Offset;
  Val.extractValue(Data, &Offset, U.getFormParams(), &U);
  AttrSize = Offset - AttrSize;

  OutOffset += cloneAttribute(*Die, InputDIE, DMO, Unit, StringPool, Val,
                              AttrSpec, AttrSize, AttrInfo);
}

// Look for accelerator entries.
uint16_t Tag = InputDIE.getTag();
// FIXME: This is slightly wrong. An inline_subroutine without a
// low_pc, but with AT_ranges might be interesting to get into the
// accelerator tables too. For now stick with dsymutil's behavior.
if ((Info.InDebugMap || AttrInfo.HasLowPc || AttrInfo.HasRanges) &&
    Tag != dwarf::DW_TAG_compile_unit &&
    getDIENames(InputDIE, AttrInfo, StringPool,
                Tag != dwarf::DW_TAG_inlined_subroutine)) {
  if (AttrInfo.MangledName && AttrInfo.MangledName != AttrInfo.Name)
    Unit.addNameAccelerator(Die, AttrInfo.MangledName,
                            Tag == dwarf::DW_TAG_inlined_subroutine);
  if (AttrInfo.Name) {
    if (AttrInfo.NameWithoutTemplate)
      Unit.addNameAccelerator(Die, AttrInfo.NameWithoutTemplate,
                              /* SkipPubSection */ true);
    Unit.addNameAccelerator(Die, AttrInfo.Name,
                            Tag == dwarf::DW_TAG_inlined_subroutine);
  }
  if (AttrInfo.Name && isObjCSelector(AttrInfo.Name.getString()))
    addObjCAccelerator(Unit, Die, AttrInfo.Name, StringPool,
                       /* SkipPubSection =*/true);

} else if (Tag == dwarf::DW_TAG_namespace) {
  if (!AttrInfo.Name)
    AttrInfo.Name = StringPool.getEntry("(anonymous namespace)");
  Unit.addNamespaceAccelerator(Die, AttrInfo.Name);
} else if (isTypeTag(Tag) && !AttrInfo.IsDeclaration &&
           getDIENames(InputDIE, AttrInfo, StringPool) && AttrInfo.Name &&
           AttrInfo.Name.getString()[0]) {
  uint32_t Hash = hashFullyQualifiedName(InputDIE, Unit, DMO);
  uint64_t RuntimeLang =
      dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_runtime_class))
          .getValueOr(0);
  bool ObjCClassIsImplementation =
      (RuntimeLang == dwarf::DW_LANG_ObjC ||
       RuntimeLang == dwarf::DW_LANG_ObjC_plus_plus) &&
      dwarf::toUnsigned(InputDIE.find(dwarf::DW_AT_APPLE_objc_complete_type))
          .getValueOr(0);
  Unit.addTypeAccelerator(Die, AttrInfo.Name, ObjCClassIsImplementation,
                          Hash);
}

// Determine whether there are any children that we want to keep.
bool HasChildren = false;
for (auto Child : InputDIE.children()) {
  unsigned Idx = U.getDIEIndex(Child);
  if (Unit.getInfo(Idx).Keep) {
    HasChildren = true;
    break;
  }
}

DIEAbbrev NewAbbrev = Die->generateAbbrev();
if (HasChildren)
  NewAbbrev.setChildrenFlag(dwarf::DW_CHILDREN_yes);
// Assign a permanent abbrev number
Linker.AssignAbbrev(NewAbbrev);
Die->setAbbrevNumber(NewAbbrev.getNumber());

// Add the size of the abbreviation number to the output offset.
OutOffset += getULEB128Size(Die->getAbbrevNumber());

if (!HasChildren) {
  // Update our size.
  Die->setSize(OutOffset - Die->getOffset());
  return Die;
}

// Recursively clone children.
for (auto Child : InputDIE.children()) {
  if (DIE *Clone = cloneDIE(Child, DMO, Unit, StringPool, PCOffset, OutOffset,
                            Flags)) {
    Die->addChild(Clone);
    OutOffset = Clone->getOffset() + Clone->getSize();
  }
}

// Account for the end of children marker.
OutOffset += sizeof(int8_t);
// Update our size.
Die->setSize(OutOffset - Die->getOffset());
return Die;
1576}

1578/// Patch the input object file relevant debug_ranges entries
1579/// and emit them in the output file. Update the relevant attributes
1580/// to point at the new entries.
1581void DwarfLinker::patchRangesForUnit(const CompileUnit &Unit,
                                   DWARFContext &OrigDwarf,
                                   const DebugMapObject &DMO) const {
DWARFDebugRangeList RangeList;
const auto &FunctionRanges = Unit.getFunctionRanges();
unsigned AddressSize = Unit.getOrigUnit().getAddressByteSize();
DWARFDataExtractor RangeExtractor(OrigDwarf.getDWARFObj(),
                                  OrigDwarf.getDWARFObj().getRangeSection(),
                                  OrigDwarf.isLittleEndian(), AddressSize);
auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;
DWARFUnit &OrigUnit = Unit.getOrigUnit();
auto OrigUnitDie = OrigUnit.getUnitDIE(false);
uint64_t OrigLowPc =
    dwarf::toAddress(OrigUnitDie.find(dwarf::DW_AT_low_pc), -1ULL);
// Ranges addresses are based on the unit's low_pc. Compute the
// offset we need to apply to adapt to the new unit's low_pc.
int64_t UnitPcOffset = 0;
if (OrigLowPc != -1ULL)
  UnitPcOffset = int64_t(OrigLowPc) - Unit.getLowPc();

for (const auto &RangeAttribute : Unit.getRangesAttributes()) {
  uint32_t Offset = RangeAttribute.get();
  RangeAttribute.set(Streamer->getRangesSectionSize());
  if (Error E = RangeList.extract(RangeExtractor, &Offset)) {
    llvm::consumeError(std::move(E));
    reportWarning("invalid range list ignored.", DMO);
    RangeList.clear();
  }
  const auto &Entries = RangeList.getEntries();
  if (!Entries.empty()) {
    const DWARFDebugRangeList::RangeListEntry &First = Entries.front();

    if (CurrRange == InvalidRange ||
        First.StartAddress + OrigLowPc < CurrRange.start() ||
        First.StartAddress + OrigLowPc >= CurrRange.stop()) {
      CurrRange = FunctionRanges.find(First.StartAddress + OrigLowPc);
      if (CurrRange == InvalidRange ||
          CurrRange.start() > First.StartAddress + OrigLowPc) {
        reportWarning("no mapping for range.", DMO);
        continue;
      }
    }
  }

  Streamer->emitRangesEntries(UnitPcOffset, OrigLowPc, CurrRange, Entries,
                              AddressSize);
}
1628}

1630/// Generate the debug_aranges entries for \p Unit and if the
1631/// unit has a DW_AT_ranges attribute, also emit the debug_ranges
1632/// contribution for this attribute.
1633/// FIXME: this could actually be done right in patchRangesForUnit,
1634/// but for the sake of initial bit-for-bit compatibility with legacy
1635/// dsymutil, we have to do it in a delayed pass.
1636void DwarfLinker::generateUnitRanges(CompileUnit &Unit) const {
auto Attr = Unit.getUnitRangesAttribute();
if (Attr)
  Attr->set(Streamer->getRangesSectionSize());
Streamer->emitUnitRangesEntries(Unit, static_cast<bool>(Attr));
1641}

1643/// Insert the new line info sequence \p Seq into the current
1644/// set of already linked line info \p Rows.
1645static void insertLineSequence(std::vector<DWARFDebugLine::Row> &Seq,
                             std::vector<DWARFDebugLine::Row> &Rows) {
if (Seq.empty())
  return;

if (!Rows.empty() && Rows.back().Address < Seq.front().Address) {
  Rows.insert(Rows.end(), Seq.begin(), Seq.end());
  Seq.clear();
  return;
}

auto InsertPoint = std::lower_bound(
    Rows.begin(), Rows.end(), Seq.front(),
    [](const DWARFDebugLine::Row &LHS, const DWARFDebugLine::Row &RHS) {
      return LHS.Address < RHS.Address;
    });

// FIXME: this only removes the unneeded end_sequence if the
// sequences have been inserted in order. Using a global sort like
// described in patchLineTableForUnit() and delaying the end_sequene
// elimination to emitLineTableForUnit() we can get rid of all of them.
if (InsertPoint != Rows.end() &&
    InsertPoint->Address == Seq.front().Address && InsertPoint->EndSequence) {
  *InsertPoint = Seq.front();
  Rows.insert(InsertPoint + 1, Seq.begin() + 1, Seq.end());
} else {
  Rows.insert(InsertPoint, Seq.begin(), Seq.end());
}

Seq.clear();
1675}

1677static void patchStmtList(DIE &Die, DIEInteger Offset) {
for (auto &V : Die.values())
  if (V.getAttribute() == dwarf::DW_AT_stmt_list) {
    V = DIEValue(V.getAttribute(), V.getForm(), Offset);
    return;
  }

llvm_unreachable("Didn't find DW_AT_stmt_list in cloned DIE!")::llvm::llvm_unreachable_internal("Didn't find DW_AT_stmt_list in cloned DIE!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1684);
1685}

1687/// Extract the line table for \p Unit from \p OrigDwarf, and
1688/// recreate a relocated version of these for the address ranges that
1689/// are present in the binary.
1690void DwarfLinker::patchLineTableForUnit(CompileUnit &Unit,
                                      DWARFContext &OrigDwarf,
                                      RangesTy &Ranges,
                                      const DebugMapObject &DMO) {
DWARFDie CUDie = Unit.getOrigUnit().getUnitDIE();
auto StmtList = dwarf::toSectionOffset(CUDie.find(dwarf::DW_AT_stmt_list));
if (!StmtList)
  return;

// Update the cloned DW_AT_stmt_list with the correct debug_line offset.
if (auto *OutputDIE = Unit.getOutputUnitDIE())
  patchStmtList(*OutputDIE, DIEInteger(Streamer->getLineSectionSize()));

// Parse the original line info for the unit.
DWARFDebugLine::LineTable LineTable;
uint32_t StmtOffset = *StmtList;
DWARFDataExtractor LineExtractor(
    OrigDwarf.getDWARFObj(), OrigDwarf.getDWARFObj().getLineSection(),
    OrigDwarf.isLittleEndian(), Unit.getOrigUnit().getAddressByteSize());

Error Err = LineTable.parse(LineExtractor, &StmtOffset, OrigDwarf,
                            &Unit.getOrigUnit(), DWARFContext::dumpWarning);
DWARFContext::dumpWarning(std::move(Err));

// This vector is the output line table.
std::vector<DWARFDebugLine::Row> NewRows;
NewRows.reserve(LineTable.Rows.size());

// Current sequence of rows being extracted, before being inserted
// in NewRows.
std::vector<DWARFDebugLine::Row> Seq;
const auto &FunctionRanges = Unit.getFunctionRanges();
auto InvalidRange = FunctionRanges.end(), CurrRange = InvalidRange;

// FIXME: This logic is meant to generate exactly the same output as
// Darwin's classic dsymutil. There is a nicer way to implement this
// by simply putting all the relocated line info in NewRows and simply
// sorting NewRows before passing it to emitLineTableForUnit. This
// should be correct as sequences for a function should stay
// together in the sorted output. There are a few corner cases that
// look suspicious though, and that required to implement the logic
// this way. Revisit that once initial validation is finished.

// Iterate over the object file line info and extract the sequences
// that correspond to linked functions.
for (auto &Row : LineTable.Rows) {
  // Check whether we stepped out of the range. The range is
  // half-open, but consider accept the end address of the range if
  // it is marked as end_sequence in the input (because in that
  // case, the relocation offset is accurate and that entry won't
  // serve as the start of another function).
  if (CurrRange == InvalidRange || Row.Address < CurrRange.start() ||
      Row.Address > CurrRange.stop() ||
      (Row.Address == CurrRange.stop() && !Row.EndSequence)) {
    // We just stepped out of a known range. Insert a end_sequence
    // corresponding to the end of the range.
    uint64_t StopAddress = CurrRange != InvalidRange
                               ? CurrRange.stop() + CurrRange.value()
                               : -1ULL;
    CurrRange = FunctionRanges.find(Row.Address);
    bool CurrRangeValid =
        CurrRange != InvalidRange && CurrRange.start() <= Row.Address;
    if (!CurrRangeValid) {
      CurrRange = InvalidRange;
      if (StopAddress != -1ULL) {
        // Try harder by looking in the DebugMapObject function
        // ranges map. There are corner cases where this finds a
        // valid entry. It's unclear if this is right or wrong, but
        // for now do as dsymutil.
        // FIXME: Understand exactly what cases this addresses and
        // potentially remove it along with the Ranges map.
        auto Range = Ranges.lower_bound(Row.Address);
        if (Range != Ranges.begin() && Range != Ranges.end())
          --Range;

        if (Range != Ranges.end() && Range->first <= Row.Address &&
            Range->second.HighPC >= Row.Address) {
          StopAddress = Row.Address + Range->second.Offset;
        }
      }
    }
    if (StopAddress != -1ULL && !Seq.empty()) {
      // Insert end sequence row with the computed end address, but
      // the same line as the previous one.
      auto NextLine = Seq.back();
      NextLine.Address = StopAddress;
      NextLine.EndSequence = 1;
      NextLine.PrologueEnd = 0;
      NextLine.BasicBlock = 0;
      NextLine.EpilogueBegin = 0;
      Seq.push_back(NextLine);
      insertLineSequence(Seq, NewRows);
    }

    if (!CurrRangeValid)
      continue;
  }

  // Ignore empty sequences.
  if (Row.EndSequence && Seq.empty())
    continue;

  // Relocate row address and add it to the current sequence.
  Row.Address += CurrRange.value();
  Seq.emplace_back(Row);

  if (Row.EndSequence)
    insertLineSequence(Seq, NewRows);
}

// Finished extracting, now emit the line tables.
// FIXME: LLVM hard-codes its prologue values. We just copy the
// prologue over and that works because we act as both producer and
// consumer. It would be nicer to have a real configurable line
// table emitter.
if (LineTable.Prologue.getVersion() < 2 ||
    LineTable.Prologue.getVersion() > 5 ||
    LineTable.Prologue.DefaultIsStmt != DWARF2_LINE_DEFAULT_IS_STMT1 ||
    LineTable.Prologue.OpcodeBase > 13)
  reportWarning("line table parameters mismatch. Cannot emit.", DMO);
else {
  uint32_t PrologueEnd = *StmtList + 10 + LineTable.Prologue.PrologueLength;
  // DWARF v5 has an extra 2 bytes of information before the header_length
  // field.
  if (LineTable.Prologue.getVersion() == 5)
    PrologueEnd += 2;
  StringRef LineData = OrigDwarf.getDWARFObj().getLineSection().Data;
  MCDwarfLineTableParams Params;
  Params.DWARF2LineOpcodeBase = LineTable.Prologue.OpcodeBase;
  Params.DWARF2LineBase = LineTable.Prologue.LineBase;
  Params.DWARF2LineRange = LineTable.Prologue.LineRange;
  Streamer->emitLineTableForUnit(Params,
                                 LineData.slice(*StmtList + 4, PrologueEnd),
                                 LineTable.Prologue.MinInstLength, NewRows,
                                 Unit.getOrigUnit().getAddressByteSize());
}
1826}

1828void DwarfLinker::emitAcceleratorEntriesForUnit(CompileUnit &Unit) {
switch (Options.TheAccelTableKind) {
case AccelTableKind::Apple:
  emitAppleAcceleratorEntriesForUnit(Unit);
  break;
case AccelTableKind::Dwarf:
  emitDwarfAcceleratorEntriesForUnit(Unit);
  break;
case AccelTableKind::Default:
  llvm_unreachable("The default must be updated to a concrete value.")::llvm::llvm_unreachable_internal("The default must be updated to a concrete value."
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 1837);
  break;
}
1840}

1842void DwarfLinker::emitAppleAcceleratorEntriesForUnit(CompileUnit &Unit) {
// Add namespaces.
for (const auto &Namespace : Unit.getNamespaces())
  AppleNamespaces.addName(Namespace.Name,
                          Namespace.Die->getOffset() + Unit.getStartOffset());

/// Add names.
if (!Options.Minimize)
  Streamer->emitPubNamesForUnit(Unit);
for (const auto &Pubname : Unit.getPubnames())
  AppleNames.addName(Pubname.Name,
                     Pubname.Die->getOffset() + Unit.getStartOffset());

/// Add types.
if (!Options.Minimize)
  Streamer->emitPubTypesForUnit(Unit);
for (const auto &Pubtype : Unit.getPubtypes())
  AppleTypes.addName(
      Pubtype.Name, Pubtype.Die->getOffset() + Unit.getStartOffset(),
      Pubtype.Die->getTag(),
      Pubtype.ObjcClassImplementation ? dwarf::DW_FLAG_type_implementation
                                      : 0,
      Pubtype.QualifiedNameHash);

/// Add ObjC names.
for (const auto &ObjC : Unit.getObjC())
  AppleObjc.addName(ObjC.Name, ObjC.Die->getOffset() + Unit.getStartOffset());
1869}

1871void DwarfLinker::emitDwarfAcceleratorEntriesForUnit(CompileUnit &Unit) {
for (const auto &Namespace : Unit.getNamespaces())
  DebugNames.addName(Namespace.Name, Namespace.Die->getOffset(),
                     Namespace.Die->getTag(), Unit.getUniqueID());
for (const auto &Pubname : Unit.getPubnames())
  DebugNames.addName(Pubname.Name, Pubname.Die->getOffset(),
                     Pubname.Die->getTag(), Unit.getUniqueID());
for (const auto &Pubtype : Unit.getPubtypes())
  DebugNames.addName(Pubtype.Name, Pubtype.Die->getOffset(),
                     Pubtype.Die->getTag(), Unit.getUniqueID());
1881}

1883/// Read the frame info stored in the object, and emit the
1884/// patched frame descriptions for the linked binary.
1885///
1886/// This is actually pretty easy as the data of the CIEs and FDEs can
1887/// be considered as black boxes and moved as is. The only thing to do
1888/// is to patch the addresses in the headers.
1889void DwarfLinker::patchFrameInfoForObject(const DebugMapObject &DMO,
                                        RangesTy &Ranges,
                                        DWARFContext &OrigDwarf,
                                        unsigned AddrSize) {
StringRef FrameData = OrigDwarf.getDWARFObj().getDebugFrameSection();
if (FrameData.empty())
  return;

DataExtractor Data(FrameData, OrigDwarf.isLittleEndian(), 0);
uint32_t InputOffset = 0;

// Store the data of the CIEs defined in this object, keyed by their
// offsets.
DenseMap<uint32_t, StringRef> LocalCIES;

while (Data.isValidOffset(InputOffset)) {
  uint32_t EntryOffset = InputOffset;
  uint32_t InitialLength = Data.getU32(&InputOffset);
  if (InitialLength == 0xFFFFFFFF)
    return reportWarning("Dwarf64 bits no supported", DMO);

  uint32_t CIEId = Data.getU32(&InputOffset);
  if (CIEId == 0xFFFFFFFF) {
    // This is a CIE, store it.
    StringRef CIEData = FrameData.substr(EntryOffset, InitialLength + 4);
    LocalCIES[EntryOffset] = CIEData;
    // The -4 is to account for the CIEId we just read.
    InputOffset += InitialLength - 4;
    continue;
  }

  uint32_t Loc = Data.getUnsigned(&InputOffset, AddrSize);

  // Some compilers seem to emit frame info that doesn't start at
  // the function entry point, thus we can't just lookup the address
  // in the debug map. Use the linker's range map to see if the FDE
  // describes something that we can relocate.
  auto Range = Ranges.upper_bound(Loc);
  if (Range != Ranges.begin())
    --Range;
  if (Range == Ranges.end() || Range->first > Loc ||
      Range->second.HighPC <= Loc) {
    // The +4 is to account for the size of the InitialLength field itself.
    InputOffset = EntryOffset + InitialLength + 4;
    continue;
  }

  // This is an FDE, and we have a mapping.
  // Have we already emitted a corresponding CIE?
  StringRef CIEData = LocalCIES[CIEId];
  if (CIEData.empty())
    return reportWarning("Inconsistent debug_frame content. Dropping.", DMO);

  // Look if we already emitted a CIE that corresponds to the
  // referenced one (the CIE data is the key of that lookup).
  auto IteratorInserted = EmittedCIEs.insert(
      std::make_pair(CIEData, Streamer->getFrameSectionSize()));
  // If there is no CIE yet for this ID, emit it.
  if (IteratorInserted.second ||
      // FIXME: dsymutil-classic only caches the last used CIE for
      // reuse. Mimic that behavior for now. Just removing that
      // second half of the condition and the LastCIEOffset variable
      // makes the code DTRT.
      LastCIEOffset != IteratorInserted.first->getValue()) {
    LastCIEOffset = Streamer->getFrameSectionSize();
    IteratorInserted.first->getValue() = LastCIEOffset;
    Streamer->emitCIE(CIEData);
  }

  // Emit the FDE with updated address and CIE pointer.
  // (4 + AddrSize) is the size of the CIEId + initial_location
  // fields that will get reconstructed by emitFDE().
  unsigned FDERemainingBytes = InitialLength - (4 + AddrSize);
  Streamer->emitFDE(IteratorInserted.first->getValue(), AddrSize,
                    Loc + Range->second.Offset,
                    FrameData.substr(InputOffset, FDERemainingBytes));
  InputOffset += FDERemainingBytes;
}
1967}

1969void DwarfLinker::DIECloner::copyAbbrev(
  const DWARFAbbreviationDeclaration &Abbrev, bool hasODR) {
DIEAbbrev Copy(dwarf::Tag(Abbrev.getTag()),
               dwarf::Form(Abbrev.hasChildren()));

for (const auto &Attr : Abbrev.attributes()) {
  uint16_t Form = Attr.Form;
  if (hasODR && isODRAttribute(Attr.Attr))
    Form = dwarf::DW_FORM_ref_addr;
  Copy.AddAttribute(dwarf::Attribute(Attr.Attr), dwarf::Form(Form));
}

Linker.AssignAbbrev(Copy);
1982}

1984uint32_t DwarfLinker::DIECloner::hashFullyQualifiedName(
  DWARFDie DIE, CompileUnit &U, const DebugMapObject &DMO, int RecurseDepth) {
const char *Name = nullptr;
DWARFUnit *OrigUnit = &U.getOrigUnit();
CompileUnit *CU = &U;
Optional<DWARFFormValue> Ref;

while (1) {
  if (const char *CurrentName = DIE.getName(DINameKind::ShortName))
    Name = CurrentName;

  if (!(Ref = DIE.find(dwarf::DW_AT_specification)) &&
      !(Ref = DIE.find(dwarf::DW_AT_abstract_origin)))
    break;

  if (!Ref->isFormClass(DWARFFormValue::FC_Reference))
    break;

  CompileUnit *RefCU;
  if (auto RefDIE = resolveDIEReference(Linker, DMO, CompileUnits, *Ref,
                                        U.getOrigUnit(), DIE, RefCU)) {
    CU = RefCU;
    OrigUnit = &RefCU->getOrigUnit();
    DIE = RefDIE;
  }
}

unsigned Idx = OrigUnit->getDIEIndex(DIE);
if (!Name && DIE.getTag() == dwarf::DW_TAG_namespace)
  Name = "(anonymous namespace)";

if (CU->getInfo(Idx).ParentIdx == 0 ||
    // FIXME: dsymutil-classic compatibility. Ignore modules.
    CU->getOrigUnit().getDIEAtIndex(CU->getInfo(Idx).ParentIdx).getTag() ==
        dwarf::DW_TAG_module)
  return djbHash(Name ? Name : "", djbHash(RecurseDepth ? "" : "::"));

DWARFDie Die = OrigUnit->getDIEAtIndex(CU->getInfo(Idx).ParentIdx);
return djbHash(
    (Name ? Name : ""),
    djbHash((Name ? "::" : ""),
            hashFullyQualifiedName(Die, *CU, DMO, ++RecurseDepth)));
2026}

2028static uint64_t getDwoId(const DWARFDie &CUDie, const DWARFUnit &Unit) {
auto DwoId = dwarf::toUnsigned(
    CUDie.find({dwarf::DW_AT_dwo_id, dwarf::DW_AT_GNU_dwo_id}));
if (DwoId)
  return *DwoId;
return 0;
2034}

2036bool DwarfLinker::registerModuleReference(
  const DWARFDie &CUDie, const DWARFUnit &Unit, DebugMap &ModuleMap,
  const DebugMapObject &DMO, RangesTy &Ranges, OffsetsStringPool &StringPool,
  UniquingStringPool &UniquingStringPool, DeclContextTree &ODRContexts,
  uint64_t ModulesEndOffset, unsigned &UnitID, unsigned Indent, bool Quiet) {
std::string PCMfile = dwarf::toString(
    CUDie.find({dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name}), "");
if (PCMfile.empty())
  return false;

// Clang module DWARF skeleton CUs abuse this for the path to the module.
std::string PCMpath = dwarf::toString(CUDie.find(dwarf::DW_AT_comp_dir), "");
uint64_t DwoId = getDwoId(CUDie, Unit);

std::string Name = dwarf::toString(CUDie.find(dwarf::DW_AT_name), "");
if (Name.empty()) {
  if (!Quiet)
    reportWarning("Anonymous module skeleton CU for " + PCMfile, DMO);
  return true;
}

if (!Quiet && Options.Verbose) {
  outs().indent(Indent);
  outs() << "Found clang module reference " << PCMfile;
}

auto Cached = ClangModules.find(PCMfile);
if (Cached != ClangModules.end()) {
  // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
  // fixed in clang, only warn about DWO_id mismatches in verbose mode.
  // ASTFileSignatures will change randomly when a module is rebuilt.
  if (!Quiet && Options.Verbose && (Cached->second != DwoId))
    reportWarning(Twine("hash mismatch: this object file was built against a "
                        "different version of the module ") +
                      PCMfile,
                  DMO);
  if (!Quiet && Options.Verbose)
    outs() << " [cached].\n";
  return true;
}
if (!Quiet && Options.Verbose)
  outs() << " ...\n";

// Cyclic dependencies are disallowed by Clang, but we still
// shouldn't run into an infinite loop, so mark it as processed now.
ClangModules.insert({PCMfile, DwoId});
if (Error E =
        loadClangModule(PCMfile, PCMpath, Name, DwoId, ModuleMap, DMO, Ranges,
                        StringPool, UniquingStringPool, ODRContexts,
                        ModulesEndOffset, UnitID, Indent + 2, Quiet)) {
  consumeError(std::move(E));
  return false;
}
return true;
2090}

2092ErrorOr<const object::ObjectFile &>
2093DwarfLinker::loadObject(const DebugMapObject &Obj, const DebugMap &Map) {
auto ObjectEntry =
    BinHolder.getObjectEntry(Obj.getObjectFilename(), Obj.getTimestamp());
if (!ObjectEntry) {
  auto Err = ObjectEntry.takeError();
  reportWarning(
      Twine(Obj.getObjectFilename()) + ": " + toString(std::move(Err)), Obj);
  return errorToErrorCode(std::move(Err));
}

auto Object = ObjectEntry->getObject(Map.getTriple());
if (!Object) {
  auto Err = Object.takeError();
  reportWarning(
      Twine(Obj.getObjectFilename()) + ": " + toString(std::move(Err)), Obj);
  return errorToErrorCode(std::move(Err));
}

return *Object;
2112}

2114Error DwarfLinker::loadClangModule(
  StringRef Filename, StringRef ModulePath, StringRef ModuleName,
  uint64_t DwoId, DebugMap &ModuleMap, const DebugMapObject &DMO,
  RangesTy &Ranges, OffsetsStringPool &StringPool,
  UniquingStringPool &UniquingStringPool, DeclContextTree &ODRContexts,
  uint64_t ModulesEndOffset, unsigned &UnitID, unsigned Indent, bool Quiet) {
SmallString<80> Path(Options.PrependPath);
if (sys::path::is_relative(Filename))
  sys::path::append(Path, ModulePath, Filename);
else
  sys::path::append(Path, Filename);
// Don't use the cached binary holder because we have no thread-safety
// guarantee and the lifetime is limited.
auto &Obj = ModuleMap.addDebugMapObject(
    Path, sys::TimePoint<std::chrono::seconds>(), MachO::N_OSO);
auto ErrOrObj = loadObject(Obj, ModuleMap);
if (!ErrOrObj) {
  // Try and emit more helpful warnings by applying some heuristics.
  StringRef ObjFile = DMO.getObjectFilename();
  bool isClangModule = sys::path::extension(Filename).equals(".pcm");
  bool isArchive = ObjFile.endswith(")");
  if (isClangModule) {
    StringRef ModuleCacheDir = sys::path::parent_path(Path);
    if (sys::fs::exists(ModuleCacheDir)) {
      // If the module's parent directory exists, we assume that the module
      // cache has expired and was pruned by clang.  A more adventurous
      // dsymutil would invoke clang to rebuild the module now.
      if (!ModuleCacheHintDisplayed) {
        WithColor::note() << "The clang module cache may have expired since "
                             "this object file was built. Rebuilding the "
                             "object file will rebuild the module cache.\n";
        ModuleCacheHintDisplayed = true;
      }
    } else if (isArchive) {
      // If the module cache directory doesn't exist at all and the object
      // file is inside a static library, we assume that the static library
      // was built on a different machine. We don't want to discourage module
      // debugging for convenience libraries within a project though.
      if (!ArchiveHintDisplayed) {
        WithColor::note()
            << "Linking a static library that was built with "
               "-gmodules, but the module cache was not found.  "
               "Redistributable static libraries should never be "
               "built with module debugging enabled.  The debug "
               "experience will be degraded due to incomplete "
               "debug information.\n";
        ArchiveHintDisplayed = true;
      }
    }
  }
  return Error::success();
}

std::unique_ptr<CompileUnit> Unit;

// Setup access to the debug info.
auto DwarfContext = DWARFContext::create(*ErrOrObj);
RelocationManager RelocMgr(*this);

for (const auto &CU : DwarfContext->compile_units()) {
  updateDwarfVersion(CU->getVersion());
  // Recursively get all modules imported by this one.
  auto CUDie = CU->getUnitDIE(false);
  if (!CUDie)
    continue;
  if (!registerModuleReference(CUDie, *CU, ModuleMap, DMO, Ranges, StringPool,
                               UniquingStringPool, ODRContexts,
                               ModulesEndOffset, UnitID, Indent, Quiet)) {
    if (Unit) {
      std::string Err =
          (Filename +
           ": Clang modules are expected to have exactly 1 compile unit.\n")
              .str();
      error(Err);
      return make_error<StringError>(Err, inconvertibleErrorCode());
    }
    // FIXME: Until PR27449 (https://llvm.org/bugs/show_bug.cgi?id=27449) is
    // fixed in clang, only warn about DWO_id mismatches in verbose mode.
    // ASTFileSignatures will change randomly when a module is rebuilt.
    uint64_t PCMDwoId = getDwoId(CUDie, *CU);
    if (PCMDwoId != DwoId) {
      if (!Quiet && Options.Verbose)
        reportWarning(
            Twine("hash mismatch: this object file was built against a "
                  "different version of the module ") +
                Filename,
            DMO);
      // Update the cache entry with the DwoId of the module loaded from disk.
      ClangModules[Filename] = PCMDwoId;
    }

    // Add this module.
    Unit = llvm::make_unique<CompileUnit>(*CU, UnitID++, !Options.NoODR,
                                          ModuleName);
    Unit->setHasInterestingContent();
    analyzeContextInfo(CUDie, 0, *Unit, &ODRContexts.getRoot(),
                       UniquingStringPool, ODRContexts, ModulesEndOffset);
    // Keep everything.
    Unit->markEverythingAsKept();
  }
}
if (!Unit->getOrigUnit().getUnitDIE().hasChildren())
  return Error::success();
if (!Quiet && Options.Verbose) {
  outs().indent(Indent);
  outs() << "cloning .debug_info from " << Filename << "\n";
}

UnitListTy CompileUnits;
CompileUnits.push_back(std::move(Unit));
DIECloner(*this, RelocMgr, DIEAlloc, CompileUnits, Options)
    .cloneAllCompileUnits(*DwarfContext, DMO, Ranges, StringPool);
return Error::success();
2227}

2229void DwarfLinker::DIECloner::cloneAllCompileUnits(
  DWARFContext &DwarfContext, const DebugMapObject &DMO, RangesTy &Ranges,
  OffsetsStringPool &StringPool) {
if (!Linker.Streamer)
  return;

for (auto &CurrentUnit : CompileUnits) {
  auto InputDIE = CurrentUnit->getOrigUnit().getUnitDIE();
  CurrentUnit->setStartOffset(Linker.OutputDebugInfoSize);
  if (!InputDIE) {
    Linker.OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset();
    continue;
  }
  if (CurrentUnit->getInfo(0).Keep) {
    // Clone the InputDIE into your Unit DIE in our compile unit since it
    // already has a DIE inside of it.
    CurrentUnit->createOutputDIE();
    cloneDIE(InputDIE, DMO, *CurrentUnit, StringPool, 0 /* PC offset */,
             11 /* Unit Header size */, 0, CurrentUnit->getOutputUnitDIE());
  }
  Linker.OutputDebugInfoSize = CurrentUnit->computeNextUnitOffset();
  if (Linker.Options.NoOutput)
    continue;

  if (LLVM_LIKELY(!Linker.Options.Update)__builtin_expect((bool)(!Linker.Options.Update), true)) {
    // FIXME: for compatibility with the classic dsymutil, we emit an empty
    // line table for the unit, even if the unit doesn't actually exist in
    // the DIE tree.
    Linker.patchLineTableForUnit(*CurrentUnit, DwarfContext, Ranges, DMO);
    Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
    Linker.patchRangesForUnit(*CurrentUnit, DwarfContext, DMO);
    Linker.Streamer->emitLocationsForUnit(*CurrentUnit, DwarfContext);
  } else {
    Linker.emitAcceleratorEntriesForUnit(*CurrentUnit);
  }
}

if (Linker.Options.NoOutput)
  return;

// Emit all the compile unit's debug information.
for (auto &CurrentUnit : CompileUnits) {
  if (LLVM_LIKELY(!Linker.Options.Update)__builtin_expect((bool)(!Linker.Options.Update), true))
    Linker.generateUnitRanges(*CurrentUnit);
  CurrentUnit->fixupForwardReferences();
  Linker.Streamer->emitCompileUnitHeader(*CurrentUnit);
  if (!CurrentUnit->getOutputUnitDIE())
    continue;
  Linker.Streamer->emitDIE(*CurrentUnit->getOutputUnitDIE());
}
2279}

2281void DwarfLinker::updateAccelKind(DWARFContext &Dwarf) {
if (Options.TheAccelTableKind != AccelTableKind::Default)
  return;

auto &DwarfObj = Dwarf.getDWARFObj();

if (!AtLeastOneDwarfAccelTable &&
    (!DwarfObj.getAppleNamesSection().Data.empty() ||
     !DwarfObj.getAppleTypesSection().Data.empty() ||
     !DwarfObj.getAppleNamespacesSection().Data.empty() ||
     !DwarfObj.getAppleObjCSection().Data.empty())) {
  AtLeastOneAppleAccelTable = true;
}

if (!AtLeastOneDwarfAccelTable &&
    !DwarfObj.getDebugNamesSection().Data.empty()) {
  AtLeastOneDwarfAccelTable = true;
}
2299}

2301bool DwarfLinker::emitPaperTrailWarnings(const DebugMapObject &DMO,
                                       const DebugMap &Map,
                                       OffsetsStringPool &StringPool) {
if (DMO.getWarnings().empty() || !DMO.empty())
11
←
Assuming the condition is false→
12
←
Taking false branch→
  return false;

Streamer->switchToDebugInfoSection(/* Version */ 2);
DIE *CUDie = DIE::get(DIEAlloc, dwarf::DW_TAG_compile_unit);
CUDie->setOffset(11);
StringRef Producer = StringPool.internString("dsymutil");
StringRef File = StringPool.internString(DMO.getObjectFilename());
CUDie->addValue(DIEAlloc, dwarf::DW_AT_producer, dwarf::DW_FORM_strp,
13
←
Calling 'DIEValueList::addValue'→
                DIEInteger(StringPool.getStringOffset(Producer)));
DIEBlock *String = new (DIEAlloc) DIEBlock();
DIEBlocks.push_back(String);
for (auto &C : File)
  String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
                   DIEInteger(C));
String->addValue(DIEAlloc, dwarf::Attribute(0), dwarf::DW_FORM_data1,
                 DIEInteger(0));

CUDie->addValue(DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_string, String);
for (const auto &Warning : DMO.getWarnings()) {
  DIE &ConstDie = CUDie->addChild(DIE::get(DIEAlloc, dwarf::DW_TAG_constant));
  ConstDie.addValue(
      DIEAlloc, dwarf::DW_AT_name, dwarf::DW_FORM_strp,
      DIEInteger(StringPool.getStringOffset("dsymutil_warning")));
  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag,
                    DIEInteger(1));
  ConstDie.addValue(DIEAlloc, dwarf::DW_AT_const_value, dwarf::DW_FORM_strp,
                    DIEInteger(StringPool.getStringOffset(Warning)));
}
unsigned Size = 4 /* FORM_strp */ + File.size() + 1 +
                DMO.getWarnings().size() * (4 + 1 + 4) +
                1 /* End of children */;
DIEAbbrev Abbrev = CUDie->generateAbbrev();
AssignAbbrev(Abbrev);
CUDie->setAbbrevNumber(Abbrev.getNumber());
Size += getULEB128Size(Abbrev.getNumber());
// Abbreviation ordering needed for classic compatibility.
for (auto &Child : CUDie->children()) {
  Abbrev = Child.generateAbbrev();
  AssignAbbrev(Abbrev);
  Child.setAbbrevNumber(Abbrev.getNumber());
  Size += getULEB128Size(Abbrev.getNumber());
}
CUDie->setSize(Size);
auto &Asm = Streamer->getAsmPrinter();
Asm.emitInt32(11 + CUDie->getSize() - 4);
Asm.emitInt16(2);
Asm.emitInt32(0);
Asm.emitInt8(Map.getTriple().isArch64Bit() ? 8 : 4);
Streamer->emitDIE(*CUDie);
OutputDebugInfoSize += 11 /* Header */ + Size;

return true;
2357}

2359bool DwarfLinker::link(const DebugMap &Map) {
if (!createStreamer(Map.getTriple(), OutFile))
2
←
Assuming the condition is false→
3
←
Taking false branch→
  return false;

// Size of the DIEs (and headers) generated for the linked output.
OutputDebugInfoSize = 0;
// A unique ID that identifies each compile unit.
unsigned UnitID = 0;
DebugMap ModuleMap(Map.getTriple(), Map.getBinaryPath());

// First populate the data structure we need for each iteration of the
// parallel loop.
unsigned NumObjects = Map.getNumberOfObjects();
std::vector<LinkContext> ObjectContexts;
ObjectContexts.reserve(NumObjects);
for (const auto &Obj : Map.objects()) {
  ObjectContexts.emplace_back(Map, *this, *Obj.get());
  LinkContext &LC = ObjectContexts.back();
  if (LC.ObjectFile)
    updateAccelKind(*LC.DwarfContext);
}

// This Dwarf string pool which is only used for uniquing. This one should
// never be used for offsets as its not thread-safe or predictable.
UniquingStringPool UniquingStringPool;

// This Dwarf string pool which is used for emission. It must be used
// serially as the order of calling getStringOffset matters for
// reproducibility.
OffsetsStringPool OffsetsStringPool;

// ODR Contexts for the link.
DeclContextTree ODRContexts;

// If we haven't decided on an accelerator table kind yet, we base ourselves
// on the DWARF we have seen so far. At this point we haven't pulled in debug
// information from modules yet, so it is technically possible that they
// would affect the decision. However, as they're built with the same
// compiler and flags, it is safe to assume that they will follow the
// decision made here.
if (Options.TheAccelTableKind == AccelTableKind::Default) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
  if (AtLeastOneDwarfAccelTable && !AtLeastOneAppleAccelTable)
    Options.TheAccelTableKind = AccelTableKind::Dwarf;
  else
    Options.TheAccelTableKind = AccelTableKind::Apple;
}

for (LinkContext &LinkContext : ObjectContexts) {
  if (Options.Verbose)
6
←
Assuming the condition is false→
7
←
Taking false branch→
    outs() << "DEBUG MAP OBJECT: " << LinkContext.DMO.getObjectFilename()
           << "\n";

  // N_AST objects (swiftmodule files) should get dumped directly into the
  // appropriate DWARF section.
  if (LinkContext.DMO.getType() == MachO::N_AST) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
    StringRef File = LinkContext.DMO.getObjectFilename();
    auto ErrorOrMem = MemoryBuffer::getFile(File);
    if (!ErrorOrMem) {
      warn("Could not open '" + File + "'\n");
      continue;
    }
    sys::fs::file_status Stat;
    if (auto Err = sys::fs::status(File, Stat)) {
      warn(Err.message());
      continue;
    }
    if (!Options.NoTimestamp &&
        Stat.getLastModificationTime() !=
            sys::TimePoint<>(LinkContext.DMO.getTimestamp())) {
      // Not using the helper here as we can easily stream TimePoint<>.
      WithColor::warning()
          << "Timestamp mismatch for " << File << ": "
          << Stat.getLastModificationTime() << " and "
          << sys::TimePoint<>(LinkContext.DMO.getTimestamp()) << "\n";
      continue;
    }

    // Copy the module into the .swift_ast section.
    if (!Options.NoOutput)
      Streamer->emitSwiftAST((*ErrorOrMem)->getBuffer());
    continue;
  }

  if (emitPaperTrailWarnings(LinkContext.DMO, Map, OffsetsStringPool))
10
←
Calling 'DwarfLinker::emitPaperTrailWarnings'→
    continue;

  if (!LinkContext.ObjectFile)
    continue;

  // Look for relocations that correspond to debug map entries.

  if (LLVM_LIKELY(!Options.Update)__builtin_expect((bool)(!Options.Update), true) &&
      !LinkContext.RelocMgr.findValidRelocsInDebugInfo(
          *LinkContext.ObjectFile, LinkContext.DMO)) {
    if (Options.Verbose)
      outs() << "No valid relocations found. Skipping.\n";

    // Clear this ObjFile entry as a signal to other loops that we should not
    // process this iteration.
    LinkContext.ObjectFile = nullptr;
    continue;
  }

  // Setup access to the debug info.
  if (!LinkContext.DwarfContext)
    continue;

  startDebugObject(LinkContext);

  // In a first phase, just read in the debug info and load all clang modules.
  LinkContext.CompileUnits.reserve(
      LinkContext.DwarfContext->getNumCompileUnits());

  for (const auto &CU : LinkContext.DwarfContext->compile_units()) {
    updateDwarfVersion(CU->getVersion());
    auto CUDie = CU->getUnitDIE(false);
    if (Options.Verbose) {
      outs() << "Input compilation unit:";
      DIDumpOptions DumpOpts;
      DumpOpts.RecurseDepth = 0;
      DumpOpts.Verbose = Options.Verbose;
      CUDie.dump(outs(), 0, DumpOpts);
    }
    if (CUDie && !LLVM_UNLIKELY(Options.Update)__builtin_expect((bool)(Options.Update), false))
      registerModuleReference(CUDie, *CU, ModuleMap, LinkContext.DMO,
                              LinkContext.Ranges, OffsetsStringPool,
                              UniquingStringPool, ODRContexts, 0, UnitID);
  }
}

// If we haven't seen any CUs, pick an arbitrary valid Dwarf version anyway.
if (MaxDwarfVersion == 0)
  MaxDwarfVersion = 3;

// At this point we know how much data we have emitted. We use this value to
// compare canonical DIE offsets in analyzeContextInfo to see if a definition
// is already emitted, without being affected by canonical die offsets set
// later. This prevents undeterminism when analyze and clone execute
// concurrently, as clone set the canonical DIE offset and analyze reads it.
const uint64_t ModulesEndOffset = OutputDebugInfoSize;

// These variables manage the list of processed object files.
// The mutex and condition variable are to ensure that this is thread safe.
std::mutex ProcessedFilesMutex;
std::condition_variable ProcessedFilesConditionVariable;
BitVector ProcessedFiles(NumObjects, false);

//  Analyzing the context info is particularly expensive so it is executed in
//  parallel with emitting the previous compile unit.
auto AnalyzeLambda = [&](size_t i) {
  auto &LinkContext = ObjectContexts[i];

  if (!LinkContext.ObjectFile || !LinkContext.DwarfContext)
    return;

  for (const auto &CU : LinkContext.DwarfContext->compile_units()) {
    updateDwarfVersion(CU->getVersion());
    // The !registerModuleReference() condition effectively skips
    // over fully resolved skeleton units. This second pass of
    // registerModuleReferences doesn't do any new work, but it
    // will collect top-level errors, which are suppressed. Module
    // warnings were already displayed in the first iteration.
    bool Quiet = true;
    auto CUDie = CU->getUnitDIE(false);
    if (!CUDie || LLVM_UNLIKELY(Options.Update)__builtin_expect((bool)(Options.Update), false) ||
        !registerModuleReference(CUDie, *CU, ModuleMap, LinkContext.DMO,
                                 LinkContext.Ranges, OffsetsStringPool,
                                 UniquingStringPool, ODRContexts,
                                 ModulesEndOffset, UnitID, Quiet)) {
      LinkContext.CompileUnits.push_back(llvm::make_unique<CompileUnit>(
          *CU, UnitID++, !Options.NoODR && !Options.Update, ""));
    }
  }

  // Now build the DIE parent links that we will use during the next phase.
  for (auto &CurrentUnit : LinkContext.CompileUnits) {
    auto CUDie = CurrentUnit->getOrigUnit().getUnitDIE();
    if (!CUDie)
      continue;
    analyzeContextInfo(CurrentUnit->getOrigUnit().getUnitDIE(), 0,
                       *CurrentUnit, &ODRContexts.getRoot(),
                       UniquingStringPool, ODRContexts, ModulesEndOffset);
  }
};

// And then the remaining work in serial again.
// Note, although this loop runs in serial, it can run in parallel with
// the analyzeContextInfo loop so long as we process files with indices >=
// than those processed by analyzeContextInfo.
auto CloneLambda = [&](size_t i) {
  auto &LinkContext = ObjectContexts[i];
  if (!LinkContext.ObjectFile)
    return;

  // Then mark all the DIEs that need to be present in the linked output
  // and collect some information about them.
  // Note that this loop can not be merged with the previous one because
  // cross-cu references require the ParentIdx to be setup for every CU in
  // the object file before calling this.
  if (LLVM_UNLIKELY(Options.Update)__builtin_expect((bool)(Options.Update), false)) {
    for (auto &CurrentUnit : LinkContext.CompileUnits)
      CurrentUnit->markEverythingAsKept();
    Streamer->copyInvariantDebugSection(*LinkContext.ObjectFile);
  } else {
    for (auto &CurrentUnit : LinkContext.CompileUnits)
      lookForDIEsToKeep(LinkContext.RelocMgr, LinkContext.Ranges,
                        LinkContext.CompileUnits,
                        CurrentUnit->getOrigUnit().getUnitDIE(),
                        LinkContext.DMO, *CurrentUnit, 0);
  }

  // The calls to applyValidRelocs inside cloneDIE will walk the reloc
  // array again (in the same way findValidRelocsInDebugInfo() did). We
  // need to reset the NextValidReloc index to the beginning.
  LinkContext.RelocMgr.resetValidRelocs();
  if (LinkContext.RelocMgr.hasValidRelocs() || LLVM_UNLIKELY(Options.Update)__builtin_expect((bool)(Options.Update), false))
    DIECloner(*this, LinkContext.RelocMgr, DIEAlloc, LinkContext.CompileUnits,
              Options)
        .cloneAllCompileUnits(*LinkContext.DwarfContext, LinkContext.DMO,
                              LinkContext.Ranges, OffsetsStringPool);
  if (!Options.NoOutput && !LinkContext.CompileUnits.empty() &&
      LLVM_LIKELY(!Options.Update)__builtin_expect((bool)(!Options.Update), true))
    patchFrameInfoForObject(
        LinkContext.DMO, LinkContext.Ranges, *LinkContext.DwarfContext,
        LinkContext.CompileUnits[0]->getOrigUnit().getAddressByteSize());

  // Clean-up before starting working on the next object.
  endDebugObject(LinkContext);
};

auto EmitLambda = [&]() {
  // Emit everything that's global.
  if (!Options.NoOutput) {
    Streamer->emitAbbrevs(Abbreviations, MaxDwarfVersion);
    Streamer->emitStrings(OffsetsStringPool);
    switch (Options.TheAccelTableKind) {
    case AccelTableKind::Apple:
      Streamer->emitAppleNames(AppleNames);
      Streamer->emitAppleNamespaces(AppleNamespaces);
      Streamer->emitAppleTypes(AppleTypes);
      Streamer->emitAppleObjc(AppleObjc);
      break;
    case AccelTableKind::Dwarf:
      Streamer->emitDebugNames(DebugNames);
      break;
    case AccelTableKind::Default:
      llvm_unreachable("Default should have already been resolved.")::llvm::llvm_unreachable_internal("Default should have already been resolved."
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/dsymutil/DwarfLinker.cpp"
, 2605);
      break;
    }
  }
};

auto AnalyzeAll = [&]() {
  for (unsigned i = 0, e = NumObjects; i != e; ++i) {
    AnalyzeLambda(i);

    std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
    ProcessedFiles.set(i);
    ProcessedFilesConditionVariable.notify_one();
  }
};

auto CloneAll = [&]() {
  for (unsigned i = 0, e = NumObjects; i != e; ++i) {
    {
      std::unique_lock<std::mutex> LockGuard(ProcessedFilesMutex);
      if (!ProcessedFiles[i]) {
        ProcessedFilesConditionVariable.wait(
            LockGuard, [&]() { return ProcessedFiles[i]; });
      }
    }

    CloneLambda(i);
  }
  EmitLambda();
};

// To limit memory usage in the single threaded case, analyze and clone are
// run sequentially so the LinkContext is freed after processing each object
// in endDebugObject.
if (Options.Threads == 1) {
  for (unsigned i = 0, e = NumObjects; i != e; ++i) {
    AnalyzeLambda(i);
    CloneLambda(i);
  }
  EmitLambda();
} else {
  ThreadPool pool(2);
  pool.async(AnalyzeAll);
  pool.async(CloneAll);
  pool.wait();
}

return Options.NoOutput ? true : Streamer->finish(Map);
2653} // namespace dsymutil

2655bool linkDwarf(raw_fd_ostream &OutFile, BinaryHolder &BinHolder,
             const DebugMap &DM, const LinkOptions &Options) {
DwarfLinker Linker(OutFile, BinHolder, Options);
return Linker.link(DM);
1
Calling 'DwarfLinker::link'→
2659}

2661} // namespace dsymutil
2662} // namespace llvm

←

/build/llvm-toolchain-snapshot-8~svn345461/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~svn345461/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~svn345461/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~svn345461/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~svn345461/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~svn345461/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));
15
←
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)));
14
←
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~svn345461/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~svn345461/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