/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h

Bug Summary

File:	include/llvm/Support/Error.h
Warning:	line 201, column 5 Potential leak of memory pointed to by 'Payload._M_t._M_head_impl'

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 llvm-nm.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/llvm-nm -I /build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-nm -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/llvm-nm -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/llvm-nm/llvm-nm.cpp -faddrsig

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

→

1//===-- llvm-nm.cpp - Symbol table dumping utility for llvm ---------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This program is a utility that works like traditional Unix "nm", that is, it
11// prints out the names of symbols in a bitcode or object file, along with some
12// information about each symbol.
13//
14// This "nm" supports many of the features of GNU "nm", including its different
15// output formats.
16//
17//===----------------------------------------------------------------------===//

19#include "llvm/ADT/StringSwitch.h"
20#include "llvm/BinaryFormat/COFF.h"
21#include "llvm/Demangle/Demangle.h"
22#include "llvm/IR/Function.h"
23#include "llvm/IR/LLVMContext.h"
24#include "llvm/Object/Archive.h"
25#include "llvm/Object/COFF.h"
26#include "llvm/Object/COFFImportFile.h"
27#include "llvm/Object/ELFObjectFile.h"
28#include "llvm/Object/IRObjectFile.h"
29#include "llvm/Object/MachO.h"
30#include "llvm/Object/MachOUniversal.h"
31#include "llvm/Object/ObjectFile.h"
32#include "llvm/Object/Wasm.h"
33#include "llvm/Support/CommandLine.h"
34#include "llvm/Support/FileSystem.h"
35#include "llvm/Support/Format.h"
36#include "llvm/Support/InitLLVM.h"
37#include "llvm/Support/MemoryBuffer.h"
38#include "llvm/Support/Program.h"
39#include "llvm/Support/Signals.h"
40#include "llvm/Support/TargetSelect.h"
41#include "llvm/Support/raw_ostream.h"
42#include <vector>

44using namespace llvm;
45using namespace object;

47namespace {
48enum OutputFormatTy { bsd, sysv, posix, darwin };
49cl::opt<OutputFormatTy> OutputFormat(
  "format", cl::desc("Specify output format"),
  cl::values(clEnumVal(bsd, "BSD format")llvm::cl::OptionEnumValue { "bsd", int(bsd), "BSD format" }, clEnumVal(sysv, "System V format")llvm::cl::OptionEnumValue { "sysv", int(sysv), "System V format"
 },
             clEnumVal(posix, "POSIX.2 format")llvm::cl::OptionEnumValue { "posix", int(posix), "POSIX.2 format"
 },
             clEnumVal(darwin, "Darwin -m format")llvm::cl::OptionEnumValue { "darwin", int(darwin), "Darwin -m format"
 }),
  cl::init(bsd));
55cl::alias OutputFormat2("f", cl::desc("Alias for --format"),
                      cl::aliasopt(OutputFormat));

58cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
                                   cl::ZeroOrMore);

61cl::opt<bool> UndefinedOnly("undefined-only",
                          cl::desc("Show only undefined symbols"));
63cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"),
                       cl::aliasopt(UndefinedOnly), cl::Grouping);

66cl::opt<bool> DynamicSyms("dynamic",
                        cl::desc("Display the dynamic symbols instead "
                                 "of normal symbols."));
69cl::alias DynamicSyms2("D", cl::desc("Alias for --dynamic"),
                     cl::aliasopt(DynamicSyms), cl::Grouping);

72cl::opt<bool> DefinedOnly("defined-only",
                        cl::desc("Show only defined symbols"));
74cl::alias DefinedOnly2("U", cl::desc("Alias for --defined-only"),
                     cl::aliasopt(DefinedOnly), cl::Grouping);

77cl::opt<bool> ExternalOnly("extern-only",
                         cl::desc("Show only external symbols"),
                         cl::ZeroOrMore);
80cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"),
                      cl::aliasopt(ExternalOnly), cl::Grouping,
                      cl::ZeroOrMore);

84cl::opt<bool> NoWeakSymbols("no-weak",
                          cl::desc("Show only non-weak symbols"));
86cl::alias NoWeakSymbols2("W", cl::desc("Alias for --no-weak"),
                       cl::aliasopt(NoWeakSymbols), cl::Grouping);

89cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd"),
                      cl::Grouping);
91cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix"),
                        cl::Grouping);
93cl::opt<bool> DarwinFormat("m", cl::desc("Alias for --format=darwin"),
                         cl::Grouping);

96static cl::list<std::string>
  ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
            cl::ZeroOrMore);
99bool ArchAll = false;

101cl::opt<bool> PrintFileName(
  "print-file-name",
  cl::desc("Precede each symbol with the object file it came from"));

105cl::alias PrintFileNameA("A", cl::desc("Alias for --print-file-name"),
                       cl::aliasopt(PrintFileName), cl::Grouping);
107cl::alias PrintFileNameo("o", cl::desc("Alias for --print-file-name"),
                       cl::aliasopt(PrintFileName), cl::Grouping);

110cl::opt<bool> DebugSyms("debug-syms",
                      cl::desc("Show all symbols, even debugger only"));
112cl::alias DebugSymsa("a", cl::desc("Alias for --debug-syms"),
                   cl::aliasopt(DebugSyms), cl::Grouping);

115cl::opt<bool> NumericSort("numeric-sort", cl::desc("Sort symbols by address"));
116cl::alias NumericSortn("n", cl::desc("Alias for --numeric-sort"),
                     cl::aliasopt(NumericSort), cl::Grouping);
118cl::alias NumericSortv("v", cl::desc("Alias for --numeric-sort"),
                     cl::aliasopt(NumericSort), cl::Grouping);

121cl::opt<bool> NoSort("no-sort", cl::desc("Show symbols in order encountered"));
122cl::alias NoSortp("p", cl::desc("Alias for --no-sort"), cl::aliasopt(NoSort),
                cl::Grouping);

125cl::opt<bool> Demangle("demangle", cl::desc("Demangle C++ symbol names"));
126cl::alias DemangleC("C", cl::desc("Alias for --demangle"), cl::aliasopt(Demangle),
                  cl::Grouping);

129cl::opt<bool> ReverseSort("reverse-sort", cl::desc("Sort in reverse order"));
130cl::alias ReverseSortr("r", cl::desc("Alias for --reverse-sort"),
                     cl::aliasopt(ReverseSort), cl::Grouping);

133cl::opt<bool> PrintSize("print-size",
                      cl::desc("Show symbol size instead of address"));
135cl::alias PrintSizeS("S", cl::desc("Alias for --print-size"),
                   cl::aliasopt(PrintSize), cl::Grouping);
137bool MachOPrintSizeWarning = false;

139cl::opt<bool> SizeSort("size-sort", cl::desc("Sort symbols by size"));

141cl::opt<bool> WithoutAliases("without-aliases", cl::Hidden,
                           cl::desc("Exclude aliases from output"));

144cl::opt<bool> ArchiveMap("print-armap", cl::desc("Print the archive map"));
145cl::alias ArchiveMaps("M", cl::desc("Alias for --print-armap"),
                    cl::aliasopt(ArchiveMap), cl::Grouping);

148enum Radix { d, o, x };
149cl::opt<Radix>
  AddressRadix("radix", cl::desc("Radix (o/d/x) for printing symbol Values"),
               cl::values(clEnumVal(d, "decimal")llvm::cl::OptionEnumValue { "d", int(d), "decimal" }, clEnumVal(o, "octal")llvm::cl::OptionEnumValue { "o", int(o), "octal" },
                          clEnumVal(x, "hexadecimal")llvm::cl::OptionEnumValue { "x", int(x), "hexadecimal" }),
               cl::init(x));
154cl::alias RadixAlias("t", cl::desc("Alias for --radix"),
                   cl::aliasopt(AddressRadix));

157cl::opt<bool> JustSymbolName("just-symbol-name",
                           cl::desc("Print just the symbol's name"));
159cl::alias JustSymbolNames("j", cl::desc("Alias for --just-symbol-name"),
                        cl::aliasopt(JustSymbolName), cl::Grouping);

162// FIXME: This option takes exactly two strings and should be allowed anywhere
163// on the command line.  Such that "llvm-nm -s __TEXT __text foo.o" would work.
164// But that does not as the CommandLine Library does not have a way to make
165// this work.  For now the "-s __TEXT __text" has to be last on the command
166// line.
167cl::list<std::string> SegSect("s", cl::Positional, cl::ZeroOrMore,
                            cl::desc("Dump only symbols from this segment "
                                     "and section name, Mach-O only"));

171cl::opt<bool> FormatMachOasHex("x", cl::desc("Print symbol entry in hex, "
                                           "Mach-O only"), cl::Grouping);
173cl::opt<bool> AddDyldInfo("add-dyldinfo",
                        cl::desc("Add symbols from the dyldinfo not already "
                                 "in the symbol table, Mach-O only"));
176cl::opt<bool> NoDyldInfo("no-dyldinfo",
                       cl::desc("Don't add any symbols from the dyldinfo, "
                                "Mach-O only"));
179cl::opt<bool> DyldInfoOnly("dyldinfo-only",
                         cl::desc("Show only symbols from the dyldinfo, "
                                  "Mach-O only"));

183cl::opt<bool> NoLLVMBitcode("no-llvm-bc",
                          cl::desc("Disable LLVM bitcode reader"));

186cl::extrahelp HelpResponse("\nPass @FILE as argument to read options from FILE.\n");

188bool PrintAddress = true;

190bool MultipleFiles = false;

192bool HadError = false;

194std::string ToolName;
195} // anonymous namespace

197static void error(Twine Message, Twine Path = Twine()) {
HadError = true;
errs() << ToolName << ": " << Path << ": " << Message << ".\n";
200}

202static bool error(std::error_code EC, Twine Path = Twine()) {
if (EC) {
  error(EC.message(), Path);
  return true;
}
return false;
208}

210// This version of error() prints the archive name and member name, for example:
211// "libx.a(foo.o)" after the ToolName before the error message.  It sets
212// HadError but returns allowing the code to move on to other archive members. 
213static void error(llvm::Error E, StringRef FileName, const Archive::Child &C,
                StringRef ArchitectureName = StringRef()) {
HadError = true;
errs() << ToolName << ": " << FileName;

Expected<StringRef> NameOrErr = C.getName();
// TODO: if we have a error getting the name then it would be nice to print
// the index of which archive member this is and or its offset in the
// archive instead of "???" as the name.
if (!NameOrErr) {
  consumeError(NameOrErr.takeError());
  errs() << "(" << "???" << ")";
} else
  errs() << "(" << NameOrErr.get() << ")";

if (!ArchitectureName.empty())
  errs() << " (for architecture " << ArchitectureName << ") ";

std::string Buf;
raw_string_ostream OS(Buf);
logAllUnhandledErrors(std::move(E), OS, "");
OS.flush();
errs() << " " << Buf << "\n";
236}

238// This version of error() prints the file name and which architecture slice it
239// is from, for example: "foo.o (for architecture i386)" after the ToolName
240// before the error message.  It sets HadError but returns allowing the code to
241// move on to other architecture slices. 
242static void error(llvm::Error E, StringRef FileName,
                StringRef ArchitectureName = StringRef()) {
HadError = true;
errs() << ToolName << ": " << FileName;

if (!ArchitectureName.empty())
  errs() << " (for architecture " << ArchitectureName << ") ";

std::string Buf;
raw_string_ostream OS(Buf);
logAllUnhandledErrors(std::move(E), OS, "");
OS.flush();
errs() << " " << Buf << "\n";
255}

257namespace {
258struct NMSymbol {
uint64_t Address;
uint64_t Size;
char TypeChar;
StringRef Name;
BasicSymbolRef Sym;
// The Sym field above points to the native symbol in the object file,
// for Mach-O when we are creating symbols from the dyld info the above
// pointer is null as there is no native symbol.  In these cases the fields
// below are filled in to represent what would have been a Mach-O nlist
// native symbol.
uint32_t SymFlags;
SectionRef Section;
uint8_t NType;
uint8_t NSect;
uint16_t NDesc;
StringRef IndirectName;
275};
276} // anonymous namespace

278static bool compareSymbolAddress(const NMSymbol &A, const NMSymbol &B) {
bool ADefined;
if (A.Sym.getRawDataRefImpl().p)
  ADefined = !(A.Sym.getFlags() & SymbolRef::SF_Undefined);
else
  ADefined = A.TypeChar != 'U';
bool BDefined;
if (B.Sym.getRawDataRefImpl().p)
  BDefined = !(B.Sym.getFlags() & SymbolRef::SF_Undefined);
else
  BDefined = B.TypeChar != 'U';
return std::make_tuple(ADefined, A.Address, A.Name, A.Size) <
       std::make_tuple(BDefined, B.Address, B.Name, B.Size);
291}

293static bool compareSymbolSize(const NMSymbol &A, const NMSymbol &B) {
return std::make_tuple(A.Size, A.Name, A.Address) <
       std::make_tuple(B.Size, B.Name, B.Address);
296}

298static bool compareSymbolName(const NMSymbol &A, const NMSymbol &B) {
return std::make_tuple(A.Name, A.Size, A.Address) <
       std::make_tuple(B.Name, B.Size, B.Address);
301}

303static char isSymbolList64Bit(SymbolicFile &Obj) {
if (auto *IRObj = dyn_cast<IRObjectFile>(&Obj))
  return Triple(IRObj->getTargetTriple()).isArch64Bit();
if (isa<COFFObjectFile>(Obj) || isa<COFFImportFile>(Obj))
  return false;
if (isa<WasmObjectFile>(Obj))
  return false;
if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
  return MachO->is64Bit();
return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
313}

315static StringRef CurrentFilename;
316typedef std::vector<NMSymbol> SymbolListT;
317static SymbolListT SymbolList;

319static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I);

321// darwinPrintSymbol() is used to print a symbol from a Mach-O file when the
322// the OutputFormat is darwin or we are printing Mach-O symbols in hex.  For
323// the darwin format it produces the same output as darwin's nm(1) -m output
324// and when printing Mach-O symbols in hex it produces the same output as
325// darwin's nm(1) -x format.
326static void darwinPrintSymbol(SymbolicFile &Obj, SymbolListT::iterator I,
                            char *SymbolAddrStr, const char *printBlanks,
                            const char *printDashes, const char *printFormat) {
MachO::mach_header H;
MachO::mach_header_64 H_64;
uint32_t Filetype = MachO::MH_OBJECT;
uint32_t Flags = 0;
uint8_t NType = 0;
uint8_t NSect = 0;
uint16_t NDesc = 0;
uint32_t NStrx = 0;
uint64_t NValue = 0;
MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
if (Obj.isIR()) {
  uint32_t SymFlags = I->Sym.getFlags();
  if (SymFlags & SymbolRef::SF_Global)
    NType |= MachO::N_EXT;
  if (SymFlags & SymbolRef::SF_Hidden)
    NType |= MachO::N_PEXT;
  if (SymFlags & SymbolRef::SF_Undefined)
    NType |= MachO::N_EXT | MachO::N_UNDF;
  else {
    // Here we have a symbol definition.  So to fake out a section name we
    // use 1, 2 and 3 for section numbers.  See below where they are used to
    // print out fake section names.
    NType |= MachO::N_SECT;
    if (SymFlags & SymbolRef::SF_Const)
      NSect = 3;
    else if (SymFlags & SymbolRef::SF_Executable)
      NSect = 1;
    else
      NSect = 2;
  }
  if (SymFlags & SymbolRef::SF_Weak)
    NDesc |= MachO::N_WEAK_DEF;
} else {
  DataRefImpl SymDRI = I->Sym.getRawDataRefImpl();
  if (MachO->is64Bit()) {
    H_64 = MachO->MachOObjectFile::getHeader64();
    Filetype = H_64.filetype;
    Flags = H_64.flags;
    if (SymDRI.p){
      MachO::nlist_64 STE_64 = MachO->getSymbol64TableEntry(SymDRI);
      NType = STE_64.n_type;
      NSect = STE_64.n_sect;
      NDesc = STE_64.n_desc;
      NStrx = STE_64.n_strx;
      NValue = STE_64.n_value;
    } else {
      NType = I->NType;
      NSect = I->NSect;
      NDesc = I->NDesc;
      NStrx = 0;
      NValue = I->Address;
    }
  } else {
    H = MachO->MachOObjectFile::getHeader();
    Filetype = H.filetype;
    Flags = H.flags;
    if (SymDRI.p){
      MachO::nlist STE = MachO->getSymbolTableEntry(SymDRI);
      NType = STE.n_type;
      NSect = STE.n_sect;
      NDesc = STE.n_desc;
      NStrx = STE.n_strx;
      NValue = STE.n_value;
    } else {
      NType = I->NType;
      NSect = I->NSect;
      NDesc = I->NDesc;
      NStrx = 0;
      NValue = I->Address;
    }
  }
}

// If we are printing Mach-O symbols in hex do that and return.
if (FormatMachOasHex) {
  char Str[18] = "";
  format(printFormat, NValue).print(Str, sizeof(Str));
  outs() << Str << ' ';
  format("%02x", NType).print(Str, sizeof(Str));
  outs() << Str << ' ';
  format("%02x", NSect).print(Str, sizeof(Str));
  outs() << Str << ' ';
  format("%04x", NDesc).print(Str, sizeof(Str));
  outs() << Str << ' ';
  format("%08x", NStrx).print(Str, sizeof(Str));
  outs() << Str << ' ';
  outs() << I->Name;
  if ((NType & MachO::N_TYPE) == MachO::N_INDR) {
    outs() << " (indirect for ";
    format(printFormat, NValue).print(Str, sizeof(Str));
    outs() << Str << ' ';
    StringRef IndirectName;
    if (I->Sym.getRawDataRefImpl().p) {
      if (MachO->getIndirectName(I->Sym.getRawDataRefImpl(), IndirectName))
        outs() << "?)";
      else
        outs() << IndirectName << ")";
    }
    else
      outs() << I->IndirectName << ")";
  }
  outs() << "\n";
  return;
}

if (PrintAddress) {
  if ((NType & MachO::N_TYPE) == MachO::N_INDR)
    strcpy(SymbolAddrStr, printBlanks);
  if (Obj.isIR() && (NType & MachO::N_TYPE) == MachO::N_TYPE)
    strcpy(SymbolAddrStr, printDashes);
  outs() << SymbolAddrStr << ' ';
}

switch (NType & MachO::N_TYPE) {
case MachO::N_UNDF:
  if (NValue != 0) {
    outs() << "(common) ";
    if (MachO::GET_COMM_ALIGN(NDesc) != 0)
      outs() << "(alignment 2^" << (int)MachO::GET_COMM_ALIGN(NDesc) << ") ";
  } else {
    if ((NType & MachO::N_TYPE) == MachO::N_PBUD)
      outs() << "(prebound ";
    else
      outs() << "(";
    if ((NDesc & MachO::REFERENCE_TYPE) ==
        MachO::REFERENCE_FLAG_UNDEFINED_LAZY)
      outs() << "undefined [lazy bound]) ";
    else if ((NDesc & MachO::REFERENCE_TYPE) ==
             MachO::REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY)
      outs() << "undefined [private lazy bound]) ";
    else if ((NDesc & MachO::REFERENCE_TYPE) ==
             MachO::REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY)
      outs() << "undefined [private]) ";
    else
      outs() << "undefined) ";
  }
  break;
case MachO::N_ABS:
  outs() << "(absolute) ";
  break;
case MachO::N_INDR:
  outs() << "(indirect) ";
  break;
case MachO::N_SECT: {
  if (Obj.isIR()) {
    // For llvm bitcode files print out a fake section name using the values
    // use 1, 2 and 3 for section numbers as set above.
    if (NSect == 1)
      outs() << "(LTO,CODE) ";
    else if (NSect == 2)
      outs() << "(LTO,DATA) ";
    else if (NSect == 3)
      outs() << "(LTO,RODATA) ";
    else
      outs() << "(?,?) ";
    break;
  }
  section_iterator Sec = SectionRef();
  if (I->Sym.getRawDataRefImpl().p) {
    Expected<section_iterator> SecOrErr =
      MachO->getSymbolSection(I->Sym.getRawDataRefImpl());
    if (!SecOrErr) {
      consumeError(SecOrErr.takeError());
      outs() << "(?,?) ";
      break;
    }
    Sec = *SecOrErr;
    if (Sec == MachO->section_end()) {
      outs() << "(?,?) ";
      break;
    }
  } else {
    Sec = I->Section;
  }
  DataRefImpl Ref = Sec->getRawDataRefImpl();
  StringRef SectionName;
  MachO->getSectionName(Ref, SectionName);
  StringRef SegmentName = MachO->getSectionFinalSegmentName(Ref);
  outs() << "(" << SegmentName << "," << SectionName << ") ";
  break;
}
default:
  outs() << "(?) ";
  break;
}

if (NType & MachO::N_EXT) {
  if (NDesc & MachO::REFERENCED_DYNAMICALLY)
    outs() << "[referenced dynamically] ";
  if (NType & MachO::N_PEXT) {
    if ((NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF)
      outs() << "weak private external ";
    else
      outs() << "private external ";
  } else {
    if ((NDesc & MachO::N_WEAK_REF) == MachO::N_WEAK_REF ||
        (NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF) {
      if ((NDesc & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF)) ==
          (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
        outs() << "weak external automatically hidden ";
      else
        outs() << "weak external ";
    } else
      outs() << "external ";
  }
} else {
  if (NType & MachO::N_PEXT)
    outs() << "non-external (was a private external) ";
  else
    outs() << "non-external ";
}

if (Filetype == MachO::MH_OBJECT &&
    (NDesc & MachO::N_NO_DEAD_STRIP) == MachO::N_NO_DEAD_STRIP)
  outs() << "[no dead strip] ";

if (Filetype == MachO::MH_OBJECT &&
    ((NType & MachO::N_TYPE) != MachO::N_UNDF) &&
    (NDesc & MachO::N_SYMBOL_RESOLVER) == MachO::N_SYMBOL_RESOLVER)
  outs() << "[symbol resolver] ";

if (Filetype == MachO::MH_OBJECT &&
    ((NType & MachO::N_TYPE) != MachO::N_UNDF) &&
    (NDesc & MachO::N_ALT_ENTRY) == MachO::N_ALT_ENTRY)
  outs() << "[alt entry] ";

if ((NDesc & MachO::N_ARM_THUMB_DEF) == MachO::N_ARM_THUMB_DEF)
  outs() << "[Thumb] ";

if ((NType & MachO::N_TYPE) == MachO::N_INDR) {
  outs() << I->Name << " (for ";
  StringRef IndirectName;
  if (MachO) {
    if (I->Sym.getRawDataRefImpl().p) {
      if (MachO->getIndirectName(I->Sym.getRawDataRefImpl(), IndirectName))
        outs() << "?)";
      else
        outs() << IndirectName << ")";
    }
    else
      outs() << I->IndirectName << ")";
  } else
    outs() << "?)";
} else
  outs() << I->Name;

if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL &&
    (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) ||
     (NType & MachO::N_TYPE) == MachO::N_PBUD)) {
  uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc);
  if (LibraryOrdinal != 0) {
    if (LibraryOrdinal == MachO::EXECUTABLE_ORDINAL)
      outs() << " (from executable)";
    else if (LibraryOrdinal == MachO::DYNAMIC_LOOKUP_ORDINAL)
      outs() << " (dynamically looked up)";
    else {
      StringRef LibraryName;
      if (!MachO ||
          MachO->getLibraryShortNameByIndex(LibraryOrdinal - 1, LibraryName))
        outs() << " (from bad library ordinal " << LibraryOrdinal << ")";
      else
        outs() << " (from " << LibraryName << ")";
    }
  }
}

outs() << "\n";
596}

598// Table that maps Darwin's Mach-O stab constants to strings to allow printing.
599struct DarwinStabName {
uint8_t NType;
const char *Name;
602};
603static const struct DarwinStabName DarwinStabNames[] = {
  {MachO::N_GSYM, "GSYM"},
  {MachO::N_FNAME, "FNAME"},
  {MachO::N_FUN, "FUN"},
  {MachO::N_STSYM, "STSYM"},
  {MachO::N_LCSYM, "LCSYM"},
  {MachO::N_BNSYM, "BNSYM"},
  {MachO::N_PC, "PC"},
  {MachO::N_AST, "AST"},
  {MachO::N_OPT, "OPT"},
  {MachO::N_RSYM, "RSYM"},
  {MachO::N_SLINE, "SLINE"},
  {MachO::N_ENSYM, "ENSYM"},
  {MachO::N_SSYM, "SSYM"},
  {MachO::N_SO, "SO"},
  {MachO::N_OSO, "OSO"},
  {MachO::N_LSYM, "LSYM"},
  {MachO::N_BINCL, "BINCL"},
  {MachO::N_SOL, "SOL"},
  {MachO::N_PARAMS, "PARAM"},
  {MachO::N_VERSION, "VERS"},
  {MachO::N_OLEVEL, "OLEV"},
  {MachO::N_PSYM, "PSYM"},
  {MachO::N_EINCL, "EINCL"},
  {MachO::N_ENTRY, "ENTRY"},
  {MachO::N_LBRAC, "LBRAC"},
  {MachO::N_EXCL, "EXCL"},
  {MachO::N_RBRAC, "RBRAC"},
  {MachO::N_BCOMM, "BCOMM"},
  {MachO::N_ECOMM, "ECOMM"},
  {MachO::N_ECOML, "ECOML"},
  {MachO::N_LENG, "LENG"},
  {0, nullptr}};

637static const char *getDarwinStabString(uint8_t NType) {
for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
  if (DarwinStabNames[i].NType == NType)
    return DarwinStabNames[i].Name;
}
return nullptr;
643}

645// darwinPrintStab() prints the n_sect, n_desc along with a symbolic name of
646// a stab n_type value in a Mach-O file.
647static void darwinPrintStab(MachOObjectFile *MachO, SymbolListT::iterator I) {
MachO::nlist_64 STE_64;
MachO::nlist STE;
uint8_t NType;
uint8_t NSect;
uint16_t NDesc;
DataRefImpl SymDRI = I->Sym.getRawDataRefImpl();
if (MachO->is64Bit()) {
  STE_64 = MachO->getSymbol64TableEntry(SymDRI);
  NType = STE_64.n_type;
  NSect = STE_64.n_sect;
  NDesc = STE_64.n_desc;
} else {
  STE = MachO->getSymbolTableEntry(SymDRI);
  NType = STE.n_type;
  NSect = STE.n_sect;
  NDesc = STE.n_desc;
}

char Str[18] = "";
format("%02x", NSect).print(Str, sizeof(Str));
outs() << ' ' << Str << ' ';
format("%04x", NDesc).print(Str, sizeof(Str));
outs() << Str << ' ';
if (const char *stabString = getDarwinStabString(NType))
  format("%5.5s", stabString).print(Str, sizeof(Str));
else
  format("   %02x", NType).print(Str, sizeof(Str));
outs() << Str;
676}

678static Optional<std::string> demangle(StringRef Name, bool StripUnderscore) {
if (StripUnderscore && Name.size() > 0 && Name[0] == '_')
  Name = Name.substr(1);

if (!Name.startswith("_Z"))
  return None;

int Status;
char *Undecorated =
    itaniumDemangle(Name.str().c_str(), nullptr, nullptr, &Status);
if (Status != 0)
  return None;

std::string S(Undecorated);
free(Undecorated);
return S;
694}

696static bool symbolIsDefined(const NMSymbol &Sym) {
return Sym.TypeChar != 'U' && Sym.TypeChar != 'w' && Sym.TypeChar != 'v';
698}

700static void sortAndPrintSymbolList(SymbolicFile &Obj, bool printName,
                                 const std::string &ArchiveName,
                                 const std::string &ArchitectureName) {
if (!NoSort) {
  std::function<bool(const NMSymbol &, const NMSymbol &)> Cmp;
  if (NumericSort)
    Cmp = compareSymbolAddress;
  else if (SizeSort)
    Cmp = compareSymbolSize;
  else
    Cmp = compareSymbolName;

  if (ReverseSort)
    Cmp = [=](const NMSymbol &A, const NMSymbol &B) { return Cmp(B, A); };
  llvm::sort(SymbolList, Cmp);
}

if (!PrintFileName) {
  if (OutputFormat == posix && MultipleFiles && printName) {
    outs() << '\n' << CurrentFilename << ":\n";
  } else if (OutputFormat == bsd && MultipleFiles && printName) {
    outs() << "\n" << CurrentFilename << ":\n";
  } else if (OutputFormat == sysv) {
    outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n";
    if (isSymbolList64Bit(Obj))
      outs() << "Name                  Value           Class        Type"
             << "         Size             Line  Section\n";
    else
      outs() << "Name                  Value   Class        Type"
             << "         Size     Line  Section\n";
  }
}

const char *printBlanks, *printDashes, *printFormat;
if (isSymbolList64Bit(Obj)) {
  printBlanks = "                ";
  printDashes = "----------------";
  switch (AddressRadix) {
  case Radix::o:
    printFormat = OutputFormat == posix ? "%" PRIo64"l" "o" : "%016" PRIo64"l" "o";
    break;
  case Radix::x:
    printFormat = OutputFormat == posix ? "%" PRIx64"l" "x" : "%016" PRIx64"l" "x";
    break;
  default:
    printFormat = OutputFormat == posix ? "%" PRId64"l" "d" : "%016" PRId64"l" "d";
  }
} else {
  printBlanks = "        ";
  printDashes = "--------";
  switch (AddressRadix) {
  case Radix::o:
    printFormat = OutputFormat == posix ? "%" PRIo64"l" "o" : "%08" PRIo64"l" "o";
    break;
  case Radix::x:
    printFormat = OutputFormat == posix ? "%" PRIx64"l" "x" : "%08" PRIx64"l" "x";
    break;
  default:
    printFormat = OutputFormat == posix ? "%" PRId64"l" "d" : "%08" PRId64"l" "d";
  }
}

auto writeFileName = [&](raw_ostream &S) {
  if (!ArchitectureName.empty())
    S << "(for architecture " << ArchitectureName << "):";
  if (OutputFormat == posix && !ArchiveName.empty())
    S << ArchiveName << "[" << CurrentFilename << "]: ";
  else {
    if (!ArchiveName.empty())
      S << ArchiveName << ":";
    S << CurrentFilename << ": ";
  }
};

if (SymbolList.empty()) {
  if (PrintFileName)
    writeFileName(errs());
  errs() << "no symbols\n";
}

for (SymbolListT::iterator I = SymbolList.begin(), E = SymbolList.end();
     I != E; ++I) {
  uint32_t SymFlags;
  std::string Name = I->Name.str();
  MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
  if (Demangle) {
    if (Optional<std::string> Opt = demangle(I->Name, MachO))
      Name = *Opt;
  }
  if (I->Sym.getRawDataRefImpl().p)
    SymFlags = I->Sym.getFlags();
  else
    SymFlags = I->SymFlags;

  bool Undefined = SymFlags & SymbolRef::SF_Undefined;
  bool Global = SymFlags & SymbolRef::SF_Global;
  bool Weak = SymFlags & SymbolRef::SF_Weak;
  if ((!Undefined && UndefinedOnly) || (Undefined && DefinedOnly) ||
      (!Global && ExternalOnly) || (SizeSort && !PrintAddress) ||
      (Weak && NoWeakSymbols))
    continue;
  if (PrintFileName)
    writeFileName(outs());
  if ((JustSymbolName ||
       (UndefinedOnly && MachO && OutputFormat != darwin)) &&
      OutputFormat != posix) {
    outs() << Name << "\n";
    continue;
  }

  char SymbolAddrStr[18] = "";
  char SymbolSizeStr[18] = "";

  // If the format is SysV or the symbol isn't defined, then print spaces.
  if (OutputFormat == sysv || !symbolIsDefined(*I)) {
    if (OutputFormat == posix) {
      format(printFormat, I->Address)
        .print(SymbolAddrStr, sizeof(SymbolAddrStr));
      format(printFormat, I->Size)
          .print(SymbolSizeStr, sizeof(SymbolSizeStr));
    } else {
      strcpy(SymbolAddrStr, printBlanks);
      strcpy(SymbolSizeStr, printBlanks);
    }
  }

  // Otherwise, print the symbol address and size.
  if (symbolIsDefined(*I)) {
    if (Obj.isIR())
      strcpy(SymbolAddrStr, printDashes);
    else if(MachO && I->TypeChar == 'I')
      strcpy(SymbolAddrStr, printBlanks);
    else
      format(printFormat, I->Address)
        .print(SymbolAddrStr, sizeof(SymbolAddrStr));
    format(printFormat, I->Size).print(SymbolSizeStr, sizeof(SymbolSizeStr));
  }

  // If OutputFormat is darwin or we are printing Mach-O symbols in hex and
  // we have a MachOObjectFile, call darwinPrintSymbol to print as darwin's
  // nm(1) -m output or hex, else if OutputFormat is darwin or we are
  // printing Mach-O symbols in hex and not a Mach-O object fall back to
  // OutputFormat bsd (see below).
  if ((OutputFormat == darwin || FormatMachOasHex) && (MachO || Obj.isIR())) {
    darwinPrintSymbol(Obj, I, SymbolAddrStr, printBlanks, printDashes,
                      printFormat);
  } else if (OutputFormat == posix) {
    outs() << Name << " " << I->TypeChar << " ";
    if (MachO)
      outs() << SymbolAddrStr << " " << "0" /* SymbolSizeStr */ << "\n";
    else
      outs() << SymbolAddrStr << " " << SymbolSizeStr << "\n";
  } else if (OutputFormat == bsd || (OutputFormat == darwin && !MachO)) {
    if (PrintAddress)
      outs() << SymbolAddrStr << ' ';
    if (PrintSize) {
      outs() << SymbolSizeStr;
      outs() << ' ';
    }
    outs() << I->TypeChar;
    if (I->TypeChar == '-' && MachO)
      darwinPrintStab(MachO, I);
    outs() << " " << Name;
    if (I->TypeChar == 'I' && MachO) {
      outs() << " (indirect for ";
      if (I->Sym.getRawDataRefImpl().p) {
        StringRef IndirectName;
        if (MachO->getIndirectName(I->Sym.getRawDataRefImpl(), IndirectName))
          outs() << "?)";
        else
          outs() << IndirectName << ")";
      } else
        outs() << I->IndirectName << ")";
    }
    outs() << "\n";
  } else if (OutputFormat == sysv) {
    std::string PaddedName(Name);
    while (PaddedName.length() < 20)
      PaddedName += " ";
    outs() << PaddedName << "|" << SymbolAddrStr << "|   " << I->TypeChar
           << "  |                  |" << SymbolSizeStr << "|     |\n";
  }
}

SymbolList.clear();
885}

887static char getSymbolNMTypeChar(ELFObjectFileBase &Obj,
                              basic_symbol_iterator I) {
// OK, this is ELF
elf_symbol_iterator SymI(I);

Expected<elf_section_iterator> SecIOrErr = SymI->getSection();
if (!SecIOrErr) {
  consumeError(SecIOrErr.takeError());
  return '?';
}

elf_section_iterator SecI = *SecIOrErr;
if (SecI != Obj.section_end()) {
  switch (SecI->getType()) {
  case ELF::SHT_PROGBITS:
  case ELF::SHT_DYNAMIC:
    switch (SecI->getFlags()) {
    case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR):
      return 't';
    case (ELF::SHF_TLS | ELF::SHF_ALLOC | ELF::SHF_WRITE):
    case (ELF::SHF_ALLOC | ELF::SHF_WRITE):
      return 'd';
    case ELF::SHF_ALLOC:
    case (ELF::SHF_ALLOC | ELF::SHF_MERGE):
    case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS):
      return 'r';
    }
    break;
  case ELF::SHT_NOBITS:
    return 'b';
  case ELF::SHT_INIT_ARRAY:
  case ELF::SHT_FINI_ARRAY:
    return 't';
  }
}

if (SymI->getELFType() == ELF::STT_SECTION) {
  Expected<StringRef> Name = SymI->getName();
  if (!Name) {
    consumeError(Name.takeError());
    return '?';
  }
  return StringSwitch<char>(*Name)
      .StartsWith(".debug", 'N')
      .StartsWith(".note", 'n')
      .Default('?');
}

return 'n';
936}

938static char getSymbolNMTypeChar(COFFObjectFile &Obj, symbol_iterator I) {
COFFSymbolRef Symb = Obj.getCOFFSymbol(*I);
// OK, this is COFF.
symbol_iterator SymI(I);

Expected<StringRef> Name = SymI->getName();
if (!Name) {
20
←
Taking true branch→
  consumeError(Name.takeError());
21
←
Calling 'consumeError'→
  return '?';
}

char Ret = StringSwitch<char>(*Name)
               .StartsWith(".debug", 'N')
               .StartsWith(".sxdata", 'N')
               .Default('?');

if (Ret != '?')
  return Ret;

uint32_t Characteristics = 0;
if (!COFF::isReservedSectionNumber(Symb.getSectionNumber())) {
  Expected<section_iterator> SecIOrErr = SymI->getSection();
  if (!SecIOrErr) {
    consumeError(SecIOrErr.takeError());
    return '?';
  }
  section_iterator SecI = *SecIOrErr;
  const coff_section *Section = Obj.getCOFFSection(*SecI);
  Characteristics = Section->Characteristics;
  StringRef SectionName;
  Obj.getSectionName(Section, SectionName);
  if (SectionName.startswith(".idata"))
    return 'i';
}

switch (Symb.getSectionNumber()) {
case COFF::IMAGE_SYM_DEBUG:
  return 'n';
default:
  // Check section type.
  if (Characteristics & COFF::IMAGE_SCN_CNT_CODE)
    return 't';
  if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
    return Characteristics & COFF::IMAGE_SCN_MEM_WRITE ? 'd' : 'r';
  if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
    return 'b';
  if (Characteristics & COFF::IMAGE_SCN_LNK_INFO)
    return 'i';
  // Check for section symbol.
  if (Symb.isSectionDefinition())
    return 's';
}

return '?';
992}

994static char getSymbolNMTypeChar(COFFImportFile &Obj) {
switch (Obj.getCOFFImportHeader()->getType()) {
case COFF::IMPORT_CODE:
  return 't';
case COFF::IMPORT_DATA:
  return 'd';
case COFF::IMPORT_CONST:
  return 'r';
}
return '?';
1004}

1006static char getSymbolNMTypeChar(MachOObjectFile &Obj, basic_symbol_iterator I) {
DataRefImpl Symb = I->getRawDataRefImpl();
uint8_t NType = Obj.is64Bit() ? Obj.getSymbol64TableEntry(Symb).n_type
                              : Obj.getSymbolTableEntry(Symb).n_type;

if (NType & MachO::N_STAB)
  return '-';

switch (NType & MachO::N_TYPE) {
case MachO::N_ABS:
  return 's';
case MachO::N_INDR:
  return 'i';
case MachO::N_SECT: {
  Expected<section_iterator> SecOrErr = Obj.getSymbolSection(Symb);
  if (!SecOrErr) {
    consumeError(SecOrErr.takeError());
    return 's';
  }
  section_iterator Sec = *SecOrErr;
  if (Sec == Obj.section_end())
    return 's';
  DataRefImpl Ref = Sec->getRawDataRefImpl();
  StringRef SectionName;
  Obj.getSectionName(Ref, SectionName);
  StringRef SegmentName = Obj.getSectionFinalSegmentName(Ref);
  if (Obj.is64Bit() && 
      Obj.getHeader64().filetype == MachO::MH_KEXT_BUNDLE &&
      SegmentName == "__TEXT_EXEC" && SectionName == "__text")
    return 't';
  if (SegmentName == "__TEXT" && SectionName == "__text")
    return 't';
  if (SegmentName == "__DATA" && SectionName == "__data")
    return 'd';
  if (SegmentName == "__DATA" && SectionName == "__bss")
    return 'b';
  return 's';
}
}

return '?';
1047}

1049static char getSymbolNMTypeChar(WasmObjectFile &Obj, basic_symbol_iterator I) {
uint32_t Flags = I->getFlags();
if (Flags & SymbolRef::SF_Executable)
  return 't';
return 'd';
1054}

1056static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I) {
uint32_t Flags = I->getFlags();
// FIXME: should we print 'b'? At the IR level we cannot be sure if this
// will be in bss or not, but we could approximate.
if (Flags & SymbolRef::SF_Executable)
  return 't';
else if (Triple(Obj.getTargetTriple()).isOSDarwin() &&
         (Flags & SymbolRef::SF_Const))
  return 's';
else
  return 'd';
1067}

1069static bool isObject(SymbolicFile &Obj, basic_symbol_iterator I) {
return !dyn_cast<ELFObjectFileBase>(&Obj)
           ? false
           : elf_symbol_iterator(I)->getELFType() == ELF::STT_OBJECT;
1073}

1075static char getNMTypeChar(SymbolicFile &Obj, basic_symbol_iterator I) {
uint32_t Symflags = I->getFlags();
if ((Symflags & object::SymbolRef::SF_Weak) && !isa<MachOObjectFile>(Obj)) {
10
←
Assuming the condition is false→
  char Ret = isObject(Obj, I) ? 'v' : 'w';
  return (!(Symflags & object::SymbolRef::SF_Undefined)) ? toupper(Ret) : Ret;
}

if (Symflags & object::SymbolRef::SF_Undefined)
11
←
Assuming the condition is false→
12
←
Taking false branch→
  return 'U';

if (Symflags & object::SymbolRef::SF_Common)
13
←
Assuming the condition is false→
14
←
Taking false branch→
  return 'C';

char Ret = '?';
if (Symflags & object::SymbolRef::SF_Absolute)
15
←
Assuming the condition is false→
16
←
Taking false branch→
  Ret = 'a';
else if (IRObjectFile *IR = dyn_cast<IRObjectFile>(&Obj))
17
←
Taking false branch→
  Ret = getSymbolNMTypeChar(*IR, I);
else if (COFFObjectFile *COFF = dyn_cast<COFFObjectFile>(&Obj))
18
←
Taking true branch→
  Ret = getSymbolNMTypeChar(*COFF, I);
19
←
Calling 'getSymbolNMTypeChar'→
else if (COFFImportFile *COFFImport = dyn_cast<COFFImportFile>(&Obj))
  Ret = getSymbolNMTypeChar(*COFFImport);
else if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
  Ret = getSymbolNMTypeChar(*MachO, I);
else if (WasmObjectFile *Wasm = dyn_cast<WasmObjectFile>(&Obj))
  Ret = getSymbolNMTypeChar(*Wasm, I);
else
  Ret = getSymbolNMTypeChar(cast<ELFObjectFileBase>(Obj), I);

if (Symflags & object::SymbolRef::SF_Global)
  Ret = toupper(Ret);

return Ret;
1108}

1110// getNsectForSegSect() is used to implement the Mach-O "-s segname sectname"
1111// option to dump only those symbols from that section in a Mach-O file.
1112// It is called once for each Mach-O file from dumpSymbolNamesFromObject()
1113// to get the section number for that named section from the command line
1114// arguments. It returns the section number for that section in the Mach-O
1115// file or zero it is not present.
1116static unsigned getNsectForSegSect(MachOObjectFile *Obj) {
unsigned Nsect = 1;
for (auto &S : Obj->sections()) {
  DataRefImpl Ref = S.getRawDataRefImpl();
  StringRef SectionName;
  Obj->getSectionName(Ref, SectionName);
  StringRef SegmentName = Obj->getSectionFinalSegmentName(Ref);
  if (SegmentName == SegSect[0] && SectionName == SegSect[1])
    return Nsect;
  Nsect++;
}
return 0;
1128}

1130// getNsectInMachO() is used to implement the Mach-O "-s segname sectname"
1131// option to dump only those symbols from that section in a Mach-O file.
1132// It is called once for each symbol in a Mach-O file from
1133// dumpSymbolNamesFromObject() and returns the section number for that symbol
1134// if it is in a section, else it returns 0.
1135static unsigned getNsectInMachO(MachOObjectFile &Obj, BasicSymbolRef Sym) {
DataRefImpl Symb = Sym.getRawDataRefImpl();
if (Obj.is64Bit()) {
  MachO::nlist_64 STE = Obj.getSymbol64TableEntry(Symb);
  return (STE.n_type & MachO::N_TYPE) == MachO::N_SECT ? STE.n_sect : 0;
}
MachO::nlist STE = Obj.getSymbolTableEntry(Symb);
return (STE.n_type & MachO::N_TYPE) == MachO::N_SECT ? STE.n_sect : 0;
1143}

1145static void
1146dumpSymbolNamesFromObject(SymbolicFile &Obj, bool printName,
                        const std::string &ArchiveName = std::string(),
                        const std::string &ArchitectureName = std::string()) {
auto Symbols = Obj.symbols();
if (DynamicSyms) {
1
Assuming the condition is false→
2
←
Taking false branch→
  const auto *E = dyn_cast<ELFObjectFileBase>(&Obj);
  if (!E) {
    error("File format has no dynamic symbol table", Obj.getFileName());
    return;
  }
  auto DynSymbols = E->getDynamicSymbolIterators();
  Symbols =
      make_range<basic_symbol_iterator>(DynSymbols.begin(), DynSymbols.end());
}
std::string NameBuffer;
raw_string_ostream OS(NameBuffer);
// If a "-s segname sectname" option was specified and this is a Mach-O
// file get the section number for that section in this object file.
unsigned int Nsect = 0;
MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
if (SegSect.size() != 0 && MachO) {
3
←
Assuming the condition is false→
  Nsect = getNsectForSegSect(MachO);
  // If this section is not in the object file no symbols are printed.
  if (Nsect == 0)
    return;
}
if (!MachO || !DyldInfoOnly) {
  for (BasicSymbolRef Sym : Symbols) {
    uint32_t SymFlags = Sym.getFlags();
    if (!DebugSyms && (SymFlags & SymbolRef::SF_FormatSpecific))
4
←
Assuming the condition is false→
      continue;
    if (WithoutAliases && (SymFlags & SymbolRef::SF_Indirect))
5
←
Assuming the condition is false→
      continue;
    // If a "-s segname sectname" option was specified and this is a Mach-O
    // file and this section appears in this file, Nsect will be non-zero then
    // see if this symbol is a symbol from that section and if not skip it.
    if (Nsect && Nsect != getNsectInMachO(*MachO, Sym))
      continue;
    NMSymbol S = {};
    S.Size = 0;
    S.Address = 0;
    if (PrintSize) {
6
←
Assuming the condition is false→
7
←
Taking false branch→
      if (isa<ELFObjectFileBase>(&Obj))
        S.Size = ELFSymbolRef(Sym).getSize();
    }
    if (PrintAddress && isa<ObjectFile>(Obj)) {
8
←
Assuming 'PrintAddress' is 0→
      SymbolRef SymRef(Sym);
      Expected<uint64_t> AddressOrErr = SymRef.getAddress();
      if (!AddressOrErr) {
        consumeError(AddressOrErr.takeError());
        break;
      }
      S.Address = *AddressOrErr;
    }
    S.TypeChar = getNMTypeChar(Obj, Sym);
9
←
Calling 'getNMTypeChar'→
    std::error_code EC = Sym.printName(OS);
    if (EC && MachO)
      OS << "bad string index";
    else
      error(EC);
    OS << '\0';
    S.Sym = Sym;
    SymbolList.push_back(S);
  }
}

OS.flush();
const char *P = NameBuffer.c_str();
unsigned I;
for (I = 0; I < SymbolList.size(); ++I) {
  SymbolList[I].Name = P;
  P += strlen(P) + 1;
}

// If this is a Mach-O file where the nlist symbol table is out of sync
// with the dyld export trie then look through exports and fake up symbols
// for the ones that are missing (also done with the -add-dyldinfo flag).
// This is needed if strip(1) -T is run on a binary containing swift
// language symbols for example.  The option -only-dyldinfo will fake up
// all symbols from the dyld export trie as well as the bind info.
std::string ExportsNameBuffer;
raw_string_ostream EOS(ExportsNameBuffer);
std::string BindsNameBuffer;
raw_string_ostream BOS(BindsNameBuffer);
std::string LazysNameBuffer;
raw_string_ostream LOS(LazysNameBuffer);
std::string WeaksNameBuffer;
raw_string_ostream WOS(WeaksNameBuffer);
std::string FunctionStartsNameBuffer;
raw_string_ostream FOS(FunctionStartsNameBuffer);
if (MachO && !NoDyldInfo) {
  MachO::mach_header H;
  MachO::mach_header_64 H_64;
  uint32_t HFlags = 0;
  if (MachO->is64Bit()) {
    H_64 = MachO->MachOObjectFile::getHeader64();
    HFlags = H_64.flags;
  } else {
    H = MachO->MachOObjectFile::getHeader();
    HFlags = H.flags;
  }
  uint64_t BaseSegmentAddress = 0;
  for (const auto &Command : MachO->load_commands()) {
    if (Command.C.cmd == MachO::LC_SEGMENT) {
      MachO::segment_command Seg = MachO->getSegmentLoadCommand(Command);
      if (Seg.fileoff == 0 && Seg.filesize != 0) {
        BaseSegmentAddress = Seg.vmaddr;
        break;
      }
    } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
      MachO::segment_command_64 Seg = MachO->getSegment64LoadCommand(Command);
      if (Seg.fileoff == 0 && Seg.filesize != 0) {
        BaseSegmentAddress = Seg.vmaddr;
        break;
      }
    }
  }
  if (DyldInfoOnly || AddDyldInfo ||
      HFlags & MachO::MH_NLIST_OUTOFSYNC_WITH_DYLDINFO) {
    unsigned ExportsAdded = 0;
    Error Err = Error::success();
    for (const llvm::object::ExportEntry &Entry : MachO->exports(Err)) {
      bool found = false;
      bool ReExport = false;
      if (!DyldInfoOnly) {
        for (unsigned J = 0; J < SymbolList.size() && !found; ++J) {
          if (SymbolList[J].Address == Entry.address() + BaseSegmentAddress &&
              SymbolList[J].Name == Entry.name())
            found = true;
        }
      }
      if (!found) {
        NMSymbol S = {};
        S.Address = Entry.address() + BaseSegmentAddress;
        S.Size = 0;
        S.TypeChar = '\0';
        S.Name = Entry.name();
        // There is no symbol in the nlist symbol table for this so we set
        // Sym effectivly to null and the rest of code in here must test for
        // it and not do things like Sym.getFlags() for it.
        S.Sym = BasicSymbolRef();
        S.SymFlags = SymbolRef::SF_Global;
        S.Section = SectionRef();
        S.NType = 0;
        S.NSect = 0;
        S.NDesc = 0;
        S.IndirectName = StringRef();

        uint64_t EFlags = Entry.flags();
        bool Abs = ((EFlags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) ==
                    MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE);
        bool Resolver = (EFlags &
                         MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER);
        ReExport = (EFlags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT);
        bool WeakDef = (EFlags & MachO::EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION);
        if (WeakDef)
          S.NDesc |= MachO::N_WEAK_DEF;
        if (Abs) {
          S.NType = MachO::N_EXT | MachO::N_ABS;
          S.TypeChar = 'A';
        } else if (ReExport) {
          S.NType = MachO::N_EXT | MachO::N_INDR;
          S.TypeChar = 'I';
        } else {
          S.NType = MachO::N_EXT | MachO::N_SECT;
          if (Resolver) {
            S.Address = Entry.other() + BaseSegmentAddress;
            if ((S.Address & 1) != 0 &&
                !MachO->is64Bit() && H.cputype == MachO::CPU_TYPE_ARM){
              S.Address &= ~1LL;
              S.NDesc |= MachO::N_ARM_THUMB_DEF;
            }
          } else {
            S.Address = Entry.address() + BaseSegmentAddress;
          }
          StringRef SegmentName = StringRef();
          StringRef SectionName = StringRef();
          for (const SectionRef &Section : MachO->sections()) {
            S.NSect++;
            Section.getName(SectionName);
            SegmentName = MachO->getSectionFinalSegmentName(
                                                Section.getRawDataRefImpl());
            if (S.Address >= Section.getAddress() &&
                S.Address < Section.getAddress() + Section.getSize()) {
              S.Section = Section;
              break;
            } else if (Entry.name() == "__mh_execute_header" &&
                       SegmentName == "__TEXT" && SectionName == "__text") {
              S.Section = Section;
              S.NDesc |= MachO::REFERENCED_DYNAMICALLY;
              break;
            }
          }
          if (SegmentName == "__TEXT" && SectionName == "__text")
            S.TypeChar = 'T';
          else if (SegmentName == "__DATA" && SectionName == "__data")
            S.TypeChar = 'D';
          else if (SegmentName == "__DATA" && SectionName == "__bss")
            S.TypeChar = 'B';
          else
            S.TypeChar = 'S';
        }
        SymbolList.push_back(S);

        EOS << Entry.name();
        EOS << '\0';
        ExportsAdded++;

        // For ReExports there are a two more things to do, first add the
        // indirect name and second create the undefined symbol using the
        // referened dynamic library.
        if (ReExport) {

          // Add the indirect name.
          if (Entry.otherName().empty())
            EOS << Entry.name();
          else
            EOS << Entry.otherName();
          EOS << '\0';

          // Now create the undefined symbol using the referened dynamic
          // library.
          NMSymbol U = {};
          U.Address = 0;
          U.Size = 0;
          U.TypeChar = 'U';
          if (Entry.otherName().empty())
            U.Name = Entry.name();
          else
            U.Name = Entry.otherName();
          // Again there is no symbol in the nlist symbol table for this so
          // we set Sym effectivly to null and the rest of code in here must
          // test for it and not do things like Sym.getFlags() for it.
          U.Sym = BasicSymbolRef();
          U.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
          U.Section = SectionRef();
          U.NType = MachO::N_EXT | MachO::N_UNDF;
          U.NSect = 0;
          U.NDesc = 0;
          // The library ordinal for this undefined symbol is in the export
          // trie Entry.other().
          MachO::SET_LIBRARY_ORDINAL(U.NDesc, Entry.other());
          U.IndirectName = StringRef();
          SymbolList.push_back(U);

          // Finally add the undefined symbol's name.
          if (Entry.otherName().empty())
            EOS << Entry.name();
          else
            EOS << Entry.otherName();
          EOS << '\0';
          ExportsAdded++;
        }
      }
    }
    if (Err)
      error(std::move(Err), MachO->getFileName());
    // Set the symbol names and indirect names for the added symbols.
    if (ExportsAdded) {
      EOS.flush();
      const char *Q = ExportsNameBuffer.c_str();
      for (unsigned K = 0; K < ExportsAdded; K++) {
        SymbolList[I].Name = Q;
        Q += strlen(Q) + 1;
        if (SymbolList[I].TypeChar == 'I') {
          SymbolList[I].IndirectName = Q;
          Q += strlen(Q) + 1;
        }
        I++;
      }
    }

    // Add the undefined symbols from the bind entries.
    unsigned BindsAdded = 0;
    Error BErr = Error::success();
    StringRef LastSymbolName = StringRef();
    for (const llvm::object::MachOBindEntry &Entry : MachO->bindTable(BErr)) {
      bool found = false;
      if (LastSymbolName == Entry.symbolName())
        found = true;
      else if(!DyldInfoOnly) {
        for (unsigned J = 0; J < SymbolList.size() && !found; ++J) {
          if (SymbolList[J].Name == Entry.symbolName())
            found = true;
        }
      }
      if (!found) {
        LastSymbolName = Entry.symbolName();
        NMSymbol B = {};
        B.Address = 0;
        B.Size = 0;
        B.TypeChar = 'U';
        // There is no symbol in the nlist symbol table for this so we set
        // Sym effectivly to null and the rest of code in here must test for
        // it and not do things like Sym.getFlags() for it.
        B.Sym = BasicSymbolRef();
        B.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
        B.NType = MachO::N_EXT | MachO::N_UNDF;
        B.NSect = 0;
        B.NDesc = 0;
        B.NDesc = 0;
        MachO::SET_LIBRARY_ORDINAL(B.NDesc, Entry.ordinal());
        B.IndirectName = StringRef();
        B.Name = Entry.symbolName();
        SymbolList.push_back(B);
        BOS << Entry.symbolName();
        BOS << '\0';
        BindsAdded++;
      }
    }
    if (BErr)
      error(std::move(BErr), MachO->getFileName());
    // Set the symbol names and indirect names for the added symbols.
    if (BindsAdded) {
      BOS.flush();
      const char *Q = BindsNameBuffer.c_str();
      for (unsigned K = 0; K < BindsAdded; K++) {
        SymbolList[I].Name = Q;
        Q += strlen(Q) + 1;
        if (SymbolList[I].TypeChar == 'I') {
          SymbolList[I].IndirectName = Q;
          Q += strlen(Q) + 1;
        }
        I++;
      }
    }

    // Add the undefined symbols from the lazy bind entries.
    unsigned LazysAdded = 0;
    Error LErr = Error::success();
    LastSymbolName = StringRef();
    for (const llvm::object::MachOBindEntry &Entry :
         MachO->lazyBindTable(LErr)) {
      bool found = false;
      if (LastSymbolName == Entry.symbolName())
        found = true;
      else {
        // Here we must check to see it this symbol is already in the
        // SymbolList as it might have already have been added above via a
        // non-lazy (bind) entry.
        for (unsigned J = 0; J < SymbolList.size() && !found; ++J) {
          if (SymbolList[J].Name == Entry.symbolName())
            found = true;
        }
      }
      if (!found) {
        LastSymbolName = Entry.symbolName();
        NMSymbol L = {};
        L.Name = Entry.symbolName();
        L.Address = 0;
        L.Size = 0;
        L.TypeChar = 'U';
        // There is no symbol in the nlist symbol table for this so we set
        // Sym effectivly to null and the rest of code in here must test for
        // it and not do things like Sym.getFlags() for it.
        L.Sym = BasicSymbolRef();
        L.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
        L.NType = MachO::N_EXT | MachO::N_UNDF;
        L.NSect = 0;
        // The REFERENCE_FLAG_UNDEFINED_LAZY is no longer used but here it
        // makes sence since we are creating this from a lazy bind entry.
        L.NDesc = MachO::REFERENCE_FLAG_UNDEFINED_LAZY;
        MachO::SET_LIBRARY_ORDINAL(L.NDesc, Entry.ordinal());
        L.IndirectName = StringRef();
        SymbolList.push_back(L);
        LOS << Entry.symbolName();
        LOS << '\0';
        LazysAdded++;
      }
    }
    if (LErr)
      error(std::move(LErr), MachO->getFileName());
    // Set the symbol names and indirect names for the added symbols.
    if (LazysAdded) {
      LOS.flush();
      const char *Q = LazysNameBuffer.c_str();
      for (unsigned K = 0; K < LazysAdded; K++) {
        SymbolList[I].Name = Q;
        Q += strlen(Q) + 1;
        if (SymbolList[I].TypeChar == 'I') {
          SymbolList[I].IndirectName = Q;
          Q += strlen(Q) + 1;
        }
        I++;
      }
    }

    // Add the undefineds symbol from the weak bind entries which are not
    // strong symbols.
    unsigned WeaksAdded = 0;
    Error WErr = Error::success();
    LastSymbolName = StringRef();
    for (const llvm::object::MachOBindEntry &Entry :
         MachO->weakBindTable(WErr)) {
      bool found = false;
      unsigned J = 0;
      if (LastSymbolName == Entry.symbolName() ||
          Entry.flags() & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION) {
        found = true;
      } else {
        for (J = 0; J < SymbolList.size() && !found; ++J) {
          if (SymbolList[J].Name == Entry.symbolName()) {
             found = true;
             break;
          }
        }
      }
      if (!found) {
        LastSymbolName = Entry.symbolName();
        NMSymbol W;
        memset(&W, '\0', sizeof(NMSymbol));
        W.Name = Entry.symbolName();
        W.Address = 0;
        W.Size = 0;
        W.TypeChar = 'U';
        // There is no symbol in the nlist symbol table for this so we set
        // Sym effectivly to null and the rest of code in here must test for
        // it and not do things like Sym.getFlags() for it.
        W.Sym = BasicSymbolRef();
        W.SymFlags = SymbolRef::SF_Global | SymbolRef::SF_Undefined;
        W.NType = MachO::N_EXT | MachO::N_UNDF;
        W.NSect = 0;
        // Odd that we are using N_WEAK_DEF on an undefined symbol but that is
        // what is created in this case by the linker when there are real
        // symbols in the nlist structs.
        W.NDesc = MachO::N_WEAK_DEF;
        W.IndirectName = StringRef();
        SymbolList.push_back(W);
        WOS << Entry.symbolName();
        WOS << '\0';
        WeaksAdded++;
      } else {
        // This is the case the symbol was previously been found and it could
        // have been added from a bind or lazy bind symbol.  If so and not
        // a definition also mark it as weak.
        if (SymbolList[J].TypeChar == 'U')
          // See comment above about N_WEAK_DEF.
          SymbolList[J].NDesc |= MachO::N_WEAK_DEF;
      }
    }
    if (WErr)
      error(std::move(WErr), MachO->getFileName());
    // Set the symbol names and indirect names for the added symbols.
    if (WeaksAdded) {
      WOS.flush();
      const char *Q = WeaksNameBuffer.c_str();
      for (unsigned K = 0; K < WeaksAdded; K++) {
        SymbolList[I].Name = Q;
        Q += strlen(Q) + 1;
        if (SymbolList[I].TypeChar == 'I') {
          SymbolList[I].IndirectName = Q;
          Q += strlen(Q) + 1;
        }
        I++;
      }
    }

    // Trying adding symbol from the function starts table and LC_MAIN entry
    // point.
    SmallVector<uint64_t, 8> FoundFns;
    uint64_t lc_main_offset = UINT64_MAX(18446744073709551615UL);
    for (const auto &Command : MachO->load_commands()) {
      if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
        // We found a function starts segment, parse the addresses for 
        // consumption.
        MachO::linkedit_data_command LLC =
          MachO->getLinkeditDataLoadCommand(Command);

        MachO->ReadULEB128s(LLC.dataoff, FoundFns);
      } else if (Command.C.cmd == MachO::LC_MAIN) {
        MachO::entry_point_command LCmain =
          MachO->getEntryPointCommand(Command);
        lc_main_offset = LCmain.entryoff;
      }
    }
    // See if these addresses are already in the symbol table.
    unsigned FunctionStartsAdded = 0;
    for (uint64_t f = 0; f < FoundFns.size(); f++) {
      bool found = false;
      for (unsigned J = 0; J < SymbolList.size() && !found; ++J) {
        if (SymbolList[J].Address == FoundFns[f] + BaseSegmentAddress)
          found = true;
      }
      // See this address is not already in the symbol table fake up an
      // nlist for it.
      if (!found) {
        NMSymbol F = {};
        F.Name = "<redacted function X>";
        F.Address = FoundFns[f] + BaseSegmentAddress;
        F.Size = 0;
        // There is no symbol in the nlist symbol table for this so we set
        // Sym effectivly to null and the rest of code in here must test for
        // it and not do things like Sym.getFlags() for it.
        F.Sym = BasicSymbolRef();
        F.SymFlags = 0;
        F.NType = MachO::N_SECT;
        F.NSect = 0;
        StringRef SegmentName = StringRef();
        StringRef SectionName = StringRef();
        for (const SectionRef &Section : MachO->sections()) {
          Section.getName(SectionName);
          SegmentName = MachO->getSectionFinalSegmentName(
                                              Section.getRawDataRefImpl());
          F.NSect++;
          if (F.Address >= Section.getAddress() &&
              F.Address < Section.getAddress() + Section.getSize()) {
            F.Section = Section;
            break;
          }
        }
        if (SegmentName == "__TEXT" && SectionName == "__text")
          F.TypeChar = 't';
        else if (SegmentName == "__DATA" && SectionName == "__data")
          F.TypeChar = 'd';
        else if (SegmentName == "__DATA" && SectionName == "__bss")
          F.TypeChar = 'b';
        else
          F.TypeChar = 's';
        F.NDesc = 0;
        F.IndirectName = StringRef();
        SymbolList.push_back(F);
        if (FoundFns[f] == lc_main_offset)
          FOS << "<redacted LC_MAIN>";
        else
          FOS << "<redacted function " << f << ">";
        FOS << '\0';
        FunctionStartsAdded++;
      }
    }
    if (FunctionStartsAdded) {
      FOS.flush();
      const char *Q = FunctionStartsNameBuffer.c_str();
      for (unsigned K = 0; K < FunctionStartsAdded; K++) {
        SymbolList[I].Name = Q;
        Q += strlen(Q) + 1;
        if (SymbolList[I].TypeChar == 'I') {
          SymbolList[I].IndirectName = Q;
          Q += strlen(Q) + 1;
        }
        I++;
      }
    }
  }
}

CurrentFilename = Obj.getFileName();
sortAndPrintSymbolList(Obj, printName, ArchiveName, ArchitectureName);
1693}

1695// checkMachOAndArchFlags() checks to see if the SymbolicFile is a Mach-O file
1696// and if it is and there is a list of architecture flags is specified then
1697// check to make sure this Mach-O file is one of those architectures or all
1698// architectures was specificed.  If not then an error is generated and this
1699// routine returns false.  Else it returns true.
1700static bool checkMachOAndArchFlags(SymbolicFile *O, std::string &Filename) {
auto *MachO = dyn_cast<MachOObjectFile>(O);

if (!MachO || ArchAll || ArchFlags.empty())
  return true;

MachO::mach_header H;
MachO::mach_header_64 H_64;
Triple T;
const char *McpuDefault, *ArchFlag;
if (MachO->is64Bit()) {
  H_64 = MachO->MachOObjectFile::getHeader64();
  T = MachOObjectFile::getArchTriple(H_64.cputype, H_64.cpusubtype,
                                     &McpuDefault, &ArchFlag);
} else {
  H = MachO->MachOObjectFile::getHeader();
  T = MachOObjectFile::getArchTriple(H.cputype, H.cpusubtype,
                                     &McpuDefault, &ArchFlag);
}
const std::string ArchFlagName(ArchFlag);
if (none_of(ArchFlags, [&](const std::string &Name) {
      return Name == ArchFlagName;
    })) {
  error("No architecture specified", Filename);
  return false;
}
return true;
1727}

1729static void dumpSymbolNamesFromFile(std::string &Filename) {
ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
    MemoryBuffer::getFileOrSTDIN(Filename);
if (error(BufferOrErr.getError(), Filename))
  return;

LLVMContext Context;
Expected<std::unique_ptr<Binary>> BinaryOrErr = createBinary(
    BufferOrErr.get()->getMemBufferRef(), NoLLVMBitcode ? nullptr : &Context);
if (!BinaryOrErr) {
  error(BinaryOrErr.takeError(), Filename);
  return;
}
Binary &Bin = *BinaryOrErr.get();

if (Archive *A = dyn_cast<Archive>(&Bin)) {
  if (ArchiveMap) {
    Archive::symbol_iterator I = A->symbol_begin();
    Archive::symbol_iterator E = A->symbol_end();
    if (I != E) {
      outs() << "Archive map\n";
      for (; I != E; ++I) {
        Expected<Archive::Child> C = I->getMember();
        if (!C) {
          error(C.takeError(), Filename);
          break;
        }
        Expected<StringRef> FileNameOrErr = C->getName();
        if (!FileNameOrErr) {
          error(FileNameOrErr.takeError(), Filename);
          break;
        }
        StringRef SymName = I->getName();
        outs() << SymName << " in " << FileNameOrErr.get() << "\n";
      }
      outs() << "\n";
    }
  }

  {
    Error Err = Error::success();
    for (auto &C : A->children(Err)) {
      Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(&Context);
      if (!ChildOrErr) {
        if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
          error(std::move(E), Filename, C);
        continue;
      }
      if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
        if (!MachOPrintSizeWarning && PrintSize &&  isa<MachOObjectFile>(O)) {
          errs() << ToolName << ": warning sizes with -print-size for Mach-O "
                    "files are always zero.\n";
          MachOPrintSizeWarning = true;
        }
        if (!checkMachOAndArchFlags(O, Filename))
          return;
        if (!PrintFileName) {
          outs() << "\n";
          if (isa<MachOObjectFile>(O)) {
            outs() << Filename << "(" << O->getFileName() << ")";
          } else
            outs() << O->getFileName();
          outs() << ":\n";
        }
        dumpSymbolNamesFromObject(*O, false, Filename);
      }
    }
    if (Err)
      error(std::move(Err), A->getFileName());
  }
  return;
}
if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
  // If we have a list of architecture flags specified dump only those.
  if (!ArchAll && ArchFlags.size() != 0) {
    // Look for a slice in the universal binary that matches each ArchFlag.
    bool ArchFound;
    for (unsigned i = 0; i < ArchFlags.size(); ++i) {
      ArchFound = false;
      for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
                                                 E = UB->end_objects();
           I != E; ++I) {
        if (ArchFlags[i] == I->getArchFlagName()) {
          ArchFound = true;
          Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
              I->getAsObjectFile();
          std::string ArchiveName;
          std::string ArchitectureName;
          ArchiveName.clear();
          ArchitectureName.clear();
          if (ObjOrErr) {
            ObjectFile &Obj = *ObjOrErr.get();
            if (ArchFlags.size() > 1) {
              if (PrintFileName)
                ArchitectureName = I->getArchFlagName();
              else
                outs() << "\n" << Obj.getFileName() << " (for architecture "
                       << I->getArchFlagName() << ")"
                       << ":\n";
            }
            dumpSymbolNamesFromObject(Obj, false, ArchiveName,
                                      ArchitectureName);
          } else if (auto E = isNotObjectErrorInvalidFileType(
                     ObjOrErr.takeError())) {
            error(std::move(E), Filename, ArchFlags.size() > 1 ?
                  StringRef(I->getArchFlagName()) : StringRef());
            continue;
          } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                         I->getAsArchive()) {
            std::unique_ptr<Archive> &A = *AOrErr;
            Error Err = Error::success();
            for (auto &C : A->children(Err)) {
              Expected<std::unique_ptr<Binary>> ChildOrErr =
                  C.getAsBinary(&Context);
              if (!ChildOrErr) {
                if (auto E = isNotObjectErrorInvalidFileType(
                                     ChildOrErr.takeError())) {
                  error(std::move(E), Filename, C, ArchFlags.size() > 1 ?
                        StringRef(I->getArchFlagName()) : StringRef());
                }
                continue;
              }
              if (SymbolicFile *O =
                      dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
                if (PrintFileName) {
                  ArchiveName = A->getFileName();
                  if (ArchFlags.size() > 1)
                    ArchitectureName = I->getArchFlagName();
                } else {
                  outs() << "\n" << A->getFileName();
                  outs() << "(" << O->getFileName() << ")";
                  if (ArchFlags.size() > 1) {
                    outs() << " (for architecture " << I->getArchFlagName()
                           << ")";
                  }
                  outs() << ":\n";
                }
                dumpSymbolNamesFromObject(*O, false, ArchiveName,
                                          ArchitectureName);
              }
            }
            if (Err)
              error(std::move(Err), A->getFileName());
          } else {
            consumeError(AOrErr.takeError());
            error(Filename + " for architecture " +
                  StringRef(I->getArchFlagName()) +
                  " is not a Mach-O file or an archive file",
                  "Mach-O universal file");
          }
        }
      }
      if (!ArchFound) {
        error(ArchFlags[i],
              "file: " + Filename + " does not contain architecture");
        return;
      }
    }
    return;
  }
  // No architecture flags were specified so if this contains a slice that
  // matches the host architecture dump only that.
  if (!ArchAll) {
    StringRef HostArchName = MachOObjectFile::getHostArch().getArchName();
    for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
                                               E = UB->end_objects();
         I != E; ++I) {
      if (HostArchName == I->getArchFlagName()) {
        Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
        std::string ArchiveName;
        if (ObjOrErr) {
          ObjectFile &Obj = *ObjOrErr.get();
          dumpSymbolNamesFromObject(Obj, false);
        } else if (auto E = isNotObjectErrorInvalidFileType(
                   ObjOrErr.takeError())) {
          error(std::move(E), Filename);
          return;
        } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                       I->getAsArchive()) {
          std::unique_ptr<Archive> &A = *AOrErr;
          Error Err = Error::success();
          for (auto &C : A->children(Err)) {
            Expected<std::unique_ptr<Binary>> ChildOrErr =
                C.getAsBinary(&Context);
            if (!ChildOrErr) {
              if (auto E = isNotObjectErrorInvalidFileType(
                                   ChildOrErr.takeError()))
                error(std::move(E), Filename, C);
              continue;
            }
            if (SymbolicFile *O =
                    dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
              if (PrintFileName)
                ArchiveName = A->getFileName();
              else
                outs() << "\n" << A->getFileName() << "(" << O->getFileName()
                       << ")"
                       << ":\n";
              dumpSymbolNamesFromObject(*O, false, ArchiveName);
            }
          }
          if (Err)
            error(std::move(Err), A->getFileName());
        } else {
          consumeError(AOrErr.takeError());
          error(Filename + " for architecture " +
                StringRef(I->getArchFlagName()) +
                " is not a Mach-O file or an archive file",
                "Mach-O universal file");
        }
        return;
      }
    }
  }
  // Either all architectures have been specified or none have been specified
  // and this does not contain the host architecture so dump all the slices.
  bool moreThanOneArch = UB->getNumberOfObjects() > 1;
  for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
                                             E = UB->end_objects();
       I != E; ++I) {
    Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
    std::string ArchiveName;
    std::string ArchitectureName;
    ArchiveName.clear();
    ArchitectureName.clear();
    if (ObjOrErr) {
      ObjectFile &Obj = *ObjOrErr.get();
      if (PrintFileName) {
        if (isa<MachOObjectFile>(Obj) && moreThanOneArch)
          ArchitectureName = I->getArchFlagName();
      } else {
        if (moreThanOneArch)
          outs() << "\n";
        outs() << Obj.getFileName();
        if (isa<MachOObjectFile>(Obj) && moreThanOneArch)
          outs() << " (for architecture " << I->getArchFlagName() << ")";
        outs() << ":\n";
      }
      dumpSymbolNamesFromObject(Obj, false, ArchiveName, ArchitectureName);
    } else if (auto E = isNotObjectErrorInvalidFileType(
               ObjOrErr.takeError())) {
      error(std::move(E), Filename, moreThanOneArch ?
            StringRef(I->getArchFlagName()) : StringRef());
      continue;
    } else if (Expected<std::unique_ptr<Archive>> AOrErr =
                I->getAsArchive()) {
      std::unique_ptr<Archive> &A = *AOrErr;
      Error Err = Error::success();
      for (auto &C : A->children(Err)) {
        Expected<std::unique_ptr<Binary>> ChildOrErr =
          C.getAsBinary(&Context);
        if (!ChildOrErr) {
          if (auto E = isNotObjectErrorInvalidFileType(
                               ChildOrErr.takeError()))
            error(std::move(E), Filename, C, moreThanOneArch ?
                  StringRef(ArchitectureName) : StringRef());
          continue;
        }
        if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
          if (PrintFileName) {
            ArchiveName = A->getFileName();
            if (isa<MachOObjectFile>(O) && moreThanOneArch)
              ArchitectureName = I->getArchFlagName();
          } else {
            outs() << "\n" << A->getFileName();
            if (isa<MachOObjectFile>(O)) {
              outs() << "(" << O->getFileName() << ")";
              if (moreThanOneArch)
                outs() << " (for architecture " << I->getArchFlagName()
                       << ")";
            } else
              outs() << ":" << O->getFileName();
            outs() << ":\n";
          }
          dumpSymbolNamesFromObject(*O, false, ArchiveName, ArchitectureName);
        }
      }
      if (Err)
        error(std::move(Err), A->getFileName());
    } else {
      consumeError(AOrErr.takeError());
      error(Filename + " for architecture " +
            StringRef(I->getArchFlagName()) +
            " is not a Mach-O file or an archive file",
            "Mach-O universal file");
    }
  }
  return;
}
if (SymbolicFile *O = dyn_cast<SymbolicFile>(&Bin)) {
  if (!MachOPrintSizeWarning && PrintSize &&  isa<MachOObjectFile>(O)) {
    errs() << ToolName << ": warning sizes with -print-size for Mach-O files "
              "are always zero.\n";
    MachOPrintSizeWarning = true;
  }
  if (!checkMachOAndArchFlags(O, Filename))
    return;
  dumpSymbolNamesFromObject(*O, true);
}
2028}

2030int main(int argc, char **argv) {
InitLLVM X(argc, argv);
cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n");

// llvm-nm only reads binary files.
if (error(sys::ChangeStdinToBinary()))
  return 1;

// These calls are needed so that we can read bitcode correctly.
llvm::InitializeAllTargetInfos();
llvm::InitializeAllTargetMCs();
llvm::InitializeAllAsmParsers();

ToolName = argv[0];
if (BSDFormat)
  OutputFormat = bsd;
if (POSIXFormat)
  OutputFormat = posix;
if (DarwinFormat)
  OutputFormat = darwin;

// The relative order of these is important. If you pass --size-sort it should
// only print out the size. However, if you pass -S --size-sort, it should
// print out both the size and address.
if (SizeSort && !PrintSize)
  PrintAddress = false;
if (OutputFormat == sysv || SizeSort)
  PrintSize = true;
if (InputFilenames.empty())
  InputFilenames.push_back("a.out");
if (InputFilenames.size() > 1)
  MultipleFiles = true;

for (unsigned i = 0; i < ArchFlags.size(); ++i) {
  if (ArchFlags[i] == "all") {
    ArchAll = true;
  } else {
    if (!MachOObjectFile::isValidArch(ArchFlags[i]))
      error("Unknown architecture named '" + ArchFlags[i] + "'",
            "for the -arch option");
  }
}

if (SegSect.size() != 0 && SegSect.size() != 2)
  error("bad number of arguments (must be two arguments)",
        "for the -s option");

if (NoDyldInfo && (AddDyldInfo || DyldInfoOnly))
  error("-no-dyldinfo can't be used with -add-dyldinfo or -dyldinfo-only");

llvm::for_each(InputFilenames, dumpSymbolNamesFromFile);

if (HadError)
  return 1;
2084}

←

/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h

1//===- llvm/Support/Error.h - Recoverable error handling --------*- 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// This file defines an API used to report recoverable errors.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_SUPPORT_ERROR_H
15#define LLVM_SUPPORT_ERROR_H
16 
17#include "llvm-c/Error.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/ADT/StringExtras.h"
21#include "llvm/ADT/Twine.h"
22#include "llvm/Config/abi-breaking.h"
23#include "llvm/Support/AlignOf.h"
24#include "llvm/Support/Compiler.h"
25#include "llvm/Support/Debug.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Support/ErrorOr.h"
28#include "llvm/Support/Format.h"
29#include "llvm/Support/raw_ostream.h"
30#include <algorithm>
31#include <cassert>
32#include <cstdint>
33#include <cstdlib>
34#include <functional>
35#include <memory>
36#include <new>
37#include <string>
38#include <system_error>
39#include <type_traits>
40#include <utility>
41#include <vector>
42 
43namespace llvm {
44 
45class ErrorSuccess;
46 
47/// Base class for error info classes. Do not extend this directly: Extend
48/// the ErrorInfo template subclass instead.
49class ErrorInfoBase {
50public:
51  virtual ~ErrorInfoBase() = default;
52 
53  /// Print an error message to an output stream.
54  virtual void log(raw_ostream &OS) const = 0;
55 
56  /// Return the error message as a string.
57  virtual std::string message() const {
58    std::string Msg;
59    raw_string_ostream OS(Msg);
60    log(OS);
61    return OS.str();
62  }
63 
64  /// Convert this error to a std::error_code.
65  ///
66  /// This is a temporary crutch to enable interaction with code still
67  /// using std::error_code. It will be removed in the future.
68  virtual std::error_code convertToErrorCode() const = 0;
69 
70  // Returns the class ID for this type.
71  static const void *classID() { return &ID; }
72 
73  // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
74  virtual const void *dynamicClassID() const = 0;
75 
76  // Check whether this instance is a subclass of the class identified by
77  // ClassID.
78  virtual bool isA(const void *const ClassID) const {
79    return ClassID == classID();
80  }
81 
82  // Check whether this instance is a subclass of ErrorInfoT.
83  template <typename ErrorInfoT> bool isA() const {
84    return isA(ErrorInfoT::classID());
85  }
86 
87private:
88  virtual void anchor();
89 
90  static char ID;
91};
92 
93/// Lightweight error class with error context and mandatory checking.
94///
95/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
96/// are represented by setting the pointer to a ErrorInfoBase subclass
97/// instance containing information describing the failure. Success is
98/// represented by a null pointer value.
99///
100/// Instances of Error also contains a 'Checked' flag, which must be set
101/// before the destructor is called, otherwise the destructor will trigger a
102/// runtime error. This enforces at runtime the requirement that all Error
103/// instances be checked or returned to the caller.
104///
105/// There are two ways to set the checked flag, depending on what state the
106/// Error instance is in. For Error instances indicating success, it
107/// is sufficient to invoke the boolean conversion operator. E.g.:
108///
109///   @code{.cpp}
110///   Error foo(<...>);
111///
112///   if (auto E = foo(<...>))
113///     return E; // <- Return E if it is in the error state.
114///   // We have verified that E was in the success state. It can now be safely
115///   // destroyed.
116///   @endcode
117///
118/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
119/// without testing the return value will raise a runtime error, even if foo
120/// returns success.
121///
122/// For Error instances representing failure, you must use either the
123/// handleErrors or handleAllErrors function with a typed handler. E.g.:
124///
125///   @code{.cpp}
126///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
127///     // Custom error info.
128///   };
129///
130///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
131///
132///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
133///   auto NewE =
134///     handleErrors(E,
135///       [](const MyErrorInfo &M) {
136///         // Deal with the error.
137///       },
138///       [](std::unique_ptr<OtherError> M) -> Error {
139///         if (canHandle(*M)) {
140///           // handle error.
141///           return Error::success();
142///         }
143///         // Couldn't handle this error instance. Pass it up the stack.
144///         return Error(std::move(M));
145///       );
146///   // Note - we must check or return NewE in case any of the handlers
147///   // returned a new error.
148///   @endcode
149///
150/// The handleAllErrors function is identical to handleErrors, except
151/// that it has a void return type, and requires all errors to be handled and
152/// no new errors be returned. It prevents errors (assuming they can all be
153/// handled) from having to be bubbled all the way to the top-level.
154///
155/// *All* Error instances must be checked before destruction, even if
156/// they're moved-assigned or constructed from Success values that have already
157/// been checked. This enforces checking through all levels of the call stack.
158class LLVM_NODISCARD[[clang::warn_unused_result]] Error {
159  // Both ErrorList and FileError need to be able to yank ErrorInfoBase
160  // pointers out of this class to add to the error list.
161  friend class ErrorList;
162  friend class FileError;
163 
164  // handleErrors needs to be able to set the Checked flag.
165  template <typename... HandlerTs>
166  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
167 
168  // Expected<T> needs to be able to steal the payload when constructed from an
169  // error.
170  template <typename T> friend class Expected;
171 
172  // wrap needs to be able to steal the payload.
173  friend LLVMErrorRef wrap(Error);
174 
175protected:
176  /// Create a success value. Prefer using 'Error::success()' for readability
177  Error() {
178    setPtr(nullptr);
179    setChecked(false);
180  }
181 
182public:
183  /// Create a success value.
184  static ErrorSuccess success();
185 
186  // Errors are not copy-constructable.
187  Error(const Error &Other) = delete;
188 
189  /// Move-construct an error value. The newly constructed error is considered
190  /// unchecked, even if the source error had been checked. The original error
191  /// becomes a checked Success value, regardless of its original state.
192  Error(Error &&Other) {
193    setChecked(true);
194    *this = std::move(Other);
195  }
196 
197  /// Create an error value. Prefer using the 'make_error' function, but
198  /// this constructor can be useful when "re-throwing" errors from handlers.
199  Error(std::unique_ptr<ErrorInfoBase> Payload) {
200    setPtr(Payload.release());
201    setChecked(false);
36
←
Potential leak of memory pointed to by 'Payload._M_t._M_head_impl'
202  }
203 
204  // Errors are not copy-assignable.
205  Error &operator=(const Error &Other) = delete;
206 
207  /// Move-assign an error value. The current error must represent success, you
208  /// you cannot overwrite an unhandled error. The current error is then
209  /// considered unchecked. The source error becomes a checked success value,
210  /// regardless of its original state.
211  Error &operator=(Error &&Other) {
212    // Don't allow overwriting of unchecked values.
213    assertIsChecked();
214    setPtr(Other.getPtr());
215 
216    // This Error is unchecked, even if the source error was checked.
217    setChecked(false);
218 
219    // Null out Other's payload and set its checked bit.
220    Other.setPtr(nullptr);
221    Other.setChecked(true);
222 
223    return *this;
224  }
225 
226  /// Destroy a Error. Fails with a call to abort() if the error is
227  /// unchecked.
228  ~Error() {
229    assertIsChecked();
230    delete getPtr();
231  }
232 
233  /// Bool conversion. Returns true if this Error is in a failure state,
234  /// and false if it is in an accept state. If the error is in a Success state
235  /// it will be considered checked.
236  explicit operator bool() {
237    setChecked(getPtr() == nullptr);
238    return getPtr() != nullptr;
239  }
240 
241  /// Check whether one error is a subclass of another.
242  template <typename ErrT> bool isA() const {
243    return getPtr() && getPtr()->isA(ErrT::classID());
244  }
245 
246  /// Returns the dynamic class id of this error, or null if this is a success
247  /// value.
248  const void* dynamicClassID() const {
249    if (!getPtr())
250      return nullptr;
251    return getPtr()->dynamicClassID();
252  }
253 
254private:
255#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
256  // assertIsChecked() happens very frequently, but under normal circumstances
257  // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
258  // of debug prints can cause the function to be too large for inlining.  So
259  // it's important that we define this function out of line so that it can't be
260  // inlined.
261  LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
262  void fatalUncheckedError() const;
263#endif
264 
265  void assertIsChecked() {
266#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
267    if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
268      fatalUncheckedError();
269#endif
270  }
271 
272  ErrorInfoBase *getPtr() const {
273    return reinterpret_cast<ErrorInfoBase*>(
274             reinterpret_cast<uintptr_t>(Payload) &
275             ~static_cast<uintptr_t>(0x1));
276  }
277 
278  void setPtr(ErrorInfoBase *EI) {
279#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
280    Payload = reinterpret_cast<ErrorInfoBase*>(
281                (reinterpret_cast<uintptr_t>(EI) &
282                 ~static_cast<uintptr_t>(0x1)) |
283                (reinterpret_cast<uintptr_t>(Payload) & 0x1));
284#else
285    Payload = EI;
286#endif
287  }
288 
289  bool getChecked() const {
290#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
291    return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
292#else
293    return true;
294#endif
295  }
296 
297  void setChecked(bool V) {
298    Payload = reinterpret_cast<ErrorInfoBase*>(
299                (reinterpret_cast<uintptr_t>(Payload) &
300                  ~static_cast<uintptr_t>(0x1)) |
301                  (V ? 0 : 1));
302  }
303 
304  std::unique_ptr<ErrorInfoBase> takePayload() {
305    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
306    setPtr(nullptr);
307    setChecked(true);
308    return Tmp;
309  }
310 
311  friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
312    if (auto P = E.getPtr())
313      P->log(OS);
314    else
315      OS << "success";
316    return OS;
317  }
318 
319  ErrorInfoBase *Payload = nullptr;
320};
321 
322/// Subclass of Error for the sole purpose of identifying the success path in
323/// the type system. This allows to catch invalid conversion to Expected<T> at
324/// compile time.
325class ErrorSuccess final : public Error {};
326 
327inline ErrorSuccess Error::success() { return ErrorSuccess(); }
328 
329/// Make a Error instance representing failure using the given error info
330/// type.
331template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
332  return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
333}
334 
335/// Base class for user error types. Users should declare their error types
336/// like:
337///
338/// class MyError : public ErrorInfo<MyError> {
339///   ....
340/// };
341///
342/// This class provides an implementation of the ErrorInfoBase::kind
343/// method, which is used by the Error RTTI system.
344template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
345class ErrorInfo : public ParentErrT {
346public:
347  using ParentErrT::ParentErrT; // inherit constructors
348 
349  static const void *classID() { return &ThisErrT::ID; }
350 
351  const void *dynamicClassID() const override { return &ThisErrT::ID; }
352 
353  bool isA(const void *const ClassID) const override {
354    return ClassID == classID() || ParentErrT::isA(ClassID);
355  }
356};
357 
358/// Special ErrorInfo subclass representing a list of ErrorInfos.
359/// Instances of this class are constructed by joinError.
360class ErrorList final : public ErrorInfo<ErrorList> {
361  // handleErrors needs to be able to iterate the payload list of an
362  // ErrorList.
363  template <typename... HandlerTs>
364  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
365 
366  // joinErrors is implemented in terms of join.
367  friend Error joinErrors(Error, Error);
368 
369public:
370  void log(raw_ostream &OS) const override {
371    OS << "Multiple errors:\n";
372    for (auto &ErrPayload : Payloads) {
373      ErrPayload->log(OS);
374      OS << "\n";
375    }
376  }
377 
378  std::error_code convertToErrorCode() const override;
379 
380  // Used by ErrorInfo::classID.
381  static char ID;
382 
383private:
384  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
385            std::unique_ptr<ErrorInfoBase> Payload2) {
386    assert(!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() &&((!Payload1->isA<ErrorList>() && !Payload2->
isA<ErrorList>() && "ErrorList constructor payloads should be singleton errors"
) ? static_cast<void> (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 387, __PRETTY_FUNCTION__))
387           "ErrorList constructor payloads should be singleton errors")((!Payload1->isA<ErrorList>() && !Payload2->
isA<ErrorList>() && "ErrorList constructor payloads should be singleton errors"
) ? static_cast<void> (0) : __assert_fail ("!Payload1->isA<ErrorList>() && !Payload2->isA<ErrorList>() && \"ErrorList constructor payloads should be singleton errors\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 387, __PRETTY_FUNCTION__));
388    Payloads.push_back(std::move(Payload1));
389    Payloads.push_back(std::move(Payload2));
390  }
391 
392  static Error join(Error E1, Error E2) {
393    if (!E1)
28
←
Taking false branch→
394      return E2;
395    if (!E2)
29
←
Taking false branch→
396      return E1;
397    if (E1.isA<ErrorList>()) {
30
←
Assuming the condition is false→
31
←
Taking false branch→
398      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
399      if (E2.isA<ErrorList>()) {
400        auto E2Payload = E2.takePayload();
401        auto &E2List = static_cast<ErrorList &>(*E2Payload);
402        for (auto &Payload : E2List.Payloads)
403          E1List.Payloads.push_back(std::move(Payload));
404      } else
405        E1List.Payloads.push_back(E2.takePayload());
406 
407      return E1;
408    }
409    if (E2.isA<ErrorList>()) {
32
←
Assuming the condition is false→
33
←
Taking false branch→
410      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
411      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
412      return E2;
413    }
414    return Error(std::unique_ptr<ErrorList>(
35
←
Calling constructor for 'Error'→
415        new ErrorList(E1.takePayload(), E2.takePayload())));
34
←
Memory is allocated→
416  }
417 
418  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
419};
420 
421/// Concatenate errors. The resulting Error is unchecked, and contains the
422/// ErrorInfo(s), if any, contained in E1, followed by the
423/// ErrorInfo(s), if any, contained in E2.
424inline Error joinErrors(Error E1, Error E2) {
425  return ErrorList::join(std::move(E1), std::move(E2));
426}
427 
428/// Tagged union holding either a T or a Error.
429///
430/// This class parallels ErrorOr, but replaces error_code with Error. Since
431/// Error cannot be copied, this class replaces getError() with
432/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
433/// error class type.
434template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
435  template <class T1> friend class ExpectedAsOutParameter;
436  template <class OtherT> friend class Expected;
437 
438  static const bool isRef = std::is_reference<T>::value;
439 
440  using wrap = std::reference_wrapper<typename std::remove_reference<T>::type>;
441 
442  using error_type = std::unique_ptr<ErrorInfoBase>;
443 
444public:
445  using storage_type = typename std::conditional<isRef, wrap, T>::type;
446  using value_type = T;
447 
448private:
449  using reference = typename std::remove_reference<T>::type &;
450  using const_reference = const typename std::remove_reference<T>::type &;
451  using pointer = typename std::remove_reference<T>::type *;
452  using const_pointer = const typename std::remove_reference<T>::type *;
453 
454public:
455  /// Create an Expected<T> error value from the given Error.
456  Expected(Error Err)
457      : HasError(true)
458#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
459        // Expected is unchecked upon construction in Debug builds.
460        , Unchecked(true)
461#endif
462  {
463    assert(Err && "Cannot create Expected<T> from Error success value.")((Err && "Cannot create Expected<T> from Error success value."
) ? static_cast<void> (0) : __assert_fail ("Err && \"Cannot create Expected<T> from Error success value.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 463, __PRETTY_FUNCTION__));
464    new (getErrorStorage()) error_type(Err.takePayload());
465  }
466 
467  /// Forbid to convert from Error::success() implicitly, this avoids having
468  /// Expected<T> foo() { return Error::success(); } which compiles otherwise
469  /// but triggers the assertion above.
470  Expected(ErrorSuccess) = delete;
471 
472  /// Create an Expected<T> success value from the given OtherT value, which
473  /// must be convertible to T.
474  template <typename OtherT>
475  Expected(OtherT &&Val,
476           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
477               * = nullptr)
478      : HasError(false)
479#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
480        // Expected is unchecked upon construction in Debug builds.
481        , Unchecked(true)
482#endif
483  {
484    new (getStorage()) storage_type(std::forward<OtherT>(Val));
485  }
486 
487  /// Move construct an Expected<T> value.
488  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
489 
490  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
491  /// must be convertible to T.
492  template <class OtherT>
493  Expected(Expected<OtherT> &&Other,
494           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
495               * = nullptr) {
496    moveConstruct(std::move(Other));
497  }
498 
499  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
500  /// isn't convertible to T.
501  template <class OtherT>
502  explicit Expected(
503      Expected<OtherT> &&Other,
504      typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
505          nullptr) {
506    moveConstruct(std::move(Other));
507  }
508 
509  /// Move-assign from another Expected<T>.
510  Expected &operator=(Expected &&Other) {
511    moveAssign(std::move(Other));
512    return *this;
513  }
514 
515  /// Destroy an Expected<T>.
516  ~Expected() {
517    assertIsChecked();
518    if (!HasError)
519      getStorage()->~storage_type();
520    else
521      getErrorStorage()->~error_type();
522  }
523 
524  /// Return false if there is an error.
525  explicit operator bool() {
526#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
527    Unchecked = HasError;
528#endif
529    return !HasError;
530  }
531 
532  /// Returns a reference to the stored T value.
533  reference get() {
534    assertIsChecked();
535    return *getStorage();
536  }
537 
538  /// Returns a const reference to the stored T value.
539  const_reference get() const {
540    assertIsChecked();
541    return const_cast<Expected<T> *>(this)->get();
542  }
543 
544  /// Check that this Expected<T> is an error of type ErrT.
545  template <typename ErrT> bool errorIsA() const {
546    return HasError && (*getErrorStorage())->template isA<ErrT>();
547  }
548 
549  /// Take ownership of the stored error.
550  /// After calling this the Expected<T> is in an indeterminate state that can
551  /// only be safely destructed. No further calls (beside the destructor) should
552  /// be made on the Expected<T> vaule.
553  Error takeError() {
554#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
555    Unchecked = false;
556#endif
557    return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
558  }
559 
560  /// Returns a pointer to the stored T value.
561  pointer operator->() {
562    assertIsChecked();
563    return toPointer(getStorage());
564  }
565 
566  /// Returns a const pointer to the stored T value.
567  const_pointer operator->() const {
568    assertIsChecked();
569    return toPointer(getStorage());
570  }
571 
572  /// Returns a reference to the stored T value.
573  reference operator*() {
574    assertIsChecked();
575    return *getStorage();
576  }
577 
578  /// Returns a const reference to the stored T value.
579  const_reference operator*() const {
580    assertIsChecked();
581    return *getStorage();
582  }
583 
584private:
585  template <class T1>
586  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
587    return &a == &b;
588  }
589 
590  template <class T1, class T2>
591  static bool compareThisIfSameType(const T1 &a, const T2 &b) {
592    return false;
593  }
594 
595  template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
596    HasError = Other.HasError;
597#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
598    Unchecked = true;
599    Other.Unchecked = false;
600#endif
601 
602    if (!HasError)
603      new (getStorage()) storage_type(std::move(*Other.getStorage()));
604    else
605      new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
606  }
607 
608  template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
609    assertIsChecked();
610 
611    if (compareThisIfSameType(*this, Other))
612      return;
613 
614    this->~Expected();
615    new (this) Expected(std::move(Other));
616  }
617 
618  pointer toPointer(pointer Val) { return Val; }
619 
620  const_pointer toPointer(const_pointer Val) const { return Val; }
621 
622  pointer toPointer(wrap *Val) { return &Val->get(); }
623 
624  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
625 
626  storage_type *getStorage() {
627    assert(!HasError && "Cannot get value when an error exists!")((!HasError && "Cannot get value when an error exists!"
) ? static_cast<void> (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 627, __PRETTY_FUNCTION__));
628    return reinterpret_cast<storage_type *>(TStorage.buffer);
629  }
630 
631  const storage_type *getStorage() const {
632    assert(!HasError && "Cannot get value when an error exists!")((!HasError && "Cannot get value when an error exists!"
) ? static_cast<void> (0) : __assert_fail ("!HasError && \"Cannot get value when an error exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 632, __PRETTY_FUNCTION__));
633    return reinterpret_cast<const storage_type *>(TStorage.buffer);
634  }
635 
636  error_type *getErrorStorage() {
637    assert(HasError && "Cannot get error when a value exists!")((HasError && "Cannot get error when a value exists!"
) ? static_cast<void> (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 637, __PRETTY_FUNCTION__));
638    return reinterpret_cast<error_type *>(ErrorStorage.buffer);
639  }
640 
641  const error_type *getErrorStorage() const {
642    assert(HasError && "Cannot get error when a value exists!")((HasError && "Cannot get error when a value exists!"
) ? static_cast<void> (0) : __assert_fail ("HasError && \"Cannot get error when a value exists!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 642, __PRETTY_FUNCTION__));
643    return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
644  }
645 
646  // Used by ExpectedAsOutParameter to reset the checked flag.
647  void setUnchecked() {
648#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
649    Unchecked = true;
650#endif
651  }
652 
653#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
654  LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
655  LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))
656  void fatalUncheckedExpected() const {
657    dbgs() << "Expected<T> must be checked before access or destruction.\n";
658    if (HasError) {
659      dbgs() << "Unchecked Expected<T> contained error:\n";
660      (*getErrorStorage())->log(dbgs());
661    } else
662      dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
663                "values in success mode must still be checked prior to being "
664                "destroyed).\n";
665    abort();
666  }
667#endif
668 
669  void assertIsChecked() {
670#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
671    if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
672      fatalUncheckedExpected();
673#endif
674  }
675 
676  union {
677    AlignedCharArrayUnion<storage_type> TStorage;
678    AlignedCharArrayUnion<error_type> ErrorStorage;
679  };
680  bool HasError : 1;
681#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
682  bool Unchecked : 1;
683#endif
684};
685 
686/// Report a serious error, calling any installed error handler. See
687/// ErrorHandling.h.
688LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void report_fatal_error(Error Err,
689                                                bool gen_crash_diag = true);
690 
691/// Report a fatal error if Err is a failure value.
692///
693/// This function can be used to wrap calls to fallible functions ONLY when it
694/// is known that the Error will always be a success value. E.g.
695///
696///   @code{.cpp}
697///   // foo only attempts the fallible operation if DoFallibleOperation is
698///   // true. If DoFallibleOperation is false then foo always returns
699///   // Error::success().
700///   Error foo(bool DoFallibleOperation);
701///
702///   cantFail(foo(false));
703///   @endcode
704inline void cantFail(Error Err, const char *Msg = nullptr) {
705  if (Err) {
706    if (!Msg)
707      Msg = "Failure value returned from cantFail wrapped call";
708    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 708);
709  }
710}
711 
712/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
713/// returns the contained value.
714///
715/// This function can be used to wrap calls to fallible functions ONLY when it
716/// is known that the Error will always be a success value. E.g.
717///
718///   @code{.cpp}
719///   // foo only attempts the fallible operation if DoFallibleOperation is
720///   // true. If DoFallibleOperation is false then foo always returns an int.
721///   Expected<int> foo(bool DoFallibleOperation);
722///
723///   int X = cantFail(foo(false));
724///   @endcode
725template <typename T>
726T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
727  if (ValOrErr)
728    return std::move(*ValOrErr);
729  else {
730    if (!Msg)
731      Msg = "Failure value returned from cantFail wrapped call";
732    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 732);
733  }
734}
735 
736/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
737/// returns the contained reference.
738///
739/// This function can be used to wrap calls to fallible functions ONLY when it
740/// is known that the Error will always be a success value. E.g.
741///
742///   @code{.cpp}
743///   // foo only attempts the fallible operation if DoFallibleOperation is
744///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
745///   Expected<Bar&> foo(bool DoFallibleOperation);
746///
747///   Bar &X = cantFail(foo(false));
748///   @endcode
749template <typename T>
750T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
751  if (ValOrErr)
752    return *ValOrErr;
753  else {
754    if (!Msg)
755      Msg = "Failure value returned from cantFail wrapped call";
756    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 756);
757  }
758}
759 
760/// Helper for testing applicability of, and applying, handlers for
761/// ErrorInfo types.
762template <typename HandlerT>
763class ErrorHandlerTraits
764    : public ErrorHandlerTraits<decltype(
765          &std::remove_reference<HandlerT>::type::operator())> {};
766 
767// Specialization functions of the form 'Error (const ErrT&)'.
768template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
769public:
770  static bool appliesTo(const ErrorInfoBase &E) {
771    return E.template isA<ErrT>();
772  }
773 
774  template <typename HandlerT>
775  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
776    assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 776, __PRETTY_FUNCTION__));
777    return H(static_cast<ErrT &>(*E));
778  }
779};
780 
781// Specialization functions of the form 'void (const ErrT&)'.
782template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
783public:
784  static bool appliesTo(const ErrorInfoBase &E) {
785    return E.template isA<ErrT>();
786  }
787 
788  template <typename HandlerT>
789  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
790    assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 790, __PRETTY_FUNCTION__));
791    H(static_cast<ErrT &>(*E));
792    return Error::success();
793  }
794};
795 
796/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
797template <typename ErrT>
798class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
799public:
800  static bool appliesTo(const ErrorInfoBase &E) {
801    return E.template isA<ErrT>();
802  }
803 
804  template <typename HandlerT>
805  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
806    assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 806, __PRETTY_FUNCTION__));
807    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
808    return H(std::move(SubE));
809  }
810};
811 
812/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
813template <typename ErrT>
814class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
815public:
816  static bool appliesTo(const ErrorInfoBase &E) {
817    return E.template isA<ErrT>();
818  }
819 
820  template <typename HandlerT>
821  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
822    assert(appliesTo(*E) && "Applying incorrect handler")((appliesTo(*E) && "Applying incorrect handler") ? static_cast
<void> (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 822, __PRETTY_FUNCTION__));
823    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
824    H(std::move(SubE));
825    return Error::success();
826  }
827};
828 
829// Specialization for member functions of the form 'RetT (const ErrT&)'.
830template <typename C, typename RetT, typename ErrT>
831class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
832    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
833 
834// Specialization for member functions of the form 'RetT (const ErrT&) const'.
835template <typename C, typename RetT, typename ErrT>
836class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
837    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
838 
839// Specialization for member functions of the form 'RetT (const ErrT&)'.
840template <typename C, typename RetT, typename ErrT>
841class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
842    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
843 
844// Specialization for member functions of the form 'RetT (const ErrT&) const'.
845template <typename C, typename RetT, typename ErrT>
846class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
847    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
848 
849/// Specialization for member functions of the form
850/// 'RetT (std::unique_ptr<ErrT>)'.
851template <typename C, typename RetT, typename ErrT>
852class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
853    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
854 
855/// Specialization for member functions of the form
856/// 'RetT (std::unique_ptr<ErrT>) const'.
857template <typename C, typename RetT, typename ErrT>
858class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
859    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
860 
861inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
862  return Error(std::move(Payload));
863}
864 
865template <typename HandlerT, typename... HandlerTs>
866Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
867                      HandlerT &&Handler, HandlerTs &&... Handlers) {
868  if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
869    return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
870                                               std::move(Payload));
871  return handleErrorImpl(std::move(Payload),
872                         std::forward<HandlerTs>(Handlers)...);
873}
874 
875/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
876/// unhandled errors (or Errors returned by handlers) are re-concatenated and
877/// returned.
878/// Because this function returns an error, its result must also be checked
879/// or returned. If you intend to handle all errors use handleAllErrors
880/// (which returns void, and will abort() on unhandled errors) instead.
881template <typename... HandlerTs>
882Error handleErrors(Error E, HandlerTs &&... Hs) {
883  if (!E)
24
←
Taking false branch→
884    return Error::success();
885 
886  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
887 
888  if (Payload->isA<ErrorList>()) {
25
←
Assuming the condition is true→
26
←
Taking true branch→
889    ErrorList &List = static_cast<ErrorList &>(*Payload);
890    Error R;
891    for (auto &P : List.Payloads)
892      R = ErrorList::join(
27
←
Calling 'ErrorList::join'→
893          std::move(R),
894          handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
895    return R;
896  }
897 
898  return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
899}
900 
901/// Behaves the same as handleErrors, except that by contract all errors
902/// *must* be handled by the given handlers (i.e. there must be no remaining
903/// errors after running the handlers, or llvm_unreachable is called).
904template <typename... HandlerTs>
905void handleAllErrors(Error E, HandlerTs &&... Handlers) {
906  cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
23
←
Calling 'handleErrors<(lambda at /build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h:979:35)>'→
907}
908 
909/// Check that E is a non-error, then drop it.
910/// If E is an error, llvm_unreachable will be called.
911inline void handleAllErrors(Error E) {
912  cantFail(std::move(E));
913}
914 
915/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
916///
917/// If the incoming value is a success value it is returned unmodified. If it
918/// is a failure value then it the contained error is passed to handleErrors.
919/// If handleErrors is able to handle the error then the RecoveryPath functor
920/// is called to supply the final result. If handleErrors is not able to
921/// handle all errors then the unhandled errors are returned.
922///
923/// This utility enables the follow pattern:
924///
925///   @code{.cpp}
926///   enum FooStrategy { Aggressive, Conservative };
927///   Expected<Foo> foo(FooStrategy S);
928///
929///   auto ResultOrErr =
930///     handleExpected(
931///       foo(Aggressive),
932///       []() { return foo(Conservative); },
933///       [](AggressiveStrategyError&) {
934///         // Implicitly conusme this - we'll recover by using a conservative
935///         // strategy.
936///       });
937///
938///   @endcode
939template <typename T, typename RecoveryFtor, typename... HandlerTs>
940Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
941                           HandlerTs &&... Handlers) {
942  if (ValOrErr)
943    return ValOrErr;
944 
945  if (auto Err = handleErrors(ValOrErr.takeError(),
946                              std::forward<HandlerTs>(Handlers)...))
947    return std::move(Err);
948 
949  return RecoveryPath();
950}
951 
952/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
953/// will be printed before the first one is logged. A newline will be printed
954/// after each error.
955///
956/// This is useful in the base level of your program to allow clean termination
957/// (allowing clean deallocation of resources, etc.), while reporting error
958/// information to the user.
959void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner);
960 
961/// Write all error messages (if any) in E to a string. The newline character
962/// is used to separate error messages.
963inline std::string toString(Error E) {
964  SmallVector<std::string, 2> Errors;
965  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
966    Errors.push_back(EI.message());
967  });
968  return join(Errors.begin(), Errors.end(), "\n");
969}
970 
971/// Consume a Error without doing anything. This method should be used
972/// only where an error can be considered a reasonable and expected return
973/// value.
974///
975/// Uses of this method are potentially indicative of design problems: If it's
976/// legitimate to do nothing while processing an "error", the error-producer
977/// might be more clearly refactored to return an Optional<T>.
978inline void consumeError(Error Err) {
979  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
22
←
Calling 'handleAllErrors<(lambda at /build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h:979:35)>'→
980}
981 
982/// Helper for converting an Error to a bool.
983///
984/// This method returns true if Err is in an error state, or false if it is
985/// in a success state.  Puts Err in a checked state in both cases (unlike
986/// Error::operator bool(), which only does this for success states).
987inline bool errorToBool(Error Err) {
988  bool IsError = static_cast<bool>(Err);
989  if (IsError)
990    consumeError(std::move(Err));
991  return IsError;
992}
993 
994/// Helper for Errors used as out-parameters.
995///
996/// This helper is for use with the Error-as-out-parameter idiom, where an error
997/// is passed to a function or method by reference, rather than being returned.
998/// In such cases it is helpful to set the checked bit on entry to the function
999/// so that the error can be written to (unchecked Errors abort on assignment)
1000/// and clear the checked bit on exit so that clients cannot accidentally forget
1001/// to check the result. This helper performs these actions automatically using
1002/// RAII:
1003///
1004///   @code{.cpp}
1005///   Result foo(Error &Err) {
1006///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1007///     // <body of foo>
1008///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1009///   }
1010///   @endcode
1011///
1012/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1013/// used with optional Errors (Error pointers that are allowed to be null). If
1014/// ErrorAsOutParameter took an Error reference, an instance would have to be
1015/// created inside every condition that verified that Error was non-null. By
1016/// taking an Error pointer we can just create one instance at the top of the
1017/// function.
1018class ErrorAsOutParameter {
1019public:
1020  ErrorAsOutParameter(Error *Err) : Err(Err) {
1021    // Raise the checked bit if Err is success.
1022    if (Err)
1023      (void)!!*Err;
1024  }
1025 
1026  ~ErrorAsOutParameter() {
1027    // Clear the checked bit.
1028    if (Err && !*Err)
1029      *Err = Error::success();
1030  }
1031 
1032private:
1033  Error *Err;
1034};
1035 
1036/// Helper for Expected<T>s used as out-parameters.
1037///
1038/// See ErrorAsOutParameter.
1039template <typename T>
1040class ExpectedAsOutParameter {
1041public:
1042  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1043    : ValOrErr(ValOrErr) {
1044    if (ValOrErr)
1045      (void)!!*ValOrErr;
1046  }
1047 
1048  ~ExpectedAsOutParameter() {
1049    if (ValOrErr)
1050      ValOrErr->setUnchecked();
1051  }
1052 
1053private:
1054  Expected<T> *ValOrErr;
1055};
1056 
1057/// This class wraps a std::error_code in a Error.
1058///
1059/// This is useful if you're writing an interface that returns a Error
1060/// (or Expected) and you want to call code that still returns
1061/// std::error_codes.
1062class ECError : public ErrorInfo<ECError> {
1063  friend Error errorCodeToError(std::error_code);
1064 
1065public:
1066  void setErrorCode(std::error_code EC) { this->EC = EC; }
1067  std::error_code convertToErrorCode() const override { return EC; }
1068  void log(raw_ostream &OS) const override { OS << EC.message(); }
1069 
1070  // Used by ErrorInfo::classID.
1071  static char ID;
1072 
1073protected:
1074  ECError() = default;
1075  ECError(std::error_code EC) : EC(EC) {}
1076 
1077  std::error_code EC;
1078};
1079 
1080/// The value returned by this function can be returned from convertToErrorCode
1081/// for Error values where no sensible translation to std::error_code exists.
1082/// It should only be used in this situation, and should never be used where a
1083/// sensible conversion to std::error_code is available, as attempts to convert
1084/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1085///error to try to convert such a value).
1086std::error_code inconvertibleErrorCode();
1087 
1088/// Helper for converting an std::error_code to a Error.
1089Error errorCodeToError(std::error_code EC);
1090 
1091/// Helper for converting an ECError to a std::error_code.
1092///
1093/// This method requires that Err be Error() or an ECError, otherwise it
1094/// will trigger a call to abort().
1095std::error_code errorToErrorCode(Error Err);
1096 
1097/// Convert an ErrorOr<T> to an Expected<T>.
1098template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1099  if (auto EC = EO.getError())
1100    return errorCodeToError(EC);
1101  return std::move(*EO);
1102}
1103 
1104/// Convert an Expected<T> to an ErrorOr<T>.
1105template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1106  if (auto Err = E.takeError())
1107    return errorToErrorCode(std::move(Err));
1108  return std::move(*E);
1109}
1110 
1111/// This class wraps a string in an Error.
1112///
1113/// StringError is useful in cases where the client is not expected to be able
1114/// to consume the specific error message programmatically (for example, if the
1115/// error message is to be presented to the user).
1116///
1117/// StringError can also be used when additional information is to be printed
1118/// along with a error_code message. Depending on the constructor called, this
1119/// class can either display:
1120///    1. the error_code message (ECError behavior)
1121///    2. a string
1122///    3. the error_code message and a string
1123///
1124/// These behaviors are useful when subtyping is required; for example, when a
1125/// specific library needs an explicit error type. In the example below,
1126/// PDBError is derived from StringError:
1127///
1128///   @code{.cpp}
1129///   Expected<int> foo() {
1130///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1131///                                        "Additional information");
1132///   }
1133///   @endcode
1134///
1135class StringError : public ErrorInfo<StringError> {
1136public:
1137  static char ID;
1138 
1139  // Prints EC + S and converts to EC
1140  StringError(std::error_code EC, const Twine &S = Twine());
1141 
1142  // Prints S and converts to EC
1143  StringError(const Twine &S, std::error_code EC);
1144 
1145  void log(raw_ostream &OS) const override;
1146  std::error_code convertToErrorCode() const override;
1147 
1148  const std::string &getMessage() const { return Msg; }
1149 
1150private:
1151  std::string Msg;
1152  std::error_code EC;
1153  const bool PrintMsgOnly = false;
1154};
1155 
1156/// Create formatted StringError object.
1157template <typename... Ts>
1158Error createStringError(std::error_code EC, char const *Fmt,
1159                        const Ts &... Vals) {
1160  std::string Buffer;
1161  raw_string_ostream Stream(Buffer);
1162  Stream << format(Fmt, Vals...);
1163  return make_error<StringError>(Stream.str(), EC);
1164}
1165 
1166Error createStringError(std::error_code EC, char const *Msg);
1167 
1168/// This class wraps a filename and another Error.
1169///
1170/// In some cases, an error needs to live along a 'source' name, in order to
1171/// show more detailed information to the user.
1172class FileError final : public ErrorInfo<FileError> {
1173 
1174  friend Error createFileError(std::string, Error);
1175 
1176public:
1177  void log(raw_ostream &OS) const override {
1178    assert(Err && !FileName.empty() && "Trying to log after takeError().")((Err && !FileName.empty() && "Trying to log after takeError()."
) ? static_cast<void> (0) : __assert_fail ("Err && !FileName.empty() && \"Trying to log after takeError().\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1178, __PRETTY_FUNCTION__));
1179    OS << "'" << FileName << "': ";
1180    Err->log(OS);
1181  }
1182 
1183  Error takeError() { return Error(std::move(Err)); }
1184 
1185  std::error_code convertToErrorCode() const override;
1186 
1187  // Used by ErrorInfo::classID.
1188  static char ID;
1189 
1190private:
1191  FileError(std::string F, std::unique_ptr<ErrorInfoBase> E) {
1192    assert(E && "Cannot create FileError from Error success value.")((E && "Cannot create FileError from Error success value."
) ? static_cast<void> (0) : __assert_fail ("E && \"Cannot create FileError from Error success value.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1192, __PRETTY_FUNCTION__));
1193    assert(!F.empty() &&((!F.empty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.empty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1194, __PRETTY_FUNCTION__))
1194           "The file name provided to FileError must not be empty.")((!F.empty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.empty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1194, __PRETTY_FUNCTION__));
1195    FileName = F;
1196    Err = std::move(E);
1197  }
1198 
1199  static Error build(std::string F, Error E) {
1200    return Error(std::unique_ptr<FileError>(new FileError(F, E.takePayload())));
1201  }
1202 
1203  std::string FileName;
1204  std::unique_ptr<ErrorInfoBase> Err;
1205};
1206 
1207/// Concatenate a source file path and/or name with an Error. The resulting
1208/// Error is unchecked.
1209inline Error createFileError(std::string F, Error E) {
1210  return FileError::build(F, std::move(E));
1211}
1212 
1213Error createFileError(std::string F, ErrorSuccess) = delete;
1214 
1215/// Helper for check-and-exit error handling.
1216///
1217/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1218///
1219class ExitOnError {
1220public:
1221  /// Create an error on exit helper.
1222  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1223      : Banner(std::move(Banner)),
1224        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1225 
1226  /// Set the banner string for any errors caught by operator().
1227  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1228 
1229  /// Set the exit-code mapper function.
1230  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1231    this->GetExitCode = std::move(GetExitCode);
1232  }
1233 
1234  /// Check Err. If it's in a failure state log the error(s) and exit.
1235  void operator()(Error Err) const { checkError(std::move(Err)); }
1236 
1237  /// Check E. If it's in a success state then return the contained value. If
1238  /// it's in a failure state log the error(s) and exit.
1239  template <typename T> T operator()(Expected<T> &&E) const {
1240    checkError(E.takeError());
1241    return std::move(*E);
1242  }
1243 
1244  /// Check E. If it's in a success state then return the contained reference. If
1245  /// it's in a failure state log the error(s) and exit.
1246  template <typename T> T& operator()(Expected<T&> &&E) const {
1247    checkError(E.takeError());
1248    return *E;
1249  }
1250 
1251private:
1252  void checkError(Error Err) const {
1253    if (Err) {
1254      int ExitCode = GetExitCode(Err);
1255      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1256      exit(ExitCode);
1257    }
1258  }
1259 
1260  std::string Banner;
1261  std::function<int(const Error &)> GetExitCode;
1262};
1263 
1264/// Conversion from Error to LLVMErrorRef for C error bindings.
1265inline LLVMErrorRef wrap(Error Err) {
1266  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1267}
1268 
1269/// Conversion from LLVMErrorRef to Error for C error bindings.
1270inline Error unwrap(LLVMErrorRef ErrRef) {
1271  return Error(std::unique_ptr<ErrorInfoBase>(
1272      reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1273}
1274 
1275} // end namespace llvm
1276 
1277#endif // LLVM_SUPPORT_ERROR_H