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

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

→

1//===- CrashDebugger.cpp - Debug compilation crashes ----------------------===//
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 the bugpoint internals that narrow down compilation crashes
11//
12//===----------------------------------------------------------------------===//

14#include "BugDriver.h"
15#include "ListReducer.h"
16#include "ToolRunner.h"
17#include "llvm/ADT/SmallPtrSet.h"
18#include "llvm/ADT/StringSet.h"
19#include "llvm/Analysis/TargetTransformInfo.h"
20#include "llvm/Transforms/Utils/Local.h"
21#include "llvm/IR/CFG.h"
22#include "llvm/IR/Constants.h"
23#include "llvm/IR/DebugInfo.h"
24#include "llvm/IR/DerivedTypes.h"
25#include "llvm/IR/Instructions.h"
26#include "llvm/IR/LegacyPassManager.h"
27#include "llvm/IR/Module.h"
28#include "llvm/IR/ValueSymbolTable.h"
29#include "llvm/IR/Verifier.h"
30#include "llvm/Pass.h"
31#include "llvm/Support/CommandLine.h"
32#include "llvm/Support/FileUtilities.h"
33#include "llvm/Transforms/Scalar.h"
34#include "llvm/Transforms/Utils/BasicBlockUtils.h"
35#include "llvm/Transforms/Utils/Cloning.h"
36#include <set>
37using namespace llvm;

39namespace {
40cl::opt<bool> KeepMain("keep-main",
                     cl::desc("Force function reduction to keep main"),
                     cl::init(false));
43cl::opt<bool> NoGlobalRM("disable-global-remove",
                       cl::desc("Do not remove global variables"),
                       cl::init(false));

47cl::opt<bool> ReplaceFuncsWithNull(
  "replace-funcs-with-null",
  cl::desc("When stubbing functions, replace all uses will null"),
  cl::init(false));
51cl::opt<bool> DontReducePassList("disable-pass-list-reduction",
                               cl::desc("Skip pass list reduction steps"),
                               cl::init(false));

55cl::opt<bool> NoNamedMDRM("disable-namedmd-remove",
                        cl::desc("Do not remove global named metadata"),
                        cl::init(false));
58cl::opt<bool> NoStripDebugInfo("disable-strip-debuginfo",
                             cl::desc("Do not strip debug info metadata"),
                             cl::init(false));
61cl::opt<bool> NoStripDebugTypeInfo("disable-strip-debug-types",
                             cl::desc("Do not strip debug type info metadata"),
                             cl::init(false));
64cl::opt<bool> VerboseErrors("verbose-errors",
                          cl::desc("Print the output of crashing program"),
                          cl::init(false));
67}

69namespace llvm {
70class ReducePassList : public ListReducer<std::string> {
BugDriver &BD;

73public:
ReducePassList(BugDriver &bd) : BD(bd) {}

// Return true iff running the "removed" passes succeeds, and running the
// "Kept" passes fail when run on the output of the "removed" passes.  If we
// return true, we update the current module of bugpoint.
Expected<TestResult> doTest(std::vector<std::string> &Removed,
                            std::vector<std::string> &Kept) override;
81};
82}

84Expected<ReducePassList::TestResult>
85ReducePassList::doTest(std::vector<std::string> &Prefix,
                     std::vector<std::string> &Suffix) {
std::string PrefixOutput;
std::unique_ptr<Module> OrigProgram;
if (!Prefix.empty()) {
  outs() << "Checking to see if these passes crash: "
         << getPassesString(Prefix) << ": ";
  if (BD.runPasses(BD.getProgram(), Prefix, PrefixOutput))
    return KeepPrefix;

  OrigProgram = std::move(BD.Program);

  BD.Program = parseInputFile(PrefixOutput, BD.getContext());
  if (BD.Program == nullptr) {
    errs() << BD.getToolName() << ": Error reading bitcode file '"
           << PrefixOutput << "'!\n";
    exit(1);
  }
  sys::fs::remove(PrefixOutput);
}

outs() << "Checking to see if these passes crash: " << getPassesString(Suffix)
       << ": ";

if (BD.runPasses(BD.getProgram(), Suffix))
  return KeepSuffix; // The suffix crashes alone...

// Nothing failed, restore state...
if (OrigProgram)
  BD.Program = std::move(OrigProgram);
return NoFailure;
116}

118using BugTester = bool (*)(const BugDriver &, Module *);

120namespace {
121/// ReduceCrashingGlobalInitializers - This works by removing global variable
122/// initializers and seeing if the program still crashes. If it does, then we
123/// keep that program and try again.
124class ReduceCrashingGlobalInitializers : public ListReducer<GlobalVariable *> {
BugDriver &BD;
BugTester TestFn;

128public:
ReduceCrashingGlobalInitializers(BugDriver &bd, BugTester testFn)
    : BD(bd), TestFn(testFn) {}

Expected<TestResult> doTest(std::vector<GlobalVariable *> &Prefix,
                            std::vector<GlobalVariable *> &Kept) override {
  if (!Kept.empty() && TestGlobalVariables(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestGlobalVariables(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestGlobalVariables(std::vector<GlobalVariable *> &GVs);
142};
143}

145bool ReduceCrashingGlobalInitializers::TestGlobalVariables(
  std::vector<GlobalVariable *> &GVs) {
// Clone the program to try hacking it apart...
ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

// Convert list to set for fast lookup...
std::set<GlobalVariable *> GVSet;

for (unsigned i = 0, e = GVs.size(); i != e; ++i) {
  GlobalVariable *CMGV = cast<GlobalVariable>(VMap[GVs[i]]);
  assert(CMGV && "Global Variable not in module?!")((CMGV && "Global Variable not in module?!") ? static_cast
<void> (0) : __assert_fail ("CMGV && \"Global Variable not in module?!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/bugpoint/CrashDebugger.cpp"
, 156, __PRETTY_FUNCTION__));
  GVSet.insert(CMGV);
}

outs() << "Checking for crash with only these global variables: ";
PrintGlobalVariableList(GVs);
outs() << ": ";

// Loop over and delete any global variables which we aren't supposed to be
// playing with...
for (GlobalVariable &I : M->globals())
  if (I.hasInitializer() && !GVSet.count(&I)) {
    DeleteGlobalInitializer(&I);
    I.setLinkage(GlobalValue::ExternalLinkage);
    I.setComdat(nullptr);
  }

// Try running the hacked up program...
if (TestFn(BD, M.get())) {
  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...

  // Make sure to use global variable pointers that point into the now-current
  // module.
  GVs.assign(GVSet.begin(), GVSet.end());
  return true;
}

return false;
184}

186namespace {
187/// ReduceCrashingFunctions reducer - This works by removing functions and
188/// seeing if the program still crashes. If it does, then keep the newer,
189/// smaller program.
190///
191class ReduceCrashingFunctions : public ListReducer<Function *> {
BugDriver &BD;
BugTester TestFn;

195public:
ReduceCrashingFunctions(BugDriver &bd, BugTester testFn)
    : BD(bd), TestFn(testFn) {}

Expected<TestResult> doTest(std::vector<Function *> &Prefix,
                            std::vector<Function *> &Kept) override {
  if (!Kept.empty() && TestFuncs(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestFuncs(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestFuncs(std::vector<Function *> &Prefix);
209};
210}

212static void RemoveFunctionReferences(Module *M, const char *Name) {
auto *UsedVar = M->getGlobalVariable(Name, true);
if (!UsedVar || !UsedVar->hasInitializer())
  return;
if (isa<ConstantAggregateZero>(UsedVar->getInitializer())) {
  assert(UsedVar->use_empty())((UsedVar->use_empty()) ? static_cast<void> (0) : __assert_fail
 ("UsedVar->use_empty()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/bugpoint/CrashDebugger.cpp"
, 217, __PRETTY_FUNCTION__));
  UsedVar->eraseFromParent();
  return;
}
auto *OldUsedVal = cast<ConstantArray>(UsedVar->getInitializer());
std::vector<Constant *> Used;
for (Value *V : OldUsedVal->operand_values()) {
  Constant *Op = cast<Constant>(V->stripPointerCasts());
  if (!Op->isNullValue()) {
    Used.push_back(cast<Constant>(V));
  }
}
auto *NewValElemTy = OldUsedVal->getType()->getElementType();
auto *NewValTy = ArrayType::get(NewValElemTy, Used.size());
auto *NewUsedVal = ConstantArray::get(NewValTy, Used);
UsedVar->mutateType(NewUsedVal->getType()->getPointerTo());
UsedVar->setInitializer(NewUsedVal);
234}

236bool ReduceCrashingFunctions::TestFuncs(std::vector<Function *> &Funcs) {
// If main isn't present, claim there is no problem.
if (KeepMain && !is_contained(Funcs, BD.getProgram().getFunction("main")))
  return false;

// Clone the program to try hacking it apart...
ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

// Convert list to set for fast lookup...
std::set<Function *> Functions;
for (unsigned i = 0, e = Funcs.size(); i != e; ++i) {
  Function *CMF = cast<Function>(VMap[Funcs[i]]);
  assert(CMF && "Function not in module?!")((CMF && "Function not in module?!") ? static_cast<
void> (0) : __assert_fail ("CMF && \"Function not in module?!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/bugpoint/CrashDebugger.cpp"
, 249, __PRETTY_FUNCTION__));
  assert(CMF->getFunctionType() == Funcs[i]->getFunctionType() && "wrong ty")((CMF->getFunctionType() == Funcs[i]->getFunctionType()
 && "wrong ty") ? static_cast<void> (0) : __assert_fail
 ("CMF->getFunctionType() == Funcs[i]->getFunctionType() && \"wrong ty\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/bugpoint/CrashDebugger.cpp"
, 250, __PRETTY_FUNCTION__));
  assert(CMF->getName() == Funcs[i]->getName() && "wrong name")((CMF->getName() == Funcs[i]->getName() && "wrong name"
) ? static_cast<void> (0) : __assert_fail ("CMF->getName() == Funcs[i]->getName() && \"wrong name\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/bugpoint/CrashDebugger.cpp"
, 251, __PRETTY_FUNCTION__));
  Functions.insert(CMF);
}

outs() << "Checking for crash with only these functions: ";
PrintFunctionList(Funcs);
outs() << ": ";
if (!ReplaceFuncsWithNull) {
  // Loop over and delete any functions which we aren't supposed to be playing
  // with...
  for (Function &I : *M)
    if (!I.isDeclaration() && !Functions.count(&I))
      DeleteFunctionBody(&I);
} else {
  std::vector<GlobalValue *> ToRemove;
  // First, remove aliases to functions we're about to purge.
  for (GlobalAlias &Alias : M->aliases()) {
    GlobalObject *Root = Alias.getBaseObject();
    Function *F = dyn_cast_or_null<Function>(Root);
    if (F) {
      if (Functions.count(F))
        // We're keeping this function.
        continue;
    } else if (Root->isNullValue()) {
      // This referenced a globalalias that we've already replaced,
      // so we still need to replace this alias.
    } else if (!F) {
      // Not a function, therefore not something we mess with.
      continue;
    }

    PointerType *Ty = cast<PointerType>(Alias.getType());
    Constant *Replacement = ConstantPointerNull::get(Ty);
    Alias.replaceAllUsesWith(Replacement);
    ToRemove.push_back(&Alias);
  }

  for (Function &I : *M) {
    if (!I.isDeclaration() && !Functions.count(&I)) {
      PointerType *Ty = cast<PointerType>(I.getType());
      Constant *Replacement = ConstantPointerNull::get(Ty);
      I.replaceAllUsesWith(Replacement);
      ToRemove.push_back(&I);
    }
  }

  for (auto *F : ToRemove) {
    F->eraseFromParent();
  }

  // Finally, remove any null members from any global intrinsic.
  RemoveFunctionReferences(M.get(), "llvm.used");
  RemoveFunctionReferences(M.get(), "llvm.compiler.used");
}
// Try running the hacked up program...
if (TestFn(BD, M.get())) {
  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...

  // Make sure to use function pointers that point into the now-current
  // module.
  Funcs.assign(Functions.begin(), Functions.end());
  return true;
}
return false;
315}

317namespace {
318/// Simplify the CFG without completely destroying it.
319/// This is not well defined, but basically comes down to "try to eliminate
320/// unreachable blocks and constant fold terminators without deciding that
321/// certain undefined behavior cuts off the program at the legs".
322void simpleSimplifyCfg(Function &F, SmallVectorImpl<BasicBlock *> &BBs) {
if (F.empty())
  return;

for (auto *BB : BBs) {
  ConstantFoldTerminator(BB);
  MergeBlockIntoPredecessor(BB);
}

// Remove unreachable blocks
// removeUnreachableBlocks can't be used here, it will turn various
// undefined behavior into unreachables, but bugpoint was the thing that
// generated the undefined behavior, and we don't want it to kill the entire
// program.
SmallPtrSet<BasicBlock *, 16> Visited;
for (auto *BB : depth_first(&F.getEntryBlock()))
  Visited.insert(BB);

SmallVector<BasicBlock *, 16> Unreachable;
for (auto &BB : F)
  if (!Visited.count(&BB))
    Unreachable.push_back(&BB);

// The dead BB's may be in a dead cycle or otherwise have references to each
// other.  Because of this, we have to drop all references first, then delete
// them all at once.
for (auto *BB : Unreachable) {
  for (BasicBlock *Successor : successors(&*BB))
    if (Visited.count(Successor))
      Successor->removePredecessor(&*BB);
  BB->dropAllReferences();
}
for (auto *BB : Unreachable)
  BB->eraseFromParent();
356}
357/// ReduceCrashingBlocks reducer - This works by setting the terminators of
358/// all terminators except the specified basic blocks to a 'ret' instruction,
359/// then running the simplify-cfg pass.  This has the effect of chopping up
360/// the CFG really fast which can reduce large functions quickly.
361///
362class ReduceCrashingBlocks : public ListReducer<const BasicBlock *> {
BugDriver &BD;
BugTester TestFn;

366public:
ReduceCrashingBlocks(BugDriver &BD, BugTester testFn)
    : BD(BD), TestFn(testFn) {}

Expected<TestResult> doTest(std::vector<const BasicBlock *> &Prefix,
                            std::vector<const BasicBlock *> &Kept) override {
  if (!Kept.empty() && TestBlocks(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestBlocks(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestBlocks(std::vector<const BasicBlock *> &Prefix);
380};
381}

383bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock *> &BBs) {
// Clone the program to try hacking it apart...
ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

// Convert list to set for fast lookup...
SmallPtrSet<BasicBlock *, 8> Blocks;
for (unsigned i = 0, e = BBs.size(); i != e; ++i)
  Blocks.insert(cast<BasicBlock>(VMap[BBs[i]]));

outs() << "Checking for crash with only these blocks:";
unsigned NumPrint = Blocks.size();
if (NumPrint > 10)
  NumPrint = 10;
for (unsigned i = 0, e = NumPrint; i != e; ++i)
  outs() << " " << BBs[i]->getName();
if (NumPrint < Blocks.size())
  outs() << "... <" << Blocks.size() << " total>";
outs() << ": ";

// Loop over and delete any hack up any blocks that are not listed...
for (Function &F : M->functions()) {
  for (BasicBlock &BB : F) {
    if (!Blocks.count(&BB) && BB.getTerminator()->getNumSuccessors()) {
      // Loop over all of the successors of this block, deleting any PHI nodes
      // that might include it.
      for (BasicBlock *Succ : successors(&BB))
        Succ->removePredecessor(&BB);

      Instruction *BBTerm = BB.getTerminator();
      if (BBTerm->isEHPad() || BBTerm->getType()->isTokenTy())
        continue;
      if (!BBTerm->getType()->isVoidTy())
        BBTerm->replaceAllUsesWith(Constant::getNullValue(BBTerm->getType()));

      // Replace the old terminator instruction.
      BB.getInstList().pop_back();
      new UnreachableInst(BB.getContext(), &BB);
    }
  }
}

// The CFG Simplifier pass may delete one of the basic blocks we are
// interested in.  If it does we need to take the block out of the list.  Make
// a "persistent mapping" by turning basic blocks into <function, name> pairs.
// This won't work well if blocks are unnamed, but that is just the risk we
// have to take. FIXME: Can we just name the blocks?
std::vector<std::pair<std::string, std::string>> BlockInfo;

for (BasicBlock *BB : Blocks)
  BlockInfo.emplace_back(BB->getParent()->getName(), BB->getName());

SmallVector<BasicBlock *, 16> ToProcess;
for (auto &F : *M) {
  for (auto &BB : F)
    if (!Blocks.count(&BB))
      ToProcess.push_back(&BB);
  simpleSimplifyCfg(F, ToProcess);
  ToProcess.clear();
}
// Verify we didn't break anything
std::vector<std::string> Passes;
Passes.push_back("verify");
std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
if (!New) {
  errs() << "verify failed!\n";
  exit(1);
}
M = std::move(New);

// Try running on the hacked up program...
if (TestFn(BD, M.get())) {
  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...

  // Make sure to use basic block pointers that point into the now-current
  // module, and that they don't include any deleted blocks.
  BBs.clear();
  const ValueSymbolTable &GST = BD.getProgram().getValueSymbolTable();
  for (const auto &BI : BlockInfo) {
    Function *F = cast<Function>(GST.lookup(BI.first));
    Value *V = F->getValueSymbolTable()->lookup(BI.second);
    if (V && V->getType() == Type::getLabelTy(V->getContext()))
      BBs.push_back(cast<BasicBlock>(V));
  }
  return true;
}
// It didn't crash, try something else.
return false;
471}

473namespace {
474/// ReduceCrashingConditionals reducer - This works by changing
475/// conditional branches to unconditional ones, then simplifying the CFG
476/// This has the effect of chopping up the CFG really fast which can reduce
477/// large functions quickly.
478///
479class ReduceCrashingConditionals : public ListReducer<const BasicBlock *> {
BugDriver &BD;
BugTester TestFn;
bool Direction;

484public:
ReduceCrashingConditionals(BugDriver &bd, BugTester testFn, bool Direction)
    : BD(bd), TestFn(testFn), Direction(Direction) {}

Expected<TestResult> doTest(std::vector<const BasicBlock *> &Prefix,
                            std::vector<const BasicBlock *> &Kept) override {
  if (!Kept.empty() && TestBlocks(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestBlocks(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestBlocks(std::vector<const BasicBlock *> &Prefix);
498};
499}

501bool ReduceCrashingConditionals::TestBlocks(
  std::vector<const BasicBlock *> &BBs) {
// Clone the program to try hacking it apart...
ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

// Convert list to set for fast lookup...
SmallPtrSet<const BasicBlock *, 8> Blocks;
for (const auto *BB : BBs)
  Blocks.insert(cast<BasicBlock>(VMap[BB]));

outs() << "Checking for crash with changing conditionals to always jump to "
       << (Direction ? "true" : "false") << ":";
unsigned NumPrint = Blocks.size();
if (NumPrint > 10)
  NumPrint = 10;
for (unsigned i = 0, e = NumPrint; i != e; ++i)
  outs() << " " << BBs[i]->getName();
if (NumPrint < Blocks.size())
  outs() << "... <" << Blocks.size() << " total>";
outs() << ": ";

// Loop over and delete any hack up any blocks that are not listed...
for (auto &F : *M)
  for (auto &BB : F)
    if (!Blocks.count(&BB)) {
      auto *BR = dyn_cast<BranchInst>(BB.getTerminator());
      if (!BR || !BR->isConditional())
        continue;
      if (Direction)
        BR->setCondition(ConstantInt::getTrue(BR->getContext()));
      else
        BR->setCondition(ConstantInt::getFalse(BR->getContext()));
    }

// The following may destroy some blocks, so we save them first
std::vector<std::pair<std::string, std::string>> BlockInfo;

for (const BasicBlock *BB : Blocks)
  BlockInfo.emplace_back(BB->getParent()->getName(), BB->getName());

SmallVector<BasicBlock *, 16> ToProcess;
for (auto &F : *M) {
  for (auto &BB : F)
    if (!Blocks.count(&BB))
      ToProcess.push_back(&BB);
  simpleSimplifyCfg(F, ToProcess);
  ToProcess.clear();
}
// Verify we didn't break anything
std::vector<std::string> Passes;
Passes.push_back("verify");
std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
if (!New) {
  errs() << "verify failed!\n";
  exit(1);
}
M = std::move(New);

// Try running on the hacked up program...
if (TestFn(BD, M.get())) {
  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...

  // Make sure to use basic block pointers that point into the now-current
  // module, and that they don't include any deleted blocks.
  BBs.clear();
  const ValueSymbolTable &GST = BD.getProgram().getValueSymbolTable();
  for (auto &BI : BlockInfo) {
    auto *F = cast<Function>(GST.lookup(BI.first));
    Value *V = F->getValueSymbolTable()->lookup(BI.second);
    if (V && V->getType() == Type::getLabelTy(V->getContext()))
      BBs.push_back(cast<BasicBlock>(V));
  }
  return true;
}
// It didn't crash, try something else.
return false;
578}

580namespace {
581/// SimplifyCFG reducer - This works by calling SimplifyCFG on each basic block
582/// in the program.

584class ReduceSimplifyCFG : public ListReducer<const BasicBlock *> {
BugDriver &BD;
BugTester TestFn;
TargetTransformInfo TTI;

589public:
ReduceSimplifyCFG(BugDriver &bd, BugTester testFn)
    : BD(bd), TestFn(testFn), TTI(bd.getProgram().getDataLayout()) {}

Expected<TestResult> doTest(std::vector<const BasicBlock *> &Prefix,
                            std::vector<const BasicBlock *> &Kept) override {
  if (!Kept.empty() && TestBlocks(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestBlocks(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestBlocks(std::vector<const BasicBlock *> &Prefix);
603};
604}

606bool ReduceSimplifyCFG::TestBlocks(std::vector<const BasicBlock *> &BBs) {
// Clone the program to try hacking it apart...
ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

// Convert list to set for fast lookup...
SmallPtrSet<const BasicBlock *, 8> Blocks;
for (const auto *BB : BBs)
  Blocks.insert(cast<BasicBlock>(VMap[BB]));

outs() << "Checking for crash with CFG simplifying:";
unsigned NumPrint = Blocks.size();
if (NumPrint > 10)
  NumPrint = 10;
for (unsigned i = 0, e = NumPrint; i != e; ++i)
  outs() << " " << BBs[i]->getName();
if (NumPrint < Blocks.size())
  outs() << "... <" << Blocks.size() << " total>";
outs() << ": ";

// The following may destroy some blocks, so we save them first
std::vector<std::pair<std::string, std::string>> BlockInfo;

for (const BasicBlock *BB : Blocks)
  BlockInfo.emplace_back(BB->getParent()->getName(), BB->getName());

// Loop over and delete any hack up any blocks that are not listed...
for (auto &F : *M)
  // Loop over all of the basic blocks and remove them if they are unneeded.
  for (Function::iterator BBIt = F.begin(); BBIt != F.end();) {
    if (!Blocks.count(&*BBIt)) {
      ++BBIt;
      continue;
    }
    simplifyCFG(&*BBIt++, TTI);
  }
// Verify we didn't break anything
std::vector<std::string> Passes;
Passes.push_back("verify");
std::unique_ptr<Module> New = BD.runPassesOn(M.get(), Passes);
if (!New) {
  errs() << "verify failed!\n";
  exit(1);
}
M = std::move(New);

// Try running on the hacked up program...
if (TestFn(BD, M.get())) {
  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...

  // Make sure to use basic block pointers that point into the now-current
  // module, and that they don't include any deleted blocks.
  BBs.clear();
  const ValueSymbolTable &GST = BD.getProgram().getValueSymbolTable();
  for (auto &BI : BlockInfo) {
    auto *F = cast<Function>(GST.lookup(BI.first));
    Value *V = F->getValueSymbolTable()->lookup(BI.second);
    if (V && V->getType() == Type::getLabelTy(V->getContext()))
      BBs.push_back(cast<BasicBlock>(V));
  }
  return true;
}
// It didn't crash, try something else.
return false;
670}

672namespace {
673/// ReduceCrashingInstructions reducer - This works by removing the specified
674/// non-terminator instructions and replacing them with undef.
675///
676class ReduceCrashingInstructions : public ListReducer<const Instruction *> {
BugDriver &BD;
BugTester TestFn;

680public:
ReduceCrashingInstructions(BugDriver &bd, BugTester testFn)
    : BD(bd), TestFn(testFn) {}

Expected<TestResult> doTest(std::vector<const Instruction *> &Prefix,
                            std::vector<const Instruction *> &Kept) override {
  if (!Kept.empty() && TestInsts(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestInsts(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestInsts(std::vector<const Instruction *> &Prefix);
694};
695}

697bool ReduceCrashingInstructions::TestInsts(
  std::vector<const Instruction *> &Insts) {
// Clone the program to try hacking it apart...
ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

// Convert list to set for fast lookup...
SmallPtrSet<Instruction *, 32> Instructions;
for (unsigned i = 0, e = Insts.size(); i != e; ++i) {
  assert(!Insts[i]->isTerminator())((!Insts[i]->isTerminator()) ? static_cast<void> (0)
 : __assert_fail ("!Insts[i]->isTerminator()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/bugpoint/CrashDebugger.cpp"
, 706, __PRETTY_FUNCTION__));
  Instructions.insert(cast<Instruction>(VMap[Insts[i]]));
}

outs() << "Checking for crash with only " << Instructions.size();
if (Instructions.size() == 1)
  outs() << " instruction: ";
else
  outs() << " instructions: ";

for (Module::iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI)
  for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE; ++FI)
    for (BasicBlock::iterator I = FI->begin(), E = FI->end(); I != E;) {
      Instruction *Inst = &*I++;
      if (!Instructions.count(Inst) && !Inst->isTerminator() &&
          !Inst->isEHPad() && !Inst->getType()->isTokenTy() &&
          !Inst->isSwiftError()) {
        if (!Inst->getType()->isVoidTy())
          Inst->replaceAllUsesWith(UndefValue::get(Inst->getType()));
        Inst->eraseFromParent();
      }
    }

// Verify that this is still valid.
legacy::PassManager Passes;
Passes.add(createVerifierPass(/*FatalErrors=*/false));
Passes.run(*M);

// Try running on the hacked up program...
if (TestFn(BD, M.get())) {
  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...

  // Make sure to use instruction pointers that point into the now-current
  // module, and that they don't include any deleted blocks.
  Insts.clear();
  for (Instruction *Inst : Instructions)
    Insts.push_back(Inst);
  return true;
}
// It didn't crash, try something else.
return false;
747}

749namespace {
750// Reduce the list of Named Metadata nodes. We keep this as a list of
751// names to avoid having to convert back and forth every time.
752class ReduceCrashingNamedMD : public ListReducer<std::string> {
BugDriver &BD;
BugTester TestFn;

756public:
ReduceCrashingNamedMD(BugDriver &bd, BugTester testFn)
    : BD(bd), TestFn(testFn) {}

Expected<TestResult> doTest(std::vector<std::string> &Prefix,
                            std::vector<std::string> &Kept) override {
  if (!Kept.empty() && TestNamedMDs(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestNamedMDs(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestNamedMDs(std::vector<std::string> &NamedMDs);
770};
771}

773bool ReduceCrashingNamedMD::TestNamedMDs(std::vector<std::string> &NamedMDs) {

ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

outs() << "Checking for crash with only these named metadata nodes:";
unsigned NumPrint = std::min<size_t>(NamedMDs.size(), 10);
for (unsigned i = 0, e = NumPrint; i != e; ++i)
  outs() << " " << NamedMDs[i];
if (NumPrint < NamedMDs.size())
  outs() << "... <" << NamedMDs.size() << " total>";
outs() << ": ";

// Make a StringMap for faster lookup
StringSet<> Names;
for (const std::string &Name : NamedMDs)
  Names.insert(Name);

// First collect all the metadata to delete in a vector, then
// delete them all at once to avoid invalidating the iterator
std::vector<NamedMDNode *> ToDelete;
ToDelete.reserve(M->named_metadata_size() - Names.size());
for (auto &NamedMD : M->named_metadata())
  // Always keep a nonempty llvm.dbg.cu because the Verifier would complain.
  if (!Names.count(NamedMD.getName()) &&
      (!(NamedMD.getName() == "llvm.dbg.cu" && NamedMD.getNumOperands() > 0)))
    ToDelete.push_back(&NamedMD);

for (auto *NamedMD : ToDelete)
  NamedMD->eraseFromParent();

// Verify that this is still valid.
legacy::PassManager Passes;
Passes.add(createVerifierPass(/*FatalErrors=*/false));
Passes.run(*M);

// Try running on the hacked up program...
if (TestFn(BD, M.get())) {
  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
  return true;
}
return false;
815}

817namespace {
818// Reduce the list of operands to named metadata nodes
819class ReduceCrashingNamedMDOps : public ListReducer<const MDNode *> {
BugDriver &BD;
BugTester TestFn;

823public:
ReduceCrashingNamedMDOps(BugDriver &bd, BugTester testFn)
    : BD(bd), TestFn(testFn) {}

Expected<TestResult> doTest(std::vector<const MDNode *> &Prefix,
                            std::vector<const MDNode *> &Kept) override {
  if (!Kept.empty() && TestNamedMDOps(Kept))
    return KeepSuffix;
  if (!Prefix.empty() && TestNamedMDOps(Prefix))
    return KeepPrefix;
  return NoFailure;
}

bool TestNamedMDOps(std::vector<const MDNode *> &NamedMDOps);
837};
838}

840bool ReduceCrashingNamedMDOps::TestNamedMDOps(
  std::vector<const MDNode *> &NamedMDOps) {
// Convert list to set for fast lookup...
SmallPtrSet<const MDNode *, 32> OldMDNodeOps;
for (unsigned i = 0, e = NamedMDOps.size(); i != e; ++i) {
  OldMDNodeOps.insert(NamedMDOps[i]);
}

outs() << "Checking for crash with only " << OldMDNodeOps.size();
if (OldMDNodeOps.size() == 1)
  outs() << " named metadata operand: ";
else
  outs() << " named metadata operands: ";

ValueToValueMapTy VMap;
std::unique_ptr<Module> M = CloneModule(BD.getProgram(), VMap);

// This is a little wasteful. In the future it might be good if we could have
// these dropped during cloning.
for (auto &NamedMD : BD.getProgram().named_metadata()) {
  // Drop the old one and create a new one
  M->eraseNamedMetadata(M->getNamedMetadata(NamedMD.getName()));
  NamedMDNode *NewNamedMDNode =
      M->getOrInsertNamedMetadata(NamedMD.getName());
  for (MDNode *op : NamedMD.operands())
    if (OldMDNodeOps.count(op))
      NewNamedMDNode->addOperand(cast<MDNode>(MapMetadata(op, VMap)));
}

// Verify that this is still valid.
legacy::PassManager Passes;
Passes.add(createVerifierPass(/*FatalErrors=*/false));
Passes.run(*M);

// Try running on the hacked up program...
if (TestFn(BD, M.get())) {
  // Make sure to use instruction pointers that point into the now-current
  // module, and that they don't include any deleted blocks.
  NamedMDOps.clear();
  for (const MDNode *Node : OldMDNodeOps)
    NamedMDOps.push_back(cast<MDNode>(*VMap.getMappedMD(Node)));

  BD.setNewProgram(std::move(M)); // It crashed, keep the trimmed version...
  return true;
}
// It didn't crash, try something else.
return false;
887}

889/// Attempt to eliminate as many global initializers as possible.
890static Error ReduceGlobalInitializers(BugDriver &BD, BugTester TestFn) {
Module &OrigM = BD.getProgram();
if (OrigM.global_empty())
5
←
Assuming the condition is false→
6
←
Taking false branch→
  return Error::success();

// Now try to reduce the number of global variable initializers in the
// module to something small.
std::unique_ptr<Module> M = CloneModule(OrigM);
bool DeletedInit = false;

for (GlobalVariable &GV : M->globals()) {
  if (GV.hasInitializer()) {
7
←
Taking true branch→
    DeleteGlobalInitializer(&GV);
    GV.setLinkage(GlobalValue::ExternalLinkage);
    GV.setComdat(nullptr);
    DeletedInit = true;
  }
}

if (!DeletedInit)
8
←
Taking false branch→
  return Error::success();

// See if the program still causes a crash...
outs() << "\nChecking to see if we can delete global inits: ";

if (TestFn(BD, M.get())) { // Still crashes?
9
←
Calling 'TestForCodeGenCrash'→
  BD.setNewProgram(std::move(M));
  outs() << "\n*** Able to remove all global initializers!\n";
  return Error::success();
}

// No longer crashes.
outs() << "  - Removing all global inits hides problem!\n";

std::vector<GlobalVariable *> GVs;
for (GlobalVariable &GV : OrigM.globals())
  if (GV.hasInitializer())
    GVs.push_back(&GV);

if (GVs.size() > 1 && !BugpointIsInterrupted) {
  outs() << "\n*** Attempting to reduce the number of global initializers "
         << "in the testcase\n";

  unsigned OldSize = GVs.size();
  Expected<bool> Result =
      ReduceCrashingGlobalInitializers(BD, TestFn).reduceList(GVs);
  if (Error E = Result.takeError())
    return E;

  if (GVs.size() < OldSize)
    BD.EmitProgressBitcode(BD.getProgram(), "reduced-global-variables");
}
return Error::success();
943}

945static Error ReduceInsts(BugDriver &BD, BugTester TestFn) {
// Attempt to delete instructions using bisection. This should help out nasty
// cases with large basic blocks where the problem is at one end.
if (!BugpointIsInterrupted) {
  std::vector<const Instruction *> Insts;
  for (const Function &F : BD.getProgram())
    for (const BasicBlock &BB : F)
      for (const Instruction &I : BB)
        if (!I.isTerminator())
          Insts.push_back(&I);

  Expected<bool> Result =
      ReduceCrashingInstructions(BD, TestFn).reduceList(Insts);
  if (Error E = Result.takeError())
    return E;
}

unsigned Simplification = 2;
do {
  if (BugpointIsInterrupted)
    // TODO: Should we distinguish this with an "interrupted error"?
    return Error::success();
  --Simplification;
  outs() << "\n*** Attempting to reduce testcase by deleting instruc"
         << "tions: Simplification Level #" << Simplification << '\n';

  // Now that we have deleted the functions that are unnecessary for the
  // program, try to remove instructions that are not necessary to cause the
  // crash.  To do this, we loop through all of the instructions in the
  // remaining functions, deleting them (replacing any values produced with
  // nulls), and then running ADCE and SimplifyCFG.  If the transformed input
  // still triggers failure, keep deleting until we cannot trigger failure
  // anymore.
  //
  unsigned InstructionsToSkipBeforeDeleting = 0;
TryAgain:

  // Loop over all of the (non-terminator) instructions remaining in the
  // function, attempting to delete them.
  unsigned CurInstructionNum = 0;
  for (Module::const_iterator FI = BD.getProgram().begin(),
                              E = BD.getProgram().end();
       FI != E; ++FI)
    if (!FI->isDeclaration())
      for (Function::const_iterator BI = FI->begin(), E = FI->end(); BI != E;
           ++BI)
        for (BasicBlock::const_iterator I = BI->begin(), E = --BI->end();
             I != E; ++I, ++CurInstructionNum) {
          if (InstructionsToSkipBeforeDeleting) {
            --InstructionsToSkipBeforeDeleting;
          } else {
            if (BugpointIsInterrupted)
              // TODO: Should this be some kind of interrupted error?
              return Error::success();

            if (I->isEHPad() || I->getType()->isTokenTy() ||
                I->isSwiftError())
              continue;

            outs() << "Checking instruction: " << *I;
            std::unique_ptr<Module> M =
                BD.deleteInstructionFromProgram(&*I, Simplification);

            // Find out if the pass still crashes on this pass...
            if (TestFn(BD, M.get())) {
              // Yup, it does, we delete the old module, and continue trying
              // to reduce the testcase...
              BD.setNewProgram(std::move(M));
              InstructionsToSkipBeforeDeleting = CurInstructionNum;
              goto TryAgain; // I wish I had a multi-level break here!
            }
          }
        }

  if (InstructionsToSkipBeforeDeleting) {
    InstructionsToSkipBeforeDeleting = 0;
    goto TryAgain;
  }

} while (Simplification);
BD.EmitProgressBitcode(BD.getProgram(), "reduced-instructions");
return Error::success();
1027}

1029/// DebugACrash - Given a predicate that determines whether a component crashes
1030/// on a program, try to destructively reduce the program while still keeping
1031/// the predicate true.
1032static Error DebugACrash(BugDriver &BD, BugTester TestFn) {
// See if we can get away with nuking some of the global variable initializers
// in the program...
if (!NoGlobalRM)
2
←
Assuming the condition is true→
3
←
Taking true branch→
  if (Error E = ReduceGlobalInitializers(BD, TestFn))
4
←
Calling 'ReduceGlobalInitializers'→
    return E;

// Now try to reduce the number of functions in the module to something small.
std::vector<Function *> Functions;
for (Function &F : BD.getProgram())
  if (!F.isDeclaration())
    Functions.push_back(&F);

if (Functions.size() > 1 && !BugpointIsInterrupted) {
  outs() << "\n*** Attempting to reduce the number of functions "
            "in the testcase\n";

  unsigned OldSize = Functions.size();
  Expected<bool> Result =
      ReduceCrashingFunctions(BD, TestFn).reduceList(Functions);
  if (Error E = Result.takeError())
    return E;

  if (Functions.size() < OldSize)
    BD.EmitProgressBitcode(BD.getProgram(), "reduced-function");
}

// Attempt to change conditional branches into unconditional branches to
// eliminate blocks.
if (!DisableSimplifyCFG && !BugpointIsInterrupted) {
  std::vector<const BasicBlock *> Blocks;
  for (Function &F : BD.getProgram())
    for (BasicBlock &BB : F)
      Blocks.push_back(&BB);
  unsigned OldSize = Blocks.size();
  Expected<bool> Result =
      ReduceCrashingConditionals(BD, TestFn, true).reduceList(Blocks);
  if (Error E = Result.takeError())
    return E;
  Result = ReduceCrashingConditionals(BD, TestFn, false).reduceList(Blocks);
  if (Error E = Result.takeError())
    return E;
  if (Blocks.size() < OldSize)
    BD.EmitProgressBitcode(BD.getProgram(), "reduced-conditionals");
}

// Attempt to delete entire basic blocks at a time to speed up
// convergence... this actually works by setting the terminator of the blocks
// to a return instruction then running simplifycfg, which can potentially
// shrinks the code dramatically quickly
//
if (!DisableSimplifyCFG && !BugpointIsInterrupted) {
  std::vector<const BasicBlock *> Blocks;
  for (Function &F : BD.getProgram())
    for (BasicBlock &BB : F)
      Blocks.push_back(&BB);
  unsigned OldSize = Blocks.size();
  Expected<bool> Result = ReduceCrashingBlocks(BD, TestFn).reduceList(Blocks);
  if (Error E = Result.takeError())
    return E;
  if (Blocks.size() < OldSize)
    BD.EmitProgressBitcode(BD.getProgram(), "reduced-blocks");
}

if (!DisableSimplifyCFG && !BugpointIsInterrupted) {
  std::vector<const BasicBlock *> Blocks;
  for (Function &F : BD.getProgram())
    for (BasicBlock &BB : F)
      Blocks.push_back(&BB);
  unsigned OldSize = Blocks.size();
  Expected<bool> Result = ReduceSimplifyCFG(BD, TestFn).reduceList(Blocks);
  if (Error E = Result.takeError())
    return E;
  if (Blocks.size() < OldSize)
    BD.EmitProgressBitcode(BD.getProgram(), "reduced-simplifycfg");
}

// Attempt to delete instructions using bisection. This should help out nasty
// cases with large basic blocks where the problem is at one end.
if (!BugpointIsInterrupted)
  if (Error E = ReduceInsts(BD, TestFn))
    return E;

// Attempt to strip debug info metadata.
auto stripMetadata = [&](std::function<bool(Module &)> strip) {
  std::unique_ptr<Module> M = CloneModule(BD.getProgram());
  strip(*M);
  if (TestFn(BD, M.get()))
    BD.setNewProgram(std::move(M));
};
if (!NoStripDebugInfo && !BugpointIsInterrupted) {
  outs() << "\n*** Attempting to strip the debug info: ";
  stripMetadata(StripDebugInfo);
}
if (!NoStripDebugTypeInfo && !BugpointIsInterrupted) {
  outs() << "\n*** Attempting to strip the debug type info: ";
  stripMetadata(stripNonLineTableDebugInfo);
}

if (!NoNamedMDRM) {
  if (!BugpointIsInterrupted) {
    // Try to reduce the amount of global metadata (particularly debug info),
    // by dropping global named metadata that anchors them
    outs() << "\n*** Attempting to remove named metadata: ";
    std::vector<std::string> NamedMDNames;
    for (auto &NamedMD : BD.getProgram().named_metadata())
      NamedMDNames.push_back(NamedMD.getName().str());
    Expected<bool> Result =
        ReduceCrashingNamedMD(BD, TestFn).reduceList(NamedMDNames);
    if (Error E = Result.takeError())
      return E;
  }

  if (!BugpointIsInterrupted) {
    // Now that we quickly dropped all the named metadata that doesn't
    // contribute to the crash, bisect the operands of the remaining ones
    std::vector<const MDNode *> NamedMDOps;
    for (auto &NamedMD : BD.getProgram().named_metadata())
      for (auto op : NamedMD.operands())
        NamedMDOps.push_back(op);
    Expected<bool> Result =
        ReduceCrashingNamedMDOps(BD, TestFn).reduceList(NamedMDOps);
    if (Error E = Result.takeError())
      return E;
  }
  BD.EmitProgressBitcode(BD.getProgram(), "reduced-named-md");
}

// Try to clean up the testcase by running funcresolve and globaldce...
if (!BugpointIsInterrupted) {
  outs() << "\n*** Attempting to perform final cleanups: ";
  std::unique_ptr<Module> M = CloneModule(BD.getProgram());
  M = BD.performFinalCleanups(std::move(M), true);

  // Find out if the pass still crashes on the cleaned up program...
  if (M && TestFn(BD, M.get()))
    BD.setNewProgram(
        std::move(M)); // Yup, it does, keep the reduced version...
}

BD.EmitProgressBitcode(BD.getProgram(), "reduced-simplified");

return Error::success();
1175}

1177static bool TestForOptimizerCrash(const BugDriver &BD, Module *M) {
return BD.runPasses(*M, BD.getPassesToRun());
1179}

1181/// debugOptimizerCrash - This method is called when some pass crashes on input.
1182/// It attempts to prune down the testcase to something reasonable, and figure
1183/// out exactly which pass is crashing.
1184///
1185Error BugDriver::debugOptimizerCrash(const std::string &ID) {
outs() << "\n*** Debugging optimizer crash!\n";

// Reduce the list of passes which causes the optimizer to crash...
if (!BugpointIsInterrupted && !DontReducePassList) {
  Expected<bool> Result = ReducePassList(*this).reduceList(PassesToRun);
  if (Error E = Result.takeError())
    return E;
}

outs() << "\n*** Found crashing pass"
       << (PassesToRun.size() == 1 ? ": " : "es: ")
       << getPassesString(PassesToRun) << '\n';

EmitProgressBitcode(*Program, ID);

return DebugACrash(*this, TestForOptimizerCrash);
1202}

1204static bool TestForCodeGenCrash(const BugDriver &BD, Module *M) {
if (Error E = BD.compileProgram(*M)) {
10
←
Taking true branch→
  if (VerboseErrors)
11
←
Assuming the condition is false→
12
←
Taking false branch→
    errs() << toString(std::move(E)) << "\n";
  else {
    consumeError(std::move(E));
13
←
Calling 'consumeError'→
    errs() << "<crash>\n";
  }
  return true; // Tool is still crashing.
}
errs() << '\n';
return false;
1216}

1218/// debugCodeGeneratorCrash - This method is called when the code generator
1219/// crashes on an input.  It attempts to reduce the input as much as possible
1220/// while still causing the code generator to crash.
1221Error BugDriver::debugCodeGeneratorCrash() {
errs() << "*** Debugging code generator crash!\n";

return DebugACrash(*this, TestForCodeGenCrash);
1
Calling 'DebugACrash'→
1225}

←

/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);
28
←
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)
20
←
Taking false branch→
394      return E2;
395    if (!E2)
21
←
Taking false branch→
396      return E1;
397    if (E1.isA<ErrorList>()) {
22
←
Assuming the condition is false→
23
←
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>()) {
24
←
Assuming the condition is false→
25
←
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>(
27
←
Calling constructor for 'Error'→
415        new ErrorList(E1.takePayload(), E2.takePayload())));
26
←
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)
16
←
Taking false branch→
884    return Error::success();
885 
886  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
887 
888  if (Payload->isA<ErrorList>()) {
17
←
Assuming the condition is true→
18
←
Taking true branch→
889    ErrorList &List = static_cast<ErrorList &>(*Payload);
890    Error R;
891    for (auto &P : List.Payloads)
892      R = ErrorList::join(
19
←
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)...));
15
←
Calling 'handleErrors<(lambda at /build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h:979:35)>'→
907}
908 
909/// Check that E is a non-error, then drop it.
910/// If E is an error, llvm_unreachable will be called.
911inline void handleAllErrors(Error E) {
912  cantFail(std::move(E));
913}
914 
915/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
916///
917/// If the incoming value is a success value it is returned unmodified. If it
918/// is a failure value then it the contained error is passed to handleErrors.
919/// If handleErrors is able to handle the error then the RecoveryPath functor
920/// is called to supply the final result. If handleErrors is not able to
921/// handle all errors then the unhandled errors are returned.
922///
923/// This utility enables the follow pattern:
924///
925///   @code{.cpp}
926///   enum FooStrategy { Aggressive, Conservative };
927///   Expected<Foo> foo(FooStrategy S);
928///
929///   auto ResultOrErr =
930///     handleExpected(
931///       foo(Aggressive),
932///       []() { return foo(Conservative); },
933///       [](AggressiveStrategyError&) {
934///         // Implicitly conusme this - we'll recover by using a conservative
935///         // strategy.
936///       });
937///
938///   @endcode
939template <typename T, typename RecoveryFtor, typename... HandlerTs>
940Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
941                           HandlerTs &&... Handlers) {
942  if (ValOrErr)
943    return ValOrErr;
944 
945  if (auto Err = handleErrors(ValOrErr.takeError(),
946                              std::forward<HandlerTs>(Handlers)...))
947    return std::move(Err);
948 
949  return RecoveryPath();
950}
951 
952/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
953/// will be printed before the first one is logged. A newline will be printed
954/// after each error.
955///
956/// This is useful in the base level of your program to allow clean termination
957/// (allowing clean deallocation of resources, etc.), while reporting error
958/// information to the user.
959void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner);
960 
961/// Write all error messages (if any) in E to a string. The newline character
962/// is used to separate error messages.
963inline std::string toString(Error E) {
964  SmallVector<std::string, 2> Errors;
965  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
966    Errors.push_back(EI.message());
967  });
968  return join(Errors.begin(), Errors.end(), "\n");
969}
970 
971/// Consume a Error without doing anything. This method should be used
972/// only where an error can be considered a reasonable and expected return
973/// value.
974///
975/// Uses of this method are potentially indicative of design problems: If it's
976/// legitimate to do nothing while processing an "error", the error-producer
977/// might be more clearly refactored to return an Optional<T>.
978inline void consumeError(Error Err) {
979  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
14
←
Calling 'handleAllErrors<(lambda at /build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h:979:35)>'→
980}
981 
982/// Helper for converting an Error to a bool.
983///
984/// This method returns true if Err is in an error state, or false if it is
985/// in a success state.  Puts Err in a checked state in both cases (unlike
986/// Error::operator bool(), which only does this for success states).
987inline bool errorToBool(Error Err) {
988  bool IsError = static_cast<bool>(Err);
989  if (IsError)
990    consumeError(std::move(Err));
991  return IsError;
992}
993 
994/// Helper for Errors used as out-parameters.
995///
996/// This helper is for use with the Error-as-out-parameter idiom, where an error
997/// is passed to a function or method by reference, rather than being returned.
998/// In such cases it is helpful to set the checked bit on entry to the function
999/// so that the error can be written to (unchecked Errors abort on assignment)
1000/// and clear the checked bit on exit so that clients cannot accidentally forget
1001/// to check the result. This helper performs these actions automatically using
1002/// RAII:
1003///
1004///   @code{.cpp}
1005///   Result foo(Error &Err) {
1006///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1007///     // <body of foo>
1008///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1009///   }
1010///   @endcode
1011///
1012/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1013/// used with optional Errors (Error pointers that are allowed to be null). If
1014/// ErrorAsOutParameter took an Error reference, an instance would have to be
1015/// created inside every condition that verified that Error was non-null. By
1016/// taking an Error pointer we can just create one instance at the top of the
1017/// function.
1018class ErrorAsOutParameter {
1019public:
1020  ErrorAsOutParameter(Error *Err) : Err(Err) {
1021    // Raise the checked bit if Err is success.
1022    if (Err)
1023      (void)!!*Err;
1024  }
1025 
1026  ~ErrorAsOutParameter() {
1027    // Clear the checked bit.
1028    if (Err && !*Err)
1029      *Err = Error::success();
1030  }
1031 
1032private:
1033  Error *Err;
1034};
1035 
1036/// Helper for Expected<T>s used as out-parameters.
1037///
1038/// See ErrorAsOutParameter.
1039template <typename T>
1040class ExpectedAsOutParameter {
1041public:
1042  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1043    : ValOrErr(ValOrErr) {
1044    if (ValOrErr)
1045      (void)!!*ValOrErr;
1046  }
1047 
1048  ~ExpectedAsOutParameter() {
1049    if (ValOrErr)
1050      ValOrErr->setUnchecked();
1051  }
1052 
1053private:
1054  Expected<T> *ValOrErr;
1055};
1056 
1057/// This class wraps a std::error_code in a Error.
1058///
1059/// This is useful if you're writing an interface that returns a Error
1060/// (or Expected) and you want to call code that still returns
1061/// std::error_codes.
1062class ECError : public ErrorInfo<ECError> {
1063  friend Error errorCodeToError(std::error_code);
1064 
1065public:
1066  void setErrorCode(std::error_code EC) { this->EC = EC; }
1067  std::error_code convertToErrorCode() const override { return EC; }
1068  void log(raw_ostream &OS) const override { OS << EC.message(); }
1069 
1070  // Used by ErrorInfo::classID.
1071  static char ID;
1072 
1073protected:
1074  ECError() = default;
1075  ECError(std::error_code EC) : EC(EC) {}
1076 
1077  std::error_code EC;
1078};
1079 
1080/// The value returned by this function can be returned from convertToErrorCode
1081/// for Error values where no sensible translation to std::error_code exists.
1082/// It should only be used in this situation, and should never be used where a
1083/// sensible conversion to std::error_code is available, as attempts to convert
1084/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1085///error to try to convert such a value).
1086std::error_code inconvertibleErrorCode();
1087 
1088/// Helper for converting an std::error_code to a Error.
1089Error errorCodeToError(std::error_code EC);
1090 
1091/// Helper for converting an ECError to a std::error_code.
1092///
1093/// This method requires that Err be Error() or an ECError, otherwise it
1094/// will trigger a call to abort().
1095std::error_code errorToErrorCode(Error Err);
1096 
1097/// Convert an ErrorOr<T> to an Expected<T>.
1098template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1099  if (auto EC = EO.getError())
1100    return errorCodeToError(EC);
1101  return std::move(*EO);
1102}
1103 
1104/// Convert an Expected<T> to an ErrorOr<T>.
1105template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1106  if (auto Err = E.takeError())
1107    return errorToErrorCode(std::move(Err));
1108  return std::move(*E);
1109}
1110 
1111/// This class wraps a string in an Error.
1112///
1113/// StringError is useful in cases where the client is not expected to be able
1114/// to consume the specific error message programmatically (for example, if the
1115/// error message is to be presented to the user).
1116///
1117/// StringError can also be used when additional information is to be printed
1118/// along with a error_code message. Depending on the constructor called, this
1119/// class can either display:
1120///    1. the error_code message (ECError behavior)
1121///    2. a string
1122///    3. the error_code message and a string
1123///
1124/// These behaviors are useful when subtyping is required; for example, when a
1125/// specific library needs an explicit error type. In the example below,
1126/// PDBError is derived from StringError:
1127///
1128///   @code{.cpp}
1129///   Expected<int> foo() {
1130///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1131///                                        "Additional information");
1132///   }
1133///   @endcode
1134///
1135class StringError : public ErrorInfo<StringError> {
1136public:
1137  static char ID;
1138 
1139  // Prints EC + S and converts to EC
1140  StringError(std::error_code EC, const Twine &S = Twine());
1141 
1142  // Prints S and converts to EC
1143  StringError(const Twine &S, std::error_code EC);
1144 
1145  void log(raw_ostream &OS) const override;
1146  std::error_code convertToErrorCode() const override;
1147 
1148  const std::string &getMessage() const { return Msg; }
1149 
1150private:
1151  std::string Msg;
1152  std::error_code EC;
1153  const bool PrintMsgOnly = false;
1154};
1155 
1156/// Create formatted StringError object.
1157template <typename... Ts>
1158Error createStringError(std::error_code EC, char const *Fmt,
1159                        const Ts &... Vals) {
1160  std::string Buffer;
1161  raw_string_ostream Stream(Buffer);
1162  Stream << format(Fmt, Vals...);
1163  return make_error<StringError>(Stream.str(), EC);
1164}
1165 
1166Error createStringError(std::error_code EC, char const *Msg);
1167 
1168/// This class wraps a filename and another Error.
1169///
1170/// In some cases, an error needs to live along a 'source' name, in order to
1171/// show more detailed information to the user.
1172class FileError final : public ErrorInfo<FileError> {
1173 
1174  friend Error createFileError(std::string, Error);
1175 
1176public:
1177  void log(raw_ostream &OS) const override {
1178    assert(Err && !FileName.empty() && "Trying to log after takeError().")((Err && !FileName.empty() && "Trying to log after takeError()."
) ? static_cast<void> (0) : __assert_fail ("Err && !FileName.empty() && \"Trying to log after takeError().\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1178, __PRETTY_FUNCTION__));
1179    OS << "'" << FileName << "': ";
1180    Err->log(OS);
1181  }
1182 
1183  Error takeError() { return Error(std::move(Err)); }
1184 
1185  std::error_code convertToErrorCode() const override;
1186 
1187  // Used by ErrorInfo::classID.
1188  static char ID;
1189 
1190private:
1191  FileError(std::string F, std::unique_ptr<ErrorInfoBase> E) {
1192    assert(E && "Cannot create FileError from Error success value.")((E && "Cannot create FileError from Error success value."
) ? static_cast<void> (0) : __assert_fail ("E && \"Cannot create FileError from Error success value.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1192, __PRETTY_FUNCTION__));
1193    assert(!F.empty() &&((!F.empty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.empty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1194, __PRETTY_FUNCTION__))
1194           "The file name provided to FileError must not be empty.")((!F.empty() && "The file name provided to FileError must not be empty."
) ? static_cast<void> (0) : __assert_fail ("!F.empty() && \"The file name provided to FileError must not be empty.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/include/llvm/Support/Error.h"
, 1194, __PRETTY_FUNCTION__));
1195    FileName = F;
1196    Err = std::move(E);
1197  }
1198 
1199  static Error build(std::string F, Error E) {
1200    return Error(std::unique_ptr<FileError>(new FileError(F, E.takePayload())));
1201  }
1202 
1203  std::string FileName;
1204  std::unique_ptr<ErrorInfoBase> Err;
1205};
1206 
1207/// Concatenate a source file path and/or name with an Error. The resulting
1208/// Error is unchecked.
1209inline Error createFileError(std::string F, Error E) {
1210  return FileError::build(F, std::move(E));
1211}
1212 
1213Error createFileError(std::string F, ErrorSuccess) = delete;
1214 
1215/// Helper for check-and-exit error handling.
1216///
1217/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1218///
1219class ExitOnError {
1220public:
1221  /// Create an error on exit helper.
1222  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1223      : Banner(std::move(Banner)),
1224        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1225 
1226  /// Set the banner string for any errors caught by operator().
1227  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1228 
1229  /// Set the exit-code mapper function.
1230  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1231    this->GetExitCode = std::move(GetExitCode);
1232  }
1233 
1234  /// Check Err. If it's in a failure state log the error(s) and exit.
1235  void operator()(Error Err) const { checkError(std::move(Err)); }
1236 
1237  /// Check E. If it's in a success state then return the contained value. If
1238  /// it's in a failure state log the error(s) and exit.
1239  template <typename T> T operator()(Expected<T> &&E) const {
1240    checkError(E.takeError());
1241    return std::move(*E);
1242  }
1243 
1244  /// Check E. If it's in a success state then return the contained reference. If
1245  /// it's in a failure state log the error(s) and exit.
1246  template <typename T> T& operator()(Expected<T&> &&E) const {
1247    checkError(E.takeError());
1248    return *E;
1249  }
1250 
1251private:
1252  void checkError(Error Err) const {
1253    if (Err) {
1254      int ExitCode = GetExitCode(Err);
1255      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1256      exit(ExitCode);
1257    }
1258  }
1259 
1260  std::string Banner;
1261  std::function<int(const Error &)> GetExitCode;
1262};
1263 
1264/// Conversion from Error to LLVMErrorRef for C error bindings.
1265inline LLVMErrorRef wrap(Error Err) {
1266  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1267}
1268 
1269/// Conversion from LLVMErrorRef to Error for C error bindings.
1270inline Error unwrap(LLVMErrorRef ErrRef) {
1271  return Error(std::unique_ptr<ErrorInfoBase>(
1272      reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1273}
1274 
1275} // end namespace llvm
1276 
1277#endif // LLVM_SUPPORT_ERROR_H