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

/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/COFF/Driver.cpp

→

1//===- Driver.cpp ---------------------------------------------------------===//
2//
3//                             The LLVM Linker
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#include "Driver.h"
11#include "Config.h"
12#include "ICF.h"
13#include "InputFiles.h"
14#include "MarkLive.h"
15#include "MinGW.h"
16#include "SymbolTable.h"
17#include "Symbols.h"
18#include "Writer.h"
19#include "lld/Common/Args.h"
20#include "lld/Common/Driver.h"
21#include "lld/Common/ErrorHandler.h"
22#include "lld/Common/Memory.h"
23#include "lld/Common/Timer.h"
24#include "lld/Common/Version.h"
25#include "llvm/ADT/Optional.h"
26#include "llvm/ADT/StringSwitch.h"
27#include "llvm/BinaryFormat/Magic.h"
28#include "llvm/Object/ArchiveWriter.h"
29#include "llvm/Object/COFFImportFile.h"
30#include "llvm/Object/COFFModuleDefinition.h"
31#include "llvm/Option/Arg.h"
32#include "llvm/Option/ArgList.h"
33#include "llvm/Option/Option.h"
34#include "llvm/Support/Debug.h"
35#include "llvm/Support/LEB128.h"
36#include "llvm/Support/Path.h"
37#include "llvm/Support/Process.h"
38#include "llvm/Support/TarWriter.h"
39#include "llvm/Support/TargetSelect.h"
40#include "llvm/Support/raw_ostream.h"
41#include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
42#include <algorithm>
43#include <future>
44#include <memory>

46using namespace llvm;
47using namespace llvm::object;
48using namespace llvm::COFF;
49using llvm::sys::Process;

51namespace lld {
52namespace coff {

54static Timer InputFileTimer("Input File Reading", Timer::root());

56Configuration *Config;
57LinkerDriver *Driver;

59bool link(ArrayRef<const char *> Args, bool CanExitEarly, raw_ostream &Diag) {
errorHandler().LogName = args::getFilenameWithoutExe(Args[0]);
errorHandler().ErrorOS = &Diag;
errorHandler().ColorDiagnostics = Diag.has_colors();
errorHandler().ErrorLimitExceededMsg =
    "too many errors emitted, stopping now"
    " (use /errorlimit:0 to see all errors)";
errorHandler().ExitEarly = CanExitEarly;
Config = make<Configuration>();

Symtab = make<SymbolTable>();

Driver = make<LinkerDriver>();
Driver->link(Args);

// Call exit() if we can to avoid calling destructors.
if (CanExitEarly)
  exitLld(errorCount() ? 1 : 0);

freeArena();
ObjFile::Instances.clear();
ImportFile::Instances.clear();
BitcodeFile::Instances.clear();
return !errorCount();
83}

85// Drop directory components and replace extension with ".exe" or ".dll".
86static std::string getOutputPath(StringRef Path) {
auto P = Path.find_last_of("\\/");
StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1);
const char* E = Config->DLL ? ".dll" : ".exe";
return (S.substr(0, S.rfind('.')) + E).str();
91}

93// ErrorOr is not default constructible, so it cannot be used as the type
94// parameter of a future.
95// FIXME: We could open the file in createFutureForFile and avoid needing to
96// return an error here, but for the moment that would cost us a file descriptor
97// (a limited resource on Windows) for the duration that the future is pending.
98typedef std::pair<std::unique_ptr<MemoryBuffer>, std::error_code> MBErrPair;

100// Create a std::future that opens and maps a file using the best strategy for
101// the host platform.
102static std::future<MBErrPair> createFutureForFile(std::string Path) {
103#if _WIN32
// On Windows, file I/O is relatively slow so it is best to do this
// asynchronously.
auto Strategy = std::launch::async;
107#else
auto Strategy = std::launch::deferred;
109#endif
return std::async(Strategy, [=]() {
  auto MBOrErr = MemoryBuffer::getFile(Path,
                                       /*FileSize*/ -1,
                                       /*RequiresNullTerminator*/ false);
  if (!MBOrErr)
    return MBErrPair{nullptr, MBOrErr.getError()};
  return MBErrPair{std::move(*MBOrErr), std::error_code()};
});
118}

120// Symbol names are mangled by prepending "_" on x86.
121static StringRef mangle(StringRef Sym) {
assert(Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN)((Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN) ? static_cast
<void> (0) : __assert_fail ("Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/COFF/Driver.cpp"
, 122, __PRETTY_FUNCTION__));
if (Config->Machine == I386)
  return Saver.save("_" + Sym);
return Sym;
126}

128static bool findUnderscoreMangle(StringRef Sym) {
StringRef Entry = Symtab->findMangle(mangle(Sym));
return !Entry.empty() && !isa<Undefined>(Symtab->find(Entry));
131}

133MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> MB) {
MemoryBufferRef MBRef = *MB;
make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take ownership

if (Driver->Tar)
  Driver->Tar->append(relativeToRoot(MBRef.getBufferIdentifier()),
                      MBRef.getBuffer());
return MBRef;
141}

143void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> MB,
                           bool WholeArchive) {
StringRef Filename = MB->getBufferIdentifier();

MemoryBufferRef MBRef = takeBuffer(std::move(MB));
FilePaths.push_back(Filename);

// File type is detected by contents, not by file extension.
switch (identify_magic(MBRef.getBuffer())) {
3
←
Control jumps to 'case archive:'  at line 155→
case file_magic::windows_resource:
  Resources.push_back(MBRef);
  break;
case file_magic::archive:
  if (WholeArchive) {
4
←
Assuming 'WholeArchive' is not equal to 0→
5
←
Taking true branch→
    std::unique_ptr<Archive> File =
        CHECK(Archive::create(MBRef), Filename + ": failed to parse archive")check2((Archive::create(MBRef)), [&] { return toString(Filename
 + ": failed to parse archive"); });
6
←
Within the expansion of the macro 'CHECK':
→
a
Calling 'check2<std::unique_ptr<llvm::object::Archive, std::default_delete<llvm::object::Archive> >>'

    for (MemoryBufferRef M : getArchiveMembers(File.get()))
      addArchiveBuffer(M, "<whole-archive>", Filename);
    return;
  }
  Symtab->addFile(make<ArchiveFile>(MBRef));
  break;
case file_magic::bitcode:
  Symtab->addFile(make<BitcodeFile>(MBRef));
  break;
case file_magic::coff_object:
case file_magic::coff_import_library:
  Symtab->addFile(make<ObjFile>(MBRef));
  break;
case file_magic::coff_cl_gl_object:
  error(Filename + ": is not a native COFF file. Recompile without /GL");
  break;
case file_magic::pecoff_executable:
  if (Filename.endswith_lower(".dll")) {
    error(Filename + ": bad file type. Did you specify a DLL instead of an "
                     "import library?");
    break;
  }
  LLVM_FALLTHROUGH[[clang::fallthrough]];
default:
  error(MBRef.getBufferIdentifier() + ": unknown file type");
  break;
}
187}

189void LinkerDriver::enqueuePath(StringRef Path, bool WholeArchive) {
auto Future =
    std::make_shared<std::future<MBErrPair>>(createFutureForFile(Path));
std::string PathStr = Path;
enqueueTask([=]() {
  auto MBOrErr = Future->get();
  if (MBOrErr.second)
1
Taking false branch→
    error("could not open " + PathStr + ": " + MBOrErr.second.message());
  else
    Driver->addBuffer(std::move(MBOrErr.first), WholeArchive);
2
←
Calling 'LinkerDriver::addBuffer'→
});
200}

202void LinkerDriver::addArchiveBuffer(MemoryBufferRef MB, StringRef SymName,
                                  StringRef ParentName) {
file_magic Magic = identify_magic(MB.getBuffer());
if (Magic == file_magic::coff_import_library) {
  Symtab->addFile(make<ImportFile>(MB));
  return;
}

InputFile *Obj;
if (Magic == file_magic::coff_object) {
  Obj = make<ObjFile>(MB);
} else if (Magic == file_magic::bitcode) {
  Obj = make<BitcodeFile>(MB);
} else {
  error("unknown file type: " + MB.getBufferIdentifier());
  return;
}

Obj->ParentName = ParentName;
Symtab->addFile(Obj);
log("Loaded " + toString(Obj) + " for " + SymName);
223}

225void LinkerDriver::enqueueArchiveMember(const Archive::Child &C,
                                      StringRef SymName,
                                      StringRef ParentName) {
if (!C.getParent()->isThin()) {
  MemoryBufferRef MB = CHECK(check2((C.getMemoryBufferRef()), [&] { return toString("could not get the buffer for the member defining symbol "
 + SymName); })
      C.getMemoryBufferRef(),check2((C.getMemoryBufferRef()), [&] { return toString("could not get the buffer for the member defining symbol "
 + SymName); })
      "could not get the buffer for the member defining symbol " + SymName)check2((C.getMemoryBufferRef()), [&] { return toString("could not get the buffer for the member defining symbol "
 + SymName); });
  enqueueTask([=]() { Driver->addArchiveBuffer(MB, SymName, ParentName); });
  return;
}

auto Future = std::make_shared<std::future<MBErrPair>>(createFutureForFile(
    CHECK(C.getFullName(),check2((C.getFullName()), [&] { return toString("could not get the filename for the member defining symbol "
 + SymName); })
          "could not get the filename for the member defining symbol " +check2((C.getFullName()), [&] { return toString("could not get the filename for the member defining symbol "
 + SymName); })
              SymName)check2((C.getFullName()), [&] { return toString("could not get the filename for the member defining symbol "
 + SymName); })));
enqueueTask([=]() {
  auto MBOrErr = Future->get();
  if (MBOrErr.second)
    fatal("could not get the buffer for the member defining " + SymName +
          ": " + MBOrErr.second.message());
  Driver->addArchiveBuffer(takeBuffer(std::move(MBOrErr.first)), SymName,
                           ParentName);
});
248}

250static bool isDecorated(StringRef Sym) {
return Sym.startswith("@") || Sym.contains("@@") || Sym.startswith("?") ||
       (!Config->MinGW && Sym.contains('@'));
253}

255// Parses .drectve section contents and returns a list of files
256// specified by /defaultlib.
257void LinkerDriver::parseDirectives(StringRef S) {
ArgParser Parser;
// .drectve is always tokenized using Windows shell rules.
// /EXPORT: option can appear too many times, processing in fastpath.
opt::InputArgList Args;
std::vector<StringRef> Exports;
std::tie(Args, Exports) = Parser.parseDirectives(S);

for (StringRef E : Exports) {
  // If a common header file contains dllexported function
  // declarations, many object files may end up with having the
  // same /EXPORT options. In order to save cost of parsing them,
  // we dedup them first.
  if (!DirectivesExports.insert(E).second)
    continue;

  Export Exp = parseExport(E);
  if (Config->Machine == I386 && Config->MinGW) {
    if (!isDecorated(Exp.Name))
      Exp.Name = Saver.save("_" + Exp.Name);
    if (!Exp.ExtName.empty() && !isDecorated(Exp.ExtName))
      Exp.ExtName = Saver.save("_" + Exp.ExtName);
  }
  Exp.Directives = true;
  Config->Exports.push_back(Exp);
}

for (auto *Arg : Args) {
  switch (Arg->getOption().getUnaliasedOption().getID()) {
  case OPT_aligncomm:
    parseAligncomm(Arg->getValue());
    break;
  case OPT_alternatename:
    parseAlternateName(Arg->getValue());
    break;
  case OPT_defaultlib:
    if (Optional<StringRef> Path = findLib(Arg->getValue()))
      enqueuePath(*Path, false);
    break;
  case OPT_entry:
    Config->Entry = addUndefined(mangle(Arg->getValue()));
    break;
  case OPT_failifmismatch:
    checkFailIfMismatch(Arg->getValue());
    break;
  case OPT_incl:
    addUndefined(Arg->getValue());
    break;
  case OPT_merge:
    parseMerge(Arg->getValue());
    break;
  case OPT_nodefaultlib:
    Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
    break;
  case OPT_section:
    parseSection(Arg->getValue());
    break;
  case OPT_subsystem:
    parseSubsystem(Arg->getValue(), &Config->Subsystem,
                   &Config->MajorOSVersion, &Config->MinorOSVersion);
    break;
  case OPT_editandcontinue:
  case OPT_fastfail:
  case OPT_guardsym:
  case OPT_natvis:
  case OPT_throwingnew:
    break;
  default:
    error(Arg->getSpelling() + " is not allowed in .drectve");
  }
}
328}

330// Find file from search paths. You can omit ".obj", this function takes
331// care of that. Note that the returned path is not guaranteed to exist.
332StringRef LinkerDriver::doFindFile(StringRef Filename) {
bool HasPathSep = (Filename.find_first_of("/\\") != StringRef::npos);
if (HasPathSep)
  return Filename;
bool HasExt = Filename.contains('.');
for (StringRef Dir : SearchPaths) {
  SmallString<128> Path = Dir;
  sys::path::append(Path, Filename);
  if (sys::fs::exists(Path.str()))
    return Saver.save(Path.str());
  if (!HasExt) {
    Path.append(".obj");
    if (sys::fs::exists(Path.str()))
      return Saver.save(Path.str());
  }
}
return Filename;
349}

351static Optional<sys::fs::UniqueID> getUniqueID(StringRef Path) {
sys::fs::UniqueID Ret;
if (sys::fs::getUniqueID(Path, Ret))
  return None;
return Ret;
356}

358// Resolves a file path. This never returns the same path
359// (in that case, it returns None).
360Optional<StringRef> LinkerDriver::findFile(StringRef Filename) {
StringRef Path = doFindFile(Filename);

if (Optional<sys::fs::UniqueID> ID = getUniqueID(Path)) {
  bool Seen = !VisitedFiles.insert(*ID).second;
  if (Seen)
    return None;
}

if (Path.endswith_lower(".lib"))
  VisitedLibs.insert(sys::path::filename(Path));
return Path;
372}

374// MinGW specific. If an embedded directive specified to link to
375// foo.lib, but it isn't found, try libfoo.a instead.
376StringRef LinkerDriver::doFindLibMinGW(StringRef Filename) {
if (Filename.contains('/') || Filename.contains('\\'))
  return Filename;

SmallString<128> S = Filename;
sys::path::replace_extension(S, ".a");
StringRef LibName = Saver.save("lib" + S.str());
return doFindFile(LibName);
384}

386// Find library file from search path.
387StringRef LinkerDriver::doFindLib(StringRef Filename) {
// Add ".lib" to Filename if that has no file extension.
bool HasExt = Filename.contains('.');
if (!HasExt)
  Filename = Saver.save(Filename + ".lib");
StringRef Ret = doFindFile(Filename);
// For MinGW, if the find above didn't turn up anything, try
// looking for a MinGW formatted library name.
if (Config->MinGW && Ret == Filename)
  return doFindLibMinGW(Filename);
return Ret;
398}

400// Resolves a library path. /nodefaultlib options are taken into
401// consideration. This never returns the same path (in that case,
402// it returns None).
403Optional<StringRef> LinkerDriver::findLib(StringRef Filename) {
if (Config->NoDefaultLibAll)
  return None;
if (!VisitedLibs.insert(Filename.lower()).second)
  return None;

StringRef Path = doFindLib(Filename);
if (Config->NoDefaultLibs.count(Path))
  return None;

if (Optional<sys::fs::UniqueID> ID = getUniqueID(Path))
  if (!VisitedFiles.insert(*ID).second)
    return None;
return Path;
417}

419// Parses LIB environment which contains a list of search paths.
420void LinkerDriver::addLibSearchPaths() {
Optional<std::string> EnvOpt = Process::GetEnv("LIB");
if (!EnvOpt.hasValue())
  return;
StringRef Env = Saver.save(*EnvOpt);
while (!Env.empty()) {
  StringRef Path;
  std::tie(Path, Env) = Env.split(';');
  SearchPaths.push_back(Path);
}
430}

432Symbol *LinkerDriver::addUndefined(StringRef Name) {
Symbol *B = Symtab->addUndefined(Name);
if (!B->IsGCRoot) {
  B->IsGCRoot = true;
  Config->GCRoot.push_back(B);
}
return B;
439}

441// Windows specific -- find default entry point name.
442//
443// There are four different entry point functions for Windows executables,
444// each of which corresponds to a user-defined "main" function. This function
445// infers an entry point from a user-defined "main" function.
446StringRef LinkerDriver::findDefaultEntry() {
assert(Config->Subsystem != IMAGE_SUBSYSTEM_UNKNOWN &&((Config->Subsystem != IMAGE_SUBSYSTEM_UNKNOWN && "must handle /subsystem before calling this"
) ? static_cast<void> (0) : __assert_fail ("Config->Subsystem != IMAGE_SUBSYSTEM_UNKNOWN && \"must handle /subsystem before calling this\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/COFF/Driver.cpp"
, 448, __PRETTY_FUNCTION__))
       "must handle /subsystem before calling this")((Config->Subsystem != IMAGE_SUBSYSTEM_UNKNOWN && "must handle /subsystem before calling this"
) ? static_cast<void> (0) : __assert_fail ("Config->Subsystem != IMAGE_SUBSYSTEM_UNKNOWN && \"must handle /subsystem before calling this\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/COFF/Driver.cpp"
, 448, __PRETTY_FUNCTION__));

if (Config->MinGW)
  return mangle(Config->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI
                    ? "WinMainCRTStartup"
                    : "mainCRTStartup");

if (Config->Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
  if (findUnderscoreMangle("wWinMain")) {
    if (!findUnderscoreMangle("WinMain"))
      return mangle("wWinMainCRTStartup");
    warn("found both wWinMain and WinMain; using latter");
  }
  return mangle("WinMainCRTStartup");
}
if (findUnderscoreMangle("wmain")) {
  if (!findUnderscoreMangle("main"))
    return mangle("wmainCRTStartup");
  warn("found both wmain and main; using latter");
}
return mangle("mainCRTStartup");
469}

471WindowsSubsystem LinkerDriver::inferSubsystem() {
if (Config->DLL)
  return IMAGE_SUBSYSTEM_WINDOWS_GUI;
if (Config->MinGW)
  return IMAGE_SUBSYSTEM_WINDOWS_CUI;
// Note that link.exe infers the subsystem from the presence of these
// functions even if /entry: or /nodefaultlib are passed which causes them
// to not be called.
bool HaveMain = findUnderscoreMangle("main");
bool HaveWMain = findUnderscoreMangle("wmain");
bool HaveWinMain = findUnderscoreMangle("WinMain");
bool HaveWWinMain = findUnderscoreMangle("wWinMain");
if (HaveMain || HaveWMain) {
  if (HaveWinMain || HaveWWinMain) {
    warn(std::string("found ") + (HaveMain ? "main" : "wmain") + " and " +
         (HaveWinMain ? "WinMain" : "wWinMain") +
         "; defaulting to /subsystem:console");
  }
  return IMAGE_SUBSYSTEM_WINDOWS_CUI;
}
if (HaveWinMain || HaveWWinMain)
  return IMAGE_SUBSYSTEM_WINDOWS_GUI;
return IMAGE_SUBSYSTEM_UNKNOWN;
494}

496static uint64_t getDefaultImageBase() {
if (Config->is64())
  return Config->DLL ? 0x180000000 : 0x140000000;
return Config->DLL ? 0x10000000 : 0x400000;
500}

502static std::string createResponseFile(const opt::InputArgList &Args,
                                    ArrayRef<StringRef> FilePaths,
                                    ArrayRef<StringRef> SearchPaths) {
SmallString<0> Data;
raw_svector_ostream OS(Data);

for (auto *Arg : Args) {
  switch (Arg->getOption().getID()) {
  case OPT_linkrepro:
  case OPT_INPUT:
  case OPT_defaultlib:
  case OPT_libpath:
  case OPT_manifest:
  case OPT_manifest_colon:
  case OPT_manifestdependency:
  case OPT_manifestfile:
  case OPT_manifestinput:
  case OPT_manifestuac:
    break;
  default:
    OS << toString(*Arg) << "\n";
  }
}

for (StringRef Path : SearchPaths) {
  std::string RelPath = relativeToRoot(Path);
  OS << "/libpath:" << quote(RelPath) << "\n";
}

for (StringRef Path : FilePaths)
  OS << quote(relativeToRoot(Path)) << "\n";

return Data.str();
535}

537enum class DebugKind { Unknown, None, Full, FastLink, GHash, Dwarf, Symtab };

539static DebugKind parseDebugKind(const opt::InputArgList &Args) {
auto *A = Args.getLastArg(OPT_debug, OPT_debug_opt);
if (!A)
  return DebugKind::None;
if (A->getNumValues() == 0)
  return DebugKind::Full;

DebugKind Debug = StringSwitch<DebugKind>(A->getValue())
                   .CaseLower("none", DebugKind::None)
                   .CaseLower("full", DebugKind::Full)
                   .CaseLower("fastlink", DebugKind::FastLink)
                   // LLD extensions
                   .CaseLower("ghash", DebugKind::GHash)
                   .CaseLower("dwarf", DebugKind::Dwarf)
                   .CaseLower("symtab", DebugKind::Symtab)
                   .Default(DebugKind::Unknown);

if (Debug == DebugKind::FastLink) {
  warn("/debug:fastlink unsupported; using /debug:full");
  return DebugKind::Full;
}
if (Debug == DebugKind::Unknown) {
  error("/debug: unknown option: " + Twine(A->getValue()));
  return DebugKind::None;
}
return Debug;
565}

567static unsigned parseDebugTypes(const opt::InputArgList &Args) {
unsigned DebugTypes = static_cast<unsigned>(DebugType::None);

if (auto *A = Args.getLastArg(OPT_debugtype)) {
  SmallVector<StringRef, 3> Types;
  A->getSpelling().split(Types, ',', /*KeepEmpty=*/false);

  for (StringRef Type : Types) {
    unsigned V = StringSwitch<unsigned>(Type.lower())
                     .Case("cv", static_cast<unsigned>(DebugType::CV))
                     .Case("pdata", static_cast<unsigned>(DebugType::PData))
                     .Case("fixup", static_cast<unsigned>(DebugType::Fixup))
                     .Default(0);
    if (V == 0) {
      warn("/debugtype: unknown option: " + Twine(A->getValue()));
      continue;
    }
    DebugTypes |= V;
  }
  return DebugTypes;
}

// Default debug types
DebugTypes = static_cast<unsigned>(DebugType::CV);
if (Args.hasArg(OPT_driver))
  DebugTypes |= static_cast<unsigned>(DebugType::PData);
if (Args.hasArg(OPT_profile))
  DebugTypes |= static_cast<unsigned>(DebugType::Fixup);

return DebugTypes;
597}

599static std::string getMapFile(const opt::InputArgList &Args) {
auto *Arg = Args.getLastArg(OPT_lldmap, OPT_lldmap_file);
if (!Arg)
  return "";
if (Arg->getOption().getID() == OPT_lldmap_file)
  return Arg->getValue();

assert(Arg->getOption().getID() == OPT_lldmap)((Arg->getOption().getID() == OPT_lldmap) ? static_cast<
void> (0) : __assert_fail ("Arg->getOption().getID() == OPT_lldmap"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/COFF/Driver.cpp"
, 606, __PRETTY_FUNCTION__));
StringRef OutFile = Config->OutputFile;
return (OutFile.substr(0, OutFile.rfind('.')) + ".map").str();
609}

611static std::string getImplibPath() {
if (!Config->Implib.empty())
  return Config->Implib;
SmallString<128> Out = StringRef(Config->OutputFile);
sys::path::replace_extension(Out, ".lib");
return Out.str();
617}

619//
620// The import name is caculated as the following:
621//
622//        | LIBRARY w/ ext |   LIBRARY w/o ext   | no LIBRARY
623//   -----+----------------+---------------------+------------------
624//   LINK | {value}        | {value}.{.dll/.exe} | {output name}
625//    LIB | {value}        | {value}.dll         | {output name}.dll
626//
627static std::string getImportName(bool AsLib) {
SmallString<128> Out;

if (Config->ImportName.empty()) {
  Out.assign(sys::path::filename(Config->OutputFile));
  if (AsLib)
    sys::path::replace_extension(Out, ".dll");
} else {
  Out.assign(Config->ImportName);
  if (!sys::path::has_extension(Out))
    sys::path::replace_extension(Out,
                                 (Config->DLL || AsLib) ? ".dll" : ".exe");
}

return Out.str();
642}

644static void createImportLibrary(bool AsLib) {
std::vector<COFFShortExport> Exports;
for (Export &E1 : Config->Exports) {
  COFFShortExport E2;
  E2.Name = E1.Name;
  E2.SymbolName = E1.SymbolName;
  E2.ExtName = E1.ExtName;
  E2.Ordinal = E1.Ordinal;
  E2.Noname = E1.Noname;
  E2.Data = E1.Data;
  E2.Private = E1.Private;
  E2.Constant = E1.Constant;
  Exports.push_back(E2);
}

auto HandleError = [](Error &&E) {
  handleAllErrors(std::move(E),
                  [](ErrorInfoBase &EIB) { error(EIB.message()); });
};
std::string LibName = getImportName(AsLib);
std::string Path = getImplibPath();

if (!Config->Incremental) {
  HandleError(writeImportLibrary(LibName, Path, Exports, Config->Machine,
                                 Config->MinGW));
  return;
}

// If the import library already exists, replace it only if the contents
// have changed.
ErrorOr<std::unique_ptr<MemoryBuffer>> OldBuf = MemoryBuffer::getFile(
    Path, /*FileSize*/ -1, /*RequiresNullTerminator*/ false);
if (!OldBuf) {
  HandleError(writeImportLibrary(LibName, Path, Exports, Config->Machine,
                                 Config->MinGW));
  return;
}

SmallString<128> TmpName;
if (std::error_code EC =
        sys::fs::createUniqueFile(Path + ".tmp-%%%%%%%%.lib", TmpName))
  fatal("cannot create temporary file for import library " + Path + ": " +
        EC.message());

if (Error E = writeImportLibrary(LibName, TmpName, Exports, Config->Machine,
                                 Config->MinGW)) {
  HandleError(std::move(E));
  return;
}

std::unique_ptr<MemoryBuffer> NewBuf = check(MemoryBuffer::getFile(
    TmpName, /*FileSize*/ -1, /*RequiresNullTerminator*/ false));
if ((*OldBuf)->getBuffer() != NewBuf->getBuffer()) {
  OldBuf->reset();
  HandleError(errorCodeToError(sys::fs::rename(TmpName, Path)));
} else {
  sys::fs::remove(TmpName);
}
702}

704static void parseModuleDefs(StringRef Path) {
std::unique_ptr<MemoryBuffer> MB = CHECK(check2((MemoryBuffer::getFile(Path, -1, false, true)), [&
] { return toString("could not open " + Path); })
    MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path)check2((MemoryBuffer::getFile(Path, -1, false, true)), [&
] { return toString("could not open " + Path); });
COFFModuleDefinition M = check(parseCOFFModuleDefinition(
    MB->getMemBufferRef(), Config->Machine, Config->MinGW));

if (Config->OutputFile.empty())
  Config->OutputFile = Saver.save(M.OutputFile);
Config->ImportName = Saver.save(M.ImportName);
if (M.ImageBase)
  Config->ImageBase = M.ImageBase;
if (M.StackReserve)
  Config->StackReserve = M.StackReserve;
if (M.StackCommit)
  Config->StackCommit = M.StackCommit;
if (M.HeapReserve)
  Config->HeapReserve = M.HeapReserve;
if (M.HeapCommit)
  Config->HeapCommit = M.HeapCommit;
if (M.MajorImageVersion)
  Config->MajorImageVersion = M.MajorImageVersion;
if (M.MinorImageVersion)
  Config->MinorImageVersion = M.MinorImageVersion;
if (M.MajorOSVersion)
  Config->MajorOSVersion = M.MajorOSVersion;
if (M.MinorOSVersion)
  Config->MinorOSVersion = M.MinorOSVersion;

for (COFFShortExport E1 : M.Exports) {
  Export E2;
  // In simple cases, only Name is set. Renamed exports are parsed
  // and set as "ExtName = Name". If Name has the form "OtherDll.Func",
  // it shouldn't be a normal exported function but a forward to another
  // DLL instead. This is supported by both MS and GNU linkers.
  if (E1.ExtName != E1.Name && StringRef(E1.Name).contains('.')) {
    E2.Name = Saver.save(E1.ExtName);
    E2.ForwardTo = Saver.save(E1.Name);
    Config->Exports.push_back(E2);
    continue;
  }
  E2.Name = Saver.save(E1.Name);
  E2.ExtName = Saver.save(E1.ExtName);
  E2.Ordinal = E1.Ordinal;
  E2.Noname = E1.Noname;
  E2.Data = E1.Data;
  E2.Private = E1.Private;
  E2.Constant = E1.Constant;
  Config->Exports.push_back(E2);
}
753}

755void LinkerDriver::enqueueTask(std::function<void()> Task) {
TaskQueue.push_back(std::move(Task));
757}

759bool LinkerDriver::run() {
ScopedTimer T(InputFileTimer);

bool DidWork = !TaskQueue.empty();
while (!TaskQueue.empty()) {
  TaskQueue.front()();
  TaskQueue.pop_front();
}
return DidWork;
768}

770// Parse an /order file. If an option is given, the linker places
771// COMDAT sections in the same order as their names appear in the
772// given file.
773static void parseOrderFile(StringRef Arg) {
// For some reason, the MSVC linker requires a filename to be
// preceded by "@".
if (!Arg.startswith("@")) {
  error("malformed /order option: '@' missing");
  return;
}

// Get a list of all comdat sections for error checking.
DenseSet<StringRef> Set;
for (Chunk *C : Symtab->getChunks())
  if (auto *Sec = dyn_cast<SectionChunk>(C))
    if (Sec->Sym)
      Set.insert(Sec->Sym->getName());

// Open a file.
StringRef Path = Arg.substr(1);
std::unique_ptr<MemoryBuffer> MB = CHECK(check2((MemoryBuffer::getFile(Path, -1, false, true)), [&
] { return toString("could not open " + Path); })
    MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path)check2((MemoryBuffer::getFile(Path, -1, false, true)), [&
] { return toString("could not open " + Path); });

// Parse a file. An order file contains one symbol per line.
// All symbols that were not present in a given order file are
// considered to have the lowest priority 0 and are placed at
// end of an output section.
for (std::string S : args::getLines(MB->getMemBufferRef())) {
  if (Config->Machine == I386 && !isDecorated(S))
    S = "_" + S;

  if (Set.count(S) == 0) {
    if (Config->WarnMissingOrderSymbol)
      warn("/order:" + Arg + ": missing symbol: " + S + " [LNK4037]");
  }
  else
    Config->Order[S] = INT_MIN(-2147483647 -1) + Config->Order.size();
}
808}

810static void markAddrsig(Symbol *S) {
if (auto *D = dyn_cast_or_null<Defined>(S))
  if (Chunk *C = D->getChunk())
    C->KeepUnique = true;
814}

816static void findKeepUniqueSections() {
// Exported symbols could be address-significant in other executables or DSOs,
// so we conservatively mark them as address-significant.
for (Export &R : Config->Exports)
  markAddrsig(R.Sym);

// Visit the address-significance table in each object file and mark each
// referenced symbol as address-significant.
for (ObjFile *Obj : ObjFile::Instances) {
  ArrayRef<Symbol *> Syms = Obj->getSymbols();
  if (Obj->AddrsigSec) {
    ArrayRef<uint8_t> Contents;
    Obj->getCOFFObj()->getSectionContents(Obj->AddrsigSec, Contents);
    const uint8_t *Cur = Contents.begin();
    while (Cur != Contents.end()) {
      unsigned Size;
      const char *Err;
      uint64_t SymIndex = decodeULEB128(Cur, &Size, Contents.end(), &Err);
      if (Err)
        fatal(toString(Obj) + ": could not decode addrsig section: " + Err);
      if (SymIndex >= Syms.size())
        fatal(toString(Obj) + ": invalid symbol index in addrsig section");
      markAddrsig(Syms[SymIndex]);
      Cur += Size;
    }
  } else {
    // If an object file does not have an address-significance table,
    // conservatively mark all of its symbols as address-significant.
    for (Symbol *S : Syms)
      markAddrsig(S);
  }
}
848}

850// link.exe replaces each %foo% in AltPath with the contents of environment
851// variable foo, and adds the two magic env vars _PDB (expands to the basename
852// of pdb's output path) and _EXT (expands to the extension of the output
853// binary).
854// lld only supports %_PDB% and %_EXT% and warns on references to all other env
855// vars.
856static void parsePDBAltPath(StringRef AltPath) {
SmallString<128> Buf;
StringRef PDBBasename =
    sys::path::filename(Config->PDBPath, sys::path::Style::windows);
StringRef BinaryExtension =
    sys::path::extension(Config->OutputFile, sys::path::Style::windows);
if (!BinaryExtension.empty())
  BinaryExtension = BinaryExtension.substr(1); // %_EXT% does not include '.'.

// Invariant:
//   +--------- Cursor ('a...' might be the empty string).
//   |   +----- FirstMark
//   |   |   +- SecondMark
//   v   v   v
//   a...%...%...
size_t Cursor = 0;
while (Cursor < AltPath.size()) {
  size_t FirstMark, SecondMark;
  if ((FirstMark = AltPath.find('%', Cursor)) == StringRef::npos ||
      (SecondMark = AltPath.find('%', FirstMark + 1)) == StringRef::npos) {
    // Didn't find another full fragment, treat rest of string as literal.
    Buf.append(AltPath.substr(Cursor));
    break;
  }

  // Found a full fragment. Append text in front of first %, and interpret
  // text between first and second % as variable name.
  Buf.append(AltPath.substr(Cursor, FirstMark - Cursor));
  StringRef Var = AltPath.substr(FirstMark, SecondMark - FirstMark + 1);
  if (Var.equals_lower("%_pdb%"))
    Buf.append(PDBBasename);
  else if (Var.equals_lower("%_ext%"))
    Buf.append(BinaryExtension);
  else {
    warn("only %_PDB% and %_EXT% supported in /pdbaltpath:, keeping " +
         Var + " as literal");
    Buf.append(Var);
  }

  Cursor = SecondMark + 1;
}

Config->PDBAltPath = Buf;
899}

901void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
// If the first command line argument is "/lib", link.exe acts like lib.exe.
// We call our own implementation of lib.exe that understands bitcode files.
if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) {
  if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
    fatal("lib failed");
  return;
}

// Needed for LTO.
InitializeAllTargetInfos();
InitializeAllTargets();
InitializeAllTargetMCs();
InitializeAllAsmParsers();
InitializeAllAsmPrinters();

// Parse command line options.
ArgParser Parser;
opt::InputArgList Args = Parser.parseLINK(ArgsArr);

// Parse and evaluate -mllvm options.
std::vector<const char *> V;
V.push_back("lld-link (LLVM option parsing)");
for (auto *Arg : Args.filtered(OPT_mllvm))
  V.push_back(Arg->getValue());
cl::ParseCommandLineOptions(V.size(), V.data());

// Handle /errorlimit early, because error() depends on it.
if (auto *Arg = Args.getLastArg(OPT_errorlimit)) {
  int N = 20;
  StringRef S = Arg->getValue();
  if (S.getAsInteger(10, N))
    error(Arg->getSpelling() + " number expected, but got " + S);
  errorHandler().ErrorLimit = N;
}

// Handle /help
if (Args.hasArg(OPT_help)) {
  printHelp(ArgsArr[0]);
  return;
}

if (Args.hasArg(OPT_show_timing))
  Config->ShowTiming = true;

ScopedTimer T(Timer::root());
// Handle --version, which is an lld extension. This option is a bit odd
// because it doesn't start with "/", but we deliberately chose "--" to
// avoid conflict with /version and for compatibility with clang-cl.
if (Args.hasArg(OPT_dash_dash_version)) {
  outs() << getLLDVersion() << "\n";
  return;
}

// Handle /lldmingw early, since it can potentially affect how other
// options are handled.
Config->MinGW = Args.hasArg(OPT_lldmingw);

if (auto *Arg = Args.getLastArg(OPT_linkrepro)) {
  SmallString<64> Path = StringRef(Arg->getValue());
  sys::path::append(Path, "repro.tar");

  Expected<std::unique_ptr<TarWriter>> ErrOrWriter =
      TarWriter::create(Path, "repro");

  if (ErrOrWriter) {
    Tar = std::move(*ErrOrWriter);
  } else {
    error("/linkrepro: failed to open " + Path + ": " +
          toString(ErrOrWriter.takeError()));
  }
}

if (!Args.hasArg(OPT_INPUT)) {
  if (Args.hasArg(OPT_deffile))
    Config->NoEntry = true;
  else
    fatal("no input files");
}

// Construct search path list.
SearchPaths.push_back("");
for (auto *Arg : Args.filtered(OPT_libpath))
  SearchPaths.push_back(Arg->getValue());
addLibSearchPaths();

// Handle /ignore
for (auto *Arg : Args.filtered(OPT_ignore)) {
  if (StringRef(Arg->getValue()) == "4037")
    Config->WarnMissingOrderSymbol = false;
  else if (StringRef(Arg->getValue()) == "4217")
    Config->WarnLocallyDefinedImported = false;
  // Other warning numbers are ignored.
}

// Handle /out
if (auto *Arg = Args.getLastArg(OPT_out))
  Config->OutputFile = Arg->getValue();

// Handle /verbose
if (Args.hasArg(OPT_verbose))
  Config->Verbose = true;
errorHandler().Verbose = Config->Verbose;

// Handle /force or /force:unresolved
if (Args.hasArg(OPT_force, OPT_force_unresolved))
  Config->ForceUnresolved = true;

// Handle /force or /force:multiple
if (Args.hasArg(OPT_force, OPT_force_multiple))
  Config->ForceMultiple = true;

// Handle /debug
DebugKind Debug = parseDebugKind(Args);
if (Debug == DebugKind::Full || Debug == DebugKind::Dwarf ||
    Debug == DebugKind::GHash) {
  Config->Debug = true;
  Config->Incremental = true;
}

// Handle /debugtype
Config->DebugTypes = parseDebugTypes(Args);

// Handle /pdb
bool ShouldCreatePDB =
    (Debug == DebugKind::Full || Debug == DebugKind::GHash);
if (ShouldCreatePDB) {
  if (auto *Arg = Args.getLastArg(OPT_pdb))
    Config->PDBPath = Arg->getValue();
  if (auto *Arg = Args.getLastArg(OPT_pdbaltpath))
    Config->PDBAltPath = Arg->getValue();
  if (Args.hasArg(OPT_natvis))
    Config->NatvisFiles = Args.getAllArgValues(OPT_natvis);

  if (auto *Arg = Args.getLastArg(OPT_pdb_source_path))
    Config->PDBSourcePath = Arg->getValue();
}

// Handle /noentry
if (Args.hasArg(OPT_noentry)) {
  if (Args.hasArg(OPT_dll))
    Config->NoEntry = true;
  else
    error("/noentry must be specified with /dll");
}

// Handle /dll
if (Args.hasArg(OPT_dll)) {
  Config->DLL = true;
  Config->ManifestID = 2;
}

// Handle /dynamicbase and /fixed. We can't use hasFlag for /dynamicbase
// because we need to explicitly check whether that option or its inverse was
// present in the argument list in order to handle /fixed.
auto *DynamicBaseArg = Args.getLastArg(OPT_dynamicbase, OPT_dynamicbase_no);
if (DynamicBaseArg &&
    DynamicBaseArg->getOption().getID() == OPT_dynamicbase_no)
  Config->DynamicBase = false;

// MSDN claims "/FIXED:NO is the default setting for a DLL, and /FIXED is the
// default setting for any other project type.", but link.exe defaults to
// /FIXED:NO for exe outputs as well. Match behavior, not docs.
bool Fixed = Args.hasFlag(OPT_fixed, OPT_fixed_no, false);
if (Fixed) {
  if (DynamicBaseArg &&
      DynamicBaseArg->getOption().getID() == OPT_dynamicbase) {
    error("/fixed must not be specified with /dynamicbase");
  } else {
    Config->Relocatable = false;
    Config->DynamicBase = false;
  }
}

// Handle /appcontainer
Config->AppContainer =
    Args.hasFlag(OPT_appcontainer, OPT_appcontainer_no, false);

// Handle /machine
if (auto *Arg = Args.getLastArg(OPT_machine))
  Config->Machine = getMachineType(Arg->getValue());

// Handle /nodefaultlib:<filename>
for (auto *Arg : Args.filtered(OPT_nodefaultlib))
  Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));

// Handle /nodefaultlib
if (Args.hasArg(OPT_nodefaultlib_all))
  Config->NoDefaultLibAll = true;

// Handle /base
if (auto *Arg = Args.getLastArg(OPT_base))
  parseNumbers(Arg->getValue(), &Config->ImageBase);

// Handle /stack
if (auto *Arg = Args.getLastArg(OPT_stack))
  parseNumbers(Arg->getValue(), &Config->StackReserve, &Config->StackCommit);

// Handle /guard:cf
if (auto *Arg = Args.getLastArg(OPT_guard))
  parseGuard(Arg->getValue());

// Handle /heap
if (auto *Arg = Args.getLastArg(OPT_heap))
  parseNumbers(Arg->getValue(), &Config->HeapReserve, &Config->HeapCommit);

// Handle /version
if (auto *Arg = Args.getLastArg(OPT_version))
  parseVersion(Arg->getValue(), &Config->MajorImageVersion,
               &Config->MinorImageVersion);

// Handle /subsystem
if (auto *Arg = Args.getLastArg(OPT_subsystem))
  parseSubsystem(Arg->getValue(), &Config->Subsystem, &Config->MajorOSVersion,
                 &Config->MinorOSVersion);

// Handle /timestamp
if (llvm::opt::Arg *Arg = Args.getLastArg(OPT_timestamp, OPT_repro)) {
  if (Arg->getOption().getID() == OPT_repro) {
    Config->Timestamp = 0;
    Config->Repro = true;
  } else {
    Config->Repro = false;
    StringRef Value(Arg->getValue());
    if (Value.getAsInteger(0, Config->Timestamp))
      fatal(Twine("invalid timestamp: ") + Value +
            ".  Expected 32-bit integer");
  }
} else {
  Config->Repro = false;
  Config->Timestamp = time(nullptr);
}

// Handle /alternatename
for (auto *Arg : Args.filtered(OPT_alternatename))
  parseAlternateName(Arg->getValue());

// Handle /include
for (auto *Arg : Args.filtered(OPT_incl))
  addUndefined(Arg->getValue());

// Handle /implib
if (auto *Arg = Args.getLastArg(OPT_implib))
  Config->Implib = Arg->getValue();

// Handle /opt.
bool DoGC = Debug == DebugKind::None || Args.hasArg(OPT_profile);
unsigned ICFLevel =
    Args.hasArg(OPT_profile) ? 0 : 1; // 0: off, 1: limited, 2: on
unsigned TailMerge = 1;
for (auto *Arg : Args.filtered(OPT_opt)) {
  std::string Str = StringRef(Arg->getValue()).lower();
  SmallVector<StringRef, 1> Vec;
  StringRef(Str).split(Vec, ',');
  for (StringRef S : Vec) {
    if (S == "ref") {
      DoGC = true;
    } else if (S == "noref") {
      DoGC = false;
    } else if (S == "icf" || S.startswith("icf=")) {
      ICFLevel = 2;
    } else if (S == "noicf") {
      ICFLevel = 0;
    } else if (S == "lldtailmerge") {
      TailMerge = 2;
    } else if (S == "nolldtailmerge") {
      TailMerge = 0;
    } else if (S.startswith("lldlto=")) {
      StringRef OptLevel = S.substr(7);
      if (OptLevel.getAsInteger(10, Config->LTOO) || Config->LTOO > 3)
        error("/opt:lldlto: invalid optimization level: " + OptLevel);
    } else if (S.startswith("lldltojobs=")) {
      StringRef Jobs = S.substr(11);
      if (Jobs.getAsInteger(10, Config->ThinLTOJobs) ||
          Config->ThinLTOJobs == 0)
        error("/opt:lldltojobs: invalid job count: " + Jobs);
    } else if (S.startswith("lldltopartitions=")) {
      StringRef N = S.substr(17);
      if (N.getAsInteger(10, Config->LTOPartitions) ||
          Config->LTOPartitions == 0)
        error("/opt:lldltopartitions: invalid partition count: " + N);
    } else if (S != "lbr" && S != "nolbr")
      error("/opt: unknown option: " + S);
  }
}

// Limited ICF is enabled if GC is enabled and ICF was never mentioned
// explicitly.
// FIXME: LLD only implements "limited" ICF, i.e. it only merges identical
// code. If the user passes /OPT:ICF explicitly, LLD should merge identical
// comdat readonly data.
if (ICFLevel == 1 && !DoGC)
  ICFLevel = 0;
Config->DoGC = DoGC;
Config->DoICF = ICFLevel > 0;
Config->TailMerge = (TailMerge == 1 && Config->DoICF) || TailMerge == 2;

// Handle /lldsavetemps
if (Args.hasArg(OPT_lldsavetemps))
  Config->SaveTemps = true;

// Handle /kill-at
if (Args.hasArg(OPT_kill_at))
  Config->KillAt = true;

// Handle /lldltocache
if (auto *Arg = Args.getLastArg(OPT_lldltocache))
  Config->LTOCache = Arg->getValue();

// Handle /lldsavecachepolicy
if (auto *Arg = Args.getLastArg(OPT_lldltocachepolicy))
  Config->LTOCachePolicy = CHECK(check2((parseCachePruningPolicy(Arg->getValue())), [&]
 { return toString(Twine("/lldltocachepolicy: invalid cache policy: "
) + Arg->getValue()); })
      parseCachePruningPolicy(Arg->getValue()),check2((parseCachePruningPolicy(Arg->getValue())), [&]
 { return toString(Twine("/lldltocachepolicy: invalid cache policy: "
) + Arg->getValue()); })
      Twine("/lldltocachepolicy: invalid cache policy: ") + Arg->getValue())check2((parseCachePruningPolicy(Arg->getValue())), [&]
 { return toString(Twine("/lldltocachepolicy: invalid cache policy: "
) + Arg->getValue()); });

// Handle /failifmismatch
for (auto *Arg : Args.filtered(OPT_failifmismatch))
  checkFailIfMismatch(Arg->getValue());

// Handle /merge
for (auto *Arg : Args.filtered(OPT_merge))
  parseMerge(Arg->getValue());

// Add default section merging rules after user rules. User rules take
// precedence, but we will emit a warning if there is a conflict.
parseMerge(".idata=.rdata");
parseMerge(".didat=.rdata");
parseMerge(".edata=.rdata");
parseMerge(".xdata=.rdata");
parseMerge(".bss=.data");

if (Config->MinGW) {
  parseMerge(".ctors=.rdata");
  parseMerge(".dtors=.rdata");
  parseMerge(".CRT=.rdata");
}

// Handle /section
for (auto *Arg : Args.filtered(OPT_section))
  parseSection(Arg->getValue());

// Handle /aligncomm
for (auto *Arg : Args.filtered(OPT_aligncomm))
  parseAligncomm(Arg->getValue());

// Handle /manifestdependency. This enables /manifest unless /manifest:no is
// also passed.
if (auto *Arg = Args.getLastArg(OPT_manifestdependency)) {
  Config->ManifestDependency = Arg->getValue();
  Config->Manifest = Configuration::SideBySide;
}

// Handle /manifest and /manifest:
if (auto *Arg = Args.getLastArg(OPT_manifest, OPT_manifest_colon)) {
  if (Arg->getOption().getID() == OPT_manifest)
    Config->Manifest = Configuration::SideBySide;
  else
    parseManifest(Arg->getValue());
}

// Handle /manifestuac
if (auto *Arg = Args.getLastArg(OPT_manifestuac))
  parseManifestUAC(Arg->getValue());

// Handle /manifestfile
if (auto *Arg = Args.getLastArg(OPT_manifestfile))
  Config->ManifestFile = Arg->getValue();

// Handle /manifestinput
for (auto *Arg : Args.filtered(OPT_manifestinput))
  Config->ManifestInput.push_back(Arg->getValue());

if (!Config->ManifestInput.empty() &&
    Config->Manifest != Configuration::Embed) {
  fatal("/manifestinput: requires /manifest:embed");
}

// Handle miscellaneous boolean flags.
Config->AllowBind = Args.hasFlag(OPT_allowbind, OPT_allowbind_no, true);
Config->AllowIsolation =
    Args.hasFlag(OPT_allowisolation, OPT_allowisolation_no, true);
Config->Incremental =
    Args.hasFlag(OPT_incremental, OPT_incremental_no,
                 !Config->DoGC && !Config->DoICF && !Args.hasArg(OPT_order) &&
                     !Args.hasArg(OPT_profile));
Config->IntegrityCheck =
    Args.hasFlag(OPT_integritycheck, OPT_integritycheck_no, false);
Config->NxCompat = Args.hasFlag(OPT_nxcompat, OPT_nxcompat_no, true);
Config->TerminalServerAware =
    !Config->DLL && Args.hasFlag(OPT_tsaware, OPT_tsaware_no, true);
Config->DebugDwarf = Debug == DebugKind::Dwarf;
Config->DebugGHashes = Debug == DebugKind::GHash;
Config->DebugSymtab = Debug == DebugKind::Symtab;

Config->MapFile = getMapFile(Args);

if (Config->Incremental && Args.hasArg(OPT_profile)) {
  warn("ignoring '/incremental' due to '/profile' specification");
  Config->Incremental = false;
}

if (Config->Incremental && Args.hasArg(OPT_order)) {
  warn("ignoring '/incremental' due to '/order' specification");
  Config->Incremental = false;
}

if (Config->Incremental && Config->DoGC) {
  warn("ignoring '/incremental' because REF is enabled; use '/opt:noref' to "
       "disable");
  Config->Incremental = false;
}

if (Config->Incremental && Config->DoICF) {
  warn("ignoring '/incremental' because ICF is enabled; use '/opt:noicf' to "
       "disable");
  Config->Incremental = false;
}

if (errorCount())
  return;

std::set<sys::fs::UniqueID> WholeArchives;
AutoExporter Exporter;
for (auto *Arg : Args.filtered(OPT_wholearchive_file)) {
  if (Optional<StringRef> Path = doFindFile(Arg->getValue())) {
    if (Optional<sys::fs::UniqueID> ID = getUniqueID(*Path))
      WholeArchives.insert(*ID);
    Exporter.addWholeArchive(*Path);
  }
}

// A predicate returning true if a given path is an argument for
// /wholearchive:, or /wholearchive is enabled globally.
// This function is a bit tricky because "foo.obj /wholearchive:././foo.obj"
// needs to be handled as "/wholearchive:foo.obj foo.obj".
auto IsWholeArchive = [&](StringRef Path) -> bool {
  if (Args.hasArg(OPT_wholearchive_flag))
    return true;
  if (Optional<sys::fs::UniqueID> ID = getUniqueID(Path))
    return WholeArchives.count(*ID);
  return false;
};

// Create a list of input files. Files can be given as arguments
// for /defaultlib option.
for (auto *Arg : Args.filtered(OPT_INPUT, OPT_wholearchive_file))
  if (Optional<StringRef> Path = findFile(Arg->getValue()))
    enqueuePath(*Path, IsWholeArchive(*Path));

for (auto *Arg : Args.filtered(OPT_defaultlib))
  if (Optional<StringRef> Path = findLib(Arg->getValue()))
    enqueuePath(*Path, false);

// Windows specific -- Create a resource file containing a manifest file.
if (Config->Manifest == Configuration::Embed)
  addBuffer(createManifestRes(), false);

// Read all input files given via the command line.
run();

if (errorCount())
  return;

// We should have inferred a machine type by now from the input files, but if
// not we assume x64.
if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
  warn("/machine is not specified. x64 is assumed");
  Config->Machine = AMD64;
}
Config->Wordsize = Config->is64() ? 8 : 4;

// Input files can be Windows resource files (.res files). We use
// WindowsResource to convert resource files to a regular COFF file,
// then link the resulting file normally.
if (!Resources.empty())
  Symtab->addFile(make<ObjFile>(convertResToCOFF(Resources)));

if (Tar)
  Tar->append("response.txt",
              createResponseFile(Args, FilePaths,
                                 ArrayRef<StringRef>(SearchPaths).slice(1)));

// Handle /largeaddressaware
Config->LargeAddressAware = Args.hasFlag(
    OPT_largeaddressaware, OPT_largeaddressaware_no, Config->is64());

// Handle /highentropyva
Config->HighEntropyVA =
    Config->is64() &&
    Args.hasFlag(OPT_highentropyva, OPT_highentropyva_no, true);

if (!Config->DynamicBase &&
    (Config->Machine == ARMNT || Config->Machine == ARM64))
  error("/dynamicbase:no is not compatible with " +
        machineToStr(Config->Machine));

// Handle /export
for (auto *Arg : Args.filtered(OPT_export)) {
  Export E = parseExport(Arg->getValue());
  if (Config->Machine == I386) {
    if (!isDecorated(E.Name))
      E.Name = Saver.save("_" + E.Name);
    if (!E.ExtName.empty() && !isDecorated(E.ExtName))
      E.ExtName = Saver.save("_" + E.ExtName);
  }
  Config->Exports.push_back(E);
}

// Handle /def
if (auto *Arg = Args.getLastArg(OPT_deffile)) {
  // parseModuleDefs mutates Config object.
  parseModuleDefs(Arg->getValue());
}

// Handle generation of import library from a def file.
if (!Args.hasArg(OPT_INPUT)) {
  fixupExports();
  createImportLibrary(/*AsLib=*/true);
  return;
}

// Windows specific -- if no /subsystem is given, we need to infer
// that from entry point name.  Must happen before /entry handling,
// and after the early return when just writing an import library.
if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
  Config->Subsystem = inferSubsystem();
  if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
    fatal("subsystem must be defined");
}

// Handle /entry and /dll
if (auto *Arg = Args.getLastArg(OPT_entry)) {
  Config->Entry = addUndefined(mangle(Arg->getValue()));
} else if (!Config->Entry && !Config->NoEntry) {
  if (Args.hasArg(OPT_dll)) {
    StringRef S = (Config->Machine == I386) ? "__DllMainCRTStartup@12"
                                            : "_DllMainCRTStartup";
    Config->Entry = addUndefined(S);
  } else {
    // Windows specific -- If entry point name is not given, we need to
    // infer that from user-defined entry name.
    StringRef S = findDefaultEntry();
    if (S.empty())
      fatal("entry point must be defined");
    Config->Entry = addUndefined(S);
    log("Entry name inferred: " + S);
  }
}

// Handle /delayload
for (auto *Arg : Args.filtered(OPT_delayload)) {
  Config->DelayLoads.insert(StringRef(Arg->getValue()).lower());
  if (Config->Machine == I386) {
    Config->DelayLoadHelper = addUndefined("___delayLoadHelper2@8");
  } else {
    Config->DelayLoadHelper = addUndefined("__delayLoadHelper2");
  }
}

// Set default image name if neither /out or /def set it.
if (Config->OutputFile.empty()) {
  Config->OutputFile =
      getOutputPath((*Args.filtered(OPT_INPUT).begin())->getValue());
}

if (ShouldCreatePDB) {
  // Put the PDB next to the image if no /pdb flag was passed.
  if (Config->PDBPath.empty()) {
    Config->PDBPath = Config->OutputFile;
    sys::path::replace_extension(Config->PDBPath, ".pdb");
  }

  // The embedded PDB path should be the absolute path to the PDB if no
  // /pdbaltpath flag was passed.
  if (Config->PDBAltPath.empty()) {
    Config->PDBAltPath = Config->PDBPath;

    // It's important to make the path absolute and remove dots.  This path
    // will eventually be written into the PE header, and certain Microsoft
    // tools won't work correctly if these assumptions are not held.
    sys::fs::make_absolute(Config->PDBAltPath);
    sys::path::remove_dots(Config->PDBAltPath);
  } else {
    // Don't do this earlier, so that Config->OutputFile is ready.
    parsePDBAltPath(Config->PDBAltPath);
  }
}

// Set default image base if /base is not given.
if (Config->ImageBase == uint64_t(-1))
  Config->ImageBase = getDefaultImageBase();

Symtab->addSynthetic(mangle("__ImageBase"), nullptr);
if (Config->Machine == I386) {
  Symtab->addAbsolute("___safe_se_handler_table", 0);
  Symtab->addAbsolute("___safe_se_handler_count", 0);
}

Symtab->addAbsolute(mangle("__guard_fids_count"), 0);
Symtab->addAbsolute(mangle("__guard_fids_table"), 0);
Symtab->addAbsolute(mangle("__guard_flags"), 0);
Symtab->addAbsolute(mangle("__guard_iat_count"), 0);
Symtab->addAbsolute(mangle("__guard_iat_table"), 0);
Symtab->addAbsolute(mangle("__guard_longjmp_count"), 0);
Symtab->addAbsolute(mangle("__guard_longjmp_table"), 0);
// Needed for MSVC 2017 15.5 CRT.
Symtab->addAbsolute(mangle("__enclave_config"), 0);

if (Config->MinGW) {
  Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST__"), 0);
  Symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST_END__"), 0);
  Symtab->addAbsolute(mangle("__CTOR_LIST__"), 0);
  Symtab->addAbsolute(mangle("__DTOR_LIST__"), 0);
}

// This code may add new undefined symbols to the link, which may enqueue more
// symbol resolution tasks, so we need to continue executing tasks until we
// converge.
do {
  // Windows specific -- if entry point is not found,
  // search for its mangled names.
  if (Config->Entry)
    Symtab->mangleMaybe(Config->Entry);

  // Windows specific -- Make sure we resolve all dllexported symbols.
  for (Export &E : Config->Exports) {
    if (!E.ForwardTo.empty())
      continue;
    E.Sym = addUndefined(E.Name);
    if (!E.Directives)
      Symtab->mangleMaybe(E.Sym);
  }

  // Add weak aliases. Weak aliases is a mechanism to give remaining
  // undefined symbols final chance to be resolved successfully.
  for (auto Pair : Config->AlternateNames) {
    StringRef From = Pair.first;
    StringRef To = Pair.second;
    Symbol *Sym = Symtab->find(From);
    if (!Sym)
      continue;
    if (auto *U = dyn_cast<Undefined>(Sym))
      if (!U->WeakAlias)
        U->WeakAlias = Symtab->addUndefined(To);
  }

  // Windows specific -- if __load_config_used can be resolved, resolve it.
  if (Symtab->findUnderscore("_load_config_used"))
    addUndefined(mangle("_load_config_used"));
} while (run());

if (errorCount())
  return;

// Do LTO by compiling bitcode input files to a set of native COFF files then
// link those files.
Symtab->addCombinedLTOObjects();
run();

if (Config->MinGW) {
  // Load any further object files that might be needed for doing automatic
  // imports.
  //
  // For cases with no automatically imported symbols, this iterates once
  // over the symbol table and doesn't do anything.
  //
  // For the normal case with a few automatically imported symbols, this
  // should only need to be run once, since each new object file imported
  // is an import library and wouldn't add any new undefined references,
  // but there's nothing stopping the __imp_ symbols from coming from a
  // normal object file as well (although that won't be used for the
  // actual autoimport later on). If this pass adds new undefined references,
  // we won't iterate further to resolve them.
  Symtab->loadMinGWAutomaticImports();
  run();
}

// Make sure we have resolved all symbols.
Symtab->reportRemainingUndefines();
if (errorCount())
  return;

// Handle /safeseh.
if (Args.hasFlag(OPT_safeseh, OPT_safeseh_no, false)) {
  for (ObjFile *File : ObjFile::Instances)
    if (!File->hasSafeSEH())
      error("/safeseh: " + File->getName() + " is not compatible with SEH");
  if (errorCount())
    return;
}

// In MinGW, all symbols are automatically exported if no symbols
// are chosen to be exported.
if (Config->DLL && ((Config->MinGW && Config->Exports.empty()) ||
                    Args.hasArg(OPT_export_all_symbols))) {
  Exporter.initSymbolExcludes();

  Symtab->forEachSymbol([=](Symbol *S) {
    auto *Def = dyn_cast<Defined>(S);
    if (!Exporter.shouldExport(Def))
      return;
    Export E;
    E.Name = Def->getName();
    E.Sym = Def;
    if (Def->getChunk() &&
        !(Def->getChunk()->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
      E.Data = true;
    Config->Exports.push_back(E);
  });
}

// Windows specific -- when we are creating a .dll file, we also
// need to create a .lib file.
if (!Config->Exports.empty() || Config->DLL) {
  fixupExports();
  createImportLibrary(/*AsLib=*/false);
  assignExportOrdinals();
}

// Handle /output-def (MinGW specific).
if (auto *Arg = Args.getLastArg(OPT_output_def))
  writeDefFile(Arg->getValue());

// Set extra alignment for .comm symbols
for (auto Pair : Config->AlignComm) {
  StringRef Name = Pair.first;
  uint32_t Alignment = Pair.second;

  Symbol *Sym = Symtab->find(Name);
  if (!Sym) {
    warn("/aligncomm symbol " + Name + " not found");
    continue;
  }

  // If the symbol isn't common, it must have been replaced with a regular
  // symbol, which will carry its own alignment.
  auto *DC = dyn_cast<DefinedCommon>(Sym);
  if (!DC)
    continue;

  CommonChunk *C = DC->getChunk();
  C->Alignment = std::max(C->Alignment, Alignment);
}

// Windows specific -- Create a side-by-side manifest file.
if (Config->Manifest == Configuration::SideBySide)
  createSideBySideManifest();

// Handle /order. We want to do this at this moment because we
// need a complete list of comdat sections to warn on nonexistent
// functions.
if (auto *Arg = Args.getLastArg(OPT_order))
  parseOrderFile(Arg->getValue());

// Identify unreferenced COMDAT sections.
if (Config->DoGC)
  markLive(Symtab->getChunks());

// Identify identical COMDAT sections to merge them.
if (Config->DoICF) {
  findKeepUniqueSections();
  doICF(Symtab->getChunks());
}

// Write the result.
writeResult();

// Stop early so we can print the results.
Timer::root().stop();
if (Config->ShowTiming)
  Timer::root().print();
1672}

1674} // namespace coff
1675} // namespace lld

←

/build/llvm-toolchain-snapshot-8~svn345461/tools/lld/include/lld/Common/ErrorHandler.h

→

1//===- ErrorHandler.h -------------------------------------------*- C++ -*-===//
2//
3//                             The LLVM Linker
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// We designed lld's error handlers with the following goals in mind:
11//
12//  - Errors can occur at any place where we handle user input, but we don't
13//    want them to affect the normal execution path too much. Ideally,
14//    handling errors should be as simple as reporting them and exit (but
15//    without actually doing exit).
16//
17//    In particular, the design to wrap all functions that could fail with
18//    ErrorOr<T> is rejected because otherwise we would have to wrap a large
19//    number of functions in lld with ErrorOr. With that approach, if some
20//    function F can fail, not only F but all functions that transitively call
21//    F have to be wrapped with ErrorOr. That seemed too much.
22//
23//  - Finding only one error at a time is not sufficient. We want to find as
24//    many errors as possible with one execution of the linker. That means the
25//    linker needs to keep running after a first error and give up at some
26//    checkpoint (beyond which it would find cascading, false errors caused by
27//    the previous errors).
28//
29//  - We want a simple interface to report errors. Unlike Clang, the data we
30//    handle is compiled binary, so we don't need an error reporting mechanism
31//    that's as sophisticated as the one that Clang has.
32//
33// The current lld's error handling mechanism is simple:
34//
35//  - When you find an error, report it using error() and continue as far as
36//    you can. An internal error counter is incremented by one every time you
37//    call error().
38//
39//    A common idiom to handle an error is calling error() and then returning
40//    a reasonable default value. For example, if your function handles a
41//    user-supplied alignment value, and if you find an invalid alignment
42//    (e.g. 17 which is not 2^n), you may report it using error() and continue
43//    as if it were alignment 1 (which is the simplest reasonable value).
44//
45//    Note that you should not continue with an invalid value; that breaks the
46//    internal consistency. You need to maintain all variables have some sane
47//    value even after an error occurred. So, when you have to continue with
48//    some value, always use a dummy value.
49//
50//  - Find a reasonable checkpoint at where you want to stop the linker, and
51//    add code to return from the function if errorCount() > 0. In most cases,
52//    a checkpoint already exists, so you don't need to do anything for this.
53//
54// This interface satisfies all the goals that we mentioned above.
55//
56// You should never call fatal() except for reporting a corrupted input file.
57// fatal() immediately terminates the linker, so the function is not desirable
58// if you are using lld as a subroutine in other program, and with that you
59// can find only one error at a time.
60//
61// warn() doesn't do anything but printing out a given message.
62//
63// It is not recommended to use llvm::outs() or llvm::errs() directly in lld
64// because they are not thread-safe. The functions declared in this file are
65// thread-safe.
66//
67//===----------------------------------------------------------------------===//
68 
69#ifndef LLD_COMMON_ERRORHANDLER_H
70#define LLD_COMMON_ERRORHANDLER_H
71 
72#include "lld/Common/LLVM.h"
73 
74#include "llvm/ADT/STLExtras.h"
75#include "llvm/Support/Error.h"
76#include "llvm/Support/FileOutputBuffer.h"
77 
78namespace llvm {
79class DiagnosticInfo;
80}
81 
82namespace lld {
83 
84class ErrorHandler {
85public:
86  uint64_t ErrorCount = 0;
87  uint64_t ErrorLimit = 20;
88  StringRef ErrorLimitExceededMsg = "too many errors emitted, stopping now";
89  StringRef LogName = "lld";
90  llvm::raw_ostream *ErrorOS = &llvm::errs();
91  bool ColorDiagnostics = llvm::errs().has_colors();
92  bool ExitEarly = true;
93  bool FatalWarnings = false;
94  bool Verbose = false;
95 
96  void error(const Twine &Msg);
97  LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void fatal(const Twine &Msg);
98  void log(const Twine &Msg);
99  void message(const Twine &Msg);
100  void warn(const Twine &Msg);
101 
102  std::unique_ptr<llvm::FileOutputBuffer> OutputBuffer;
103 
104private:
105  void print(StringRef S, raw_ostream::Colors C);
106};
107 
108/// Returns the default error handler.
109ErrorHandler &errorHandler();
110 
111inline void error(const Twine &Msg) { errorHandler().error(Msg); }
112inline LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void fatal(const Twine &Msg) {
113  errorHandler().fatal(Msg);
114}
115inline void log(const Twine &Msg) { errorHandler().log(Msg); }
116inline void message(const Twine &Msg) { errorHandler().message(Msg); }
117inline void warn(const Twine &Msg) { errorHandler().warn(Msg); }
118inline uint64_t errorCount() { return errorHandler().ErrorCount; }
119 
120LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void exitLld(int Val);
121 
122void diagnosticHandler(const llvm::DiagnosticInfo &DI);
123void checkError(Error E);
124 
125// check functions are convenient functions to strip errors
126// from error-or-value objects.
127template <class T> T check(ErrorOr<T> E) {
128  if (auto EC = E.getError())
129    fatal(EC.message());
130  return std::move(*E);
131}
132 
133template <class T> T check(Expected<T> E) {
134  if (!E)
135    fatal(llvm::toString(E.takeError()));
136  return std::move(*E);
137}
138 
139template <class T>
140T check2(ErrorOr<T> E, llvm::function_ref<std::string()> Prefix) {
141  if (auto EC = E.getError())
142    fatal(Prefix() + ": " + EC.message());
143  return std::move(*E);
144}
145 
146template <class T>
147T check2(Expected<T> E, llvm::function_ref<std::string()> Prefix) {
148  if (!E)
7
←
Taking true branch→
149    fatal(Prefix() + ": " + toString(E.takeError()));
8
←
Calling 'toString'→
150  return std::move(*E);
151}
152 
153inline std::string toString(const Twine &S) { return S.str(); }
154 
155// To evaluate the second argument lazily, we use C macro.
156#define CHECK(E, S)check2((E), [&] { return toString(S); }) check2((E), [&] { return toString(S); })
157 
158} // namespace lld
159 
160#endif

←

/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);
23
←
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)
15
←
Taking false branch→
394      return E2;
395    if (!E2)
16
←
Taking false branch→
396      return E1;
397    if (E1.isA<ErrorList>()) {
17
←
Assuming the condition is false→
18
←
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>()) {
19
←
Assuming the condition is false→
20
←
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>(
22
←
Calling constructor for 'Error'→
415        new ErrorList(E1.takePayload(), E2.takePayload())));
21
←
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)
11
←
Taking false branch→
884    return Error::success();
885 
886  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
887 
888  if (Payload->isA<ErrorList>()) {
12
←
Assuming the condition is true→
13
←
Taking true branch→
889    ErrorList &List = static_cast<ErrorList &>(*Payload);
890    Error R;
891    for (auto &P : List.Payloads)
892      R = ErrorList::join(
14
←
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)...));
10
←
Calling 'handleErrors<(lambda at /build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h:965:33)>'→
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) {
9
←
Calling 'handleAllErrors<(lambda at /build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h:965:33)>'→
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 &) {});
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