/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 CodeCoverage.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/llvm-cov -I /build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-cov -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/llvm-cov -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/llvm-cov/CodeCoverage.cpp -faddrsig

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

→

1//===- CodeCoverage.cpp - Coverage tool based on profiling instrumentation-===//
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// The 'CodeCoverageTool' class implements a command line tool to analyze and
11// report coverage information using the profiling instrumentation and code
12// coverage mapping.
13//
14//===----------------------------------------------------------------------===//

16#include "CoverageExporterJson.h"
17#include "CoverageFilters.h"
18#include "CoverageReport.h"
19#include "CoverageSummaryInfo.h"
20#include "CoverageViewOptions.h"
21#include "RenderingSupport.h"
22#include "SourceCoverageView.h"
23#include "llvm/ADT/SmallString.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/ADT/Triple.h"
26#include "llvm/ProfileData/Coverage/CoverageMapping.h"
27#include "llvm/ProfileData/InstrProfReader.h"
28#include "llvm/Support/CommandLine.h"
29#include "llvm/Support/FileSystem.h"
30#include "llvm/Support/Format.h"
31#include "llvm/Support/MemoryBuffer.h"
32#include "llvm/Support/Path.h"
33#include "llvm/Support/Process.h"
34#include "llvm/Support/Program.h"
35#include "llvm/Support/ScopedPrinter.h"
36#include "llvm/Support/ThreadPool.h"
37#include "llvm/Support/Threading.h"
38#include "llvm/Support/ToolOutputFile.h"

40#include <functional>
41#include <map>
42#include <system_error>

44using namespace llvm;
45using namespace coverage;

47void exportCoverageDataToJson(const coverage::CoverageMapping &CoverageMapping,
                            const CoverageViewOptions &Options,
                            raw_ostream &OS);

51namespace {
52/// The implementation of the coverage tool.
53class CodeCoverageTool {
54public:
enum Command {
  /// The show command.
  Show,
  /// The report command.
  Report,
  /// The export command.
  Export
};

int run(Command Cmd, int argc, const char **argv);

66private:
/// Print the error message to the error output stream.
void error(const Twine &Message, StringRef Whence = "");

/// Print the warning message to the error output stream.
void warning(const Twine &Message, StringRef Whence = "");

/// Convert \p Path into an absolute path and append it to the list
/// of collected paths.
void addCollectedPath(const std::string &Path);

/// If \p Path is a regular file, collect the path. If it's a
/// directory, recursively collect all of the paths within the directory.
void collectPaths(const std::string &Path);

/// Return a memory buffer for the given source file.
ErrorOr<const MemoryBuffer &> getSourceFile(StringRef SourceFile);

/// Create source views for the expansions of the view.
void attachExpansionSubViews(SourceCoverageView &View,
                             ArrayRef<ExpansionRecord> Expansions,
                             const CoverageMapping &Coverage);

/// Create the source view of a particular function.
std::unique_ptr<SourceCoverageView>
createFunctionView(const FunctionRecord &Function,
                   const CoverageMapping &Coverage);

/// Create the main source view of a particular source file.
std::unique_ptr<SourceCoverageView>
createSourceFileView(StringRef SourceFile, const CoverageMapping &Coverage);

/// Load the coverage mapping data. Return nullptr if an error occurred.
std::unique_ptr<CoverageMapping> load();

/// Create a mapping from files in the Coverage data to local copies
/// (path-equivalence).
void remapPathNames(const CoverageMapping &Coverage);

/// Remove input source files which aren't mapped by \p Coverage.
void removeUnmappedInputs(const CoverageMapping &Coverage);

/// If a demangler is available, demangle all symbol names.
void demangleSymbols(const CoverageMapping &Coverage);

/// Write out a source file view to the filesystem.
void writeSourceFileView(StringRef SourceFile, CoverageMapping *Coverage,
                         CoveragePrinter *Printer, bool ShowFilenames);

typedef llvm::function_ref<int(int, const char **)> CommandLineParserType;

int doShow(int argc, const char **argv,
           CommandLineParserType commandLineParser);

int doReport(int argc, const char **argv,
             CommandLineParserType commandLineParser);

int doExport(int argc, const char **argv,
             CommandLineParserType commandLineParser);

std::vector<StringRef> ObjectFilenames;
CoverageViewOptions ViewOpts;
CoverageFiltersMatchAll Filters;
CoverageFilters IgnoreFilenameFilters;

/// The path to the indexed profile.
std::string PGOFilename;

/// A list of input source files.
std::vector<std::string> SourceFiles;

/// In -path-equivalence mode, this maps the absolute paths from the coverage
/// mapping data to the input source files.
StringMap<std::string> RemappedFilenames;

/// The coverage data path to be remapped from, and the source path to be
/// remapped to, when using -path-equivalence.
Optional<std::pair<std::string, std::string>> PathRemapping;

/// The architecture the coverage mapping data targets.
std::vector<StringRef> CoverageArches;

/// A cache for demangled symbols.
DemangleCache DC;

/// A lock which guards printing to stderr.
std::mutex ErrsLock;

/// A container for input source file buffers.
std::mutex LoadedSourceFilesLock;
std::vector<std::pair<std::string, std::unique_ptr<MemoryBuffer>>>
    LoadedSourceFiles;

/// Whitelist from -name-whitelist to be used for filtering.
std::unique_ptr<SpecialCaseList> NameWhitelist;
161};
162}

164static std::string getErrorString(const Twine &Message, StringRef Whence,
                                bool Warning) {
std::string Str = (Warning ? "warning" : "error");
Str += ": ";
if (!Whence.empty())
  Str += Whence.str() + ": ";
Str += Message.str() + "\n";
return Str;
172}

174void CodeCoverageTool::error(const Twine &Message, StringRef Whence) {
std::unique_lock<std::mutex> Guard{ErrsLock};
ViewOpts.colored_ostream(errs(), raw_ostream::RED)
    << getErrorString(Message, Whence, false);
178}

180void CodeCoverageTool::warning(const Twine &Message, StringRef Whence) {
std::unique_lock<std::mutex> Guard{ErrsLock};
ViewOpts.colored_ostream(errs(), raw_ostream::RED)
    << getErrorString(Message, Whence, true);
184}

186void CodeCoverageTool::addCollectedPath(const std::string &Path) {
SmallString<128> EffectivePath(Path);
if (std::error_code EC = sys::fs::make_absolute(EffectivePath)) {
  error(EC.message(), Path);
  return;
}
sys::path::remove_dots(EffectivePath, /*remove_dot_dots=*/true);
if (!IgnoreFilenameFilters.matchesFilename(EffectivePath))
  SourceFiles.emplace_back(EffectivePath.str());
195}

197void CodeCoverageTool::collectPaths(const std::string &Path) {
llvm::sys::fs::file_status Status;
llvm::sys::fs::status(Path, Status);
if (!llvm::sys::fs::exists(Status)) {
  if (PathRemapping)
    addCollectedPath(Path);
  else
    warning("Source file doesn't exist, proceeded by ignoring it.", Path);
  return;
}

if (llvm::sys::fs::is_regular_file(Status)) {
  addCollectedPath(Path);
  return;
}

if (llvm::sys::fs::is_directory(Status)) {
  std::error_code EC;
  for (llvm::sys::fs::recursive_directory_iterator F(Path, EC), E;
       F != E; F.increment(EC)) {

    auto Status = F->status();
    if (!Status) {
      warning(Status.getError().message(), F->path());
      continue;
    }

    if (Status->type() == llvm::sys::fs::file_type::regular_file)
      addCollectedPath(F->path());
  }
}
228}

230ErrorOr<const MemoryBuffer &>
231CodeCoverageTool::getSourceFile(StringRef SourceFile) {
// If we've remapped filenames, look up the real location for this file.
std::unique_lock<std::mutex> Guard{LoadedSourceFilesLock};
if (!RemappedFilenames.empty()) {
  auto Loc = RemappedFilenames.find(SourceFile);
  if (Loc != RemappedFilenames.end())
    SourceFile = Loc->second;
}
for (const auto &Files : LoadedSourceFiles)
  if (sys::fs::equivalent(SourceFile, Files.first))
    return *Files.second;
auto Buffer = MemoryBuffer::getFile(SourceFile);
if (auto EC = Buffer.getError()) {
  error(EC.message(), SourceFile);
  return EC;
}
LoadedSourceFiles.emplace_back(SourceFile, std::move(Buffer.get()));
return *LoadedSourceFiles.back().second;
249}

251void CodeCoverageTool::attachExpansionSubViews(
  SourceCoverageView &View, ArrayRef<ExpansionRecord> Expansions,
  const CoverageMapping &Coverage) {
if (!ViewOpts.ShowExpandedRegions)
  return;
for (const auto &Expansion : Expansions) {
  auto ExpansionCoverage = Coverage.getCoverageForExpansion(Expansion);
  if (ExpansionCoverage.empty())
    continue;
  auto SourceBuffer = getSourceFile(ExpansionCoverage.getFilename());
  if (!SourceBuffer)
    continue;

  auto SubViewExpansions = ExpansionCoverage.getExpansions();
  auto SubView =
      SourceCoverageView::create(Expansion.Function.Name, SourceBuffer.get(),
                                 ViewOpts, std::move(ExpansionCoverage));
  attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
  View.addExpansion(Expansion.Region, std::move(SubView));
}
271}

273std::unique_ptr<SourceCoverageView>
274CodeCoverageTool::createFunctionView(const FunctionRecord &Function,
                                   const CoverageMapping &Coverage) {
auto FunctionCoverage = Coverage.getCoverageForFunction(Function);
if (FunctionCoverage.empty())
  return nullptr;
auto SourceBuffer = getSourceFile(FunctionCoverage.getFilename());
if (!SourceBuffer)
  return nullptr;

auto Expansions = FunctionCoverage.getExpansions();
auto View = SourceCoverageView::create(DC.demangle(Function.Name),
                                       SourceBuffer.get(), ViewOpts,
                                       std::move(FunctionCoverage));
attachExpansionSubViews(*View, Expansions, Coverage);

return View;
290}

292std::unique_ptr<SourceCoverageView>
293CodeCoverageTool::createSourceFileView(StringRef SourceFile,
                                     const CoverageMapping &Coverage) {
auto SourceBuffer = getSourceFile(SourceFile);
if (!SourceBuffer)
  return nullptr;
auto FileCoverage = Coverage.getCoverageForFile(SourceFile);
if (FileCoverage.empty())
  return nullptr;

auto Expansions = FileCoverage.getExpansions();
auto View = SourceCoverageView::create(SourceFile, SourceBuffer.get(),
                                       ViewOpts, std::move(FileCoverage));
attachExpansionSubViews(*View, Expansions, Coverage);
if (!ViewOpts.ShowFunctionInstantiations)
  return View;

for (const auto &Group : Coverage.getInstantiationGroups(SourceFile)) {
  // Skip functions which have a single instantiation.
  if (Group.size() < 2)
    continue;

  for (const FunctionRecord *Function : Group.getInstantiations()) {
    std::unique_ptr<SourceCoverageView> SubView{nullptr};

    StringRef Funcname = DC.demangle(Function->Name);

    if (Function->ExecutionCount > 0) {
      auto SubViewCoverage = Coverage.getCoverageForFunction(*Function);
      auto SubViewExpansions = SubViewCoverage.getExpansions();
      SubView = SourceCoverageView::create(
          Funcname, SourceBuffer.get(), ViewOpts, std::move(SubViewCoverage));
      attachExpansionSubViews(*SubView, SubViewExpansions, Coverage);
    }

    unsigned FileID = Function->CountedRegions.front().FileID;
    unsigned Line = 0;
    for (const auto &CR : Function->CountedRegions)
      if (CR.FileID == FileID)
        Line = std::max(CR.LineEnd, Line);
    View->addInstantiation(Funcname, Line, std::move(SubView));
  }
}
return View;
336}

338static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
sys::fs::file_status Status;
if (sys::fs::status(LHS, Status))
  return false;
auto LHSTime = Status.getLastModificationTime();
if (sys::fs::status(RHS, Status))
  return false;
auto RHSTime = Status.getLastModificationTime();
return LHSTime > RHSTime;
347}

349std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
for (StringRef ObjectFilename : ObjectFilenames)
  if (modifiedTimeGT(ObjectFilename, PGOFilename))
    warning("profile data may be out of date - object is newer",
            ObjectFilename);
auto CoverageOrErr =
    CoverageMapping::load(ObjectFilenames, PGOFilename, CoverageArches);
if (Error E = CoverageOrErr.takeError()) {
8
←
Taking true branch→
  error("Failed to load coverage: " + toString(std::move(E)),
9
←
Calling 'toString'→
        join(ObjectFilenames.begin(), ObjectFilenames.end(), ", "));
  return nullptr;
}
auto Coverage = std::move(CoverageOrErr.get());
unsigned Mismatched = Coverage->getMismatchedCount();
if (Mismatched) {
  warning(Twine(Mismatched) + " functions have mismatched data");

  if (ViewOpts.Debug) {
    for (const auto &HashMismatch : Coverage->getHashMismatches())
      errs() << "hash-mismatch: "
             << "No profile record found for '" << HashMismatch.first << "'"
             << " with hash = 0x" << Twine::utohexstr(HashMismatch.second)
             << '\n';
  }
}

remapPathNames(*Coverage);

if (!SourceFiles.empty())
  removeUnmappedInputs(*Coverage);

demangleSymbols(*Coverage);

return Coverage;
383}

385void CodeCoverageTool::remapPathNames(const CoverageMapping &Coverage) {
if (!PathRemapping)
  return;

// Convert remapping paths to native paths with trailing seperators.
auto nativeWithTrailing = [](StringRef Path) -> std::string {
  if (Path.empty())
    return "";
  SmallString<128> NativePath;
  sys::path::native(Path, NativePath);
  if (!sys::path::is_separator(NativePath.back()))
    NativePath += sys::path::get_separator();
  return NativePath.c_str();
};
std::string RemapFrom = nativeWithTrailing(PathRemapping->first);
std::string RemapTo = nativeWithTrailing(PathRemapping->second);

// Create a mapping from coverage data file paths to local paths.
for (StringRef Filename : Coverage.getUniqueSourceFiles()) {
  SmallString<128> NativeFilename;
  sys::path::native(Filename, NativeFilename);
  if (NativeFilename.startswith(RemapFrom)) {
    RemappedFilenames[Filename] =
        RemapTo + NativeFilename.substr(RemapFrom.size()).str();
  }
}

// Convert input files from local paths to coverage data file paths.
StringMap<std::string> InvRemappedFilenames;
for (const auto &RemappedFilename : RemappedFilenames)
  InvRemappedFilenames[RemappedFilename.getValue()] = RemappedFilename.getKey();

for (std::string &Filename : SourceFiles) {
  SmallString<128> NativeFilename;
  sys::path::native(Filename, NativeFilename);
  auto CovFileName = InvRemappedFilenames.find(NativeFilename);
  if (CovFileName != InvRemappedFilenames.end())
    Filename = CovFileName->second;
}
424}

426void CodeCoverageTool::removeUnmappedInputs(const CoverageMapping &Coverage) {
std::vector<StringRef> CoveredFiles = Coverage.getUniqueSourceFiles();

auto UncoveredFilesIt = SourceFiles.end();
// The user may have specified source files which aren't in the coverage
// mapping. Filter these files away.
UncoveredFilesIt = std::remove_if(
    SourceFiles.begin(), SourceFiles.end(), [&](const std::string &SF) {
      return !std::binary_search(CoveredFiles.begin(), CoveredFiles.end(),
                                 SF);
    });

SourceFiles.erase(UncoveredFilesIt, SourceFiles.end());
439}

441void CodeCoverageTool::demangleSymbols(const CoverageMapping &Coverage) {
if (!ViewOpts.hasDemangler())
  return;

// Pass function names to the demangler in a temporary file.
int InputFD;
SmallString<256> InputPath;
std::error_code EC =
    sys::fs::createTemporaryFile("demangle-in", "list", InputFD, InputPath);
if (EC) {
  error(InputPath, EC.message());
  return;
}
ToolOutputFile InputTOF{InputPath, InputFD};

unsigned NumSymbols = 0;
for (const auto &Function : Coverage.getCoveredFunctions()) {
  InputTOF.os() << Function.Name << '\n';
  ++NumSymbols;
}
InputTOF.os().close();

// Use another temporary file to store the demangler's output.
int OutputFD;
SmallString<256> OutputPath;
EC = sys::fs::createTemporaryFile("demangle-out", "list", OutputFD,
                                  OutputPath);
if (EC) {
  error(OutputPath, EC.message());
  return;
}
ToolOutputFile OutputTOF{OutputPath, OutputFD};
OutputTOF.os().close();

// Invoke the demangler.
std::vector<StringRef> ArgsV;
for (StringRef Arg : ViewOpts.DemanglerOpts)
  ArgsV.push_back(Arg);
Optional<StringRef> Redirects[] = {InputPath.str(), OutputPath.str(), {""}};
std::string ErrMsg;
int RC = sys::ExecuteAndWait(ViewOpts.DemanglerOpts[0], ArgsV,
                             /*env=*/None, Redirects, /*secondsToWait=*/0,
                             /*memoryLimit=*/0, &ErrMsg);
if (RC) {
  error(ErrMsg, ViewOpts.DemanglerOpts[0]);
  return;
}

// Parse the demangler's output.
auto BufOrError = MemoryBuffer::getFile(OutputPath);
if (!BufOrError) {
  error(OutputPath, BufOrError.getError().message());
  return;
}

std::unique_ptr<MemoryBuffer> DemanglerBuf = std::move(*BufOrError);

SmallVector<StringRef, 8> Symbols;
StringRef DemanglerData = DemanglerBuf->getBuffer();
DemanglerData.split(Symbols, '\n', /*MaxSplit=*/NumSymbols,
                    /*KeepEmpty=*/false);
if (Symbols.size() != NumSymbols) {
  error("Demangler did not provide expected number of symbols");
  return;
}

// Cache the demangled names.
unsigned I = 0;
for (const auto &Function : Coverage.getCoveredFunctions())
  // On Windows, lines in the demangler's output file end with "\r\n".
  // Splitting by '\n' keeps '\r's, so cut them now.
  DC.DemangledNames[Function.Name] = Symbols[I++].rtrim();
513}

515void CodeCoverageTool::writeSourceFileView(StringRef SourceFile,
                                         CoverageMapping *Coverage,
                                         CoveragePrinter *Printer,
                                         bool ShowFilenames) {
auto View = createSourceFileView(SourceFile, *Coverage);
if (!View) {
  warning("The file '" + SourceFile + "' isn't covered.");
  return;
}

auto OSOrErr = Printer->createViewFile(SourceFile, /*InToplevel=*/false);
if (Error E = OSOrErr.takeError()) {
  error("Could not create view file!", toString(std::move(E)));
  return;
}
auto OS = std::move(OSOrErr.get());

View->print(*OS.get(), /*Wholefile=*/true,
            /*ShowSourceName=*/ShowFilenames,
            /*ShowTitle=*/ViewOpts.hasOutputDirectory());
Printer->closeViewFile(std::move(OS));
536}

538int CodeCoverageTool::run(Command Cmd, int argc, const char **argv) {
cl::opt<std::string> CovFilename(
    cl::Positional, cl::desc("Covered executable or object file."));

cl::list<std::string> CovFilenames(
    "object", cl::desc("Coverage executable or object file"), cl::ZeroOrMore,
    cl::CommaSeparated);

cl::list<std::string> InputSourceFiles(
    cl::Positional, cl::desc("<Source files>"), cl::ZeroOrMore);

cl::opt<bool> DebugDumpCollectedPaths(
    "dump-collected-paths", cl::Optional, cl::Hidden,
    cl::desc("Show the collected paths to source files"));

cl::opt<std::string, true> PGOFilename(
    "instr-profile", cl::Required, cl::location(this->PGOFilename),
    cl::desc(
        "File with the profile data obtained after an instrumented run"));

cl::list<std::string> Arches(
    "arch", cl::desc("architectures of the coverage mapping binaries"));

cl::opt<bool> DebugDump("dump", cl::Optional,
                        cl::desc("Show internal debug dump"));

cl::opt<CoverageViewOptions::OutputFormat> Format(
    "format", cl::desc("Output format for line-based coverage reports"),
    cl::values(clEnumValN(CoverageViewOptions::OutputFormat::Text, "text",llvm::cl::OptionEnumValue { "text", int(CoverageViewOptions::
OutputFormat::Text), "Text output" }
                          "Text output")llvm::cl::OptionEnumValue { "text", int(CoverageViewOptions::
OutputFormat::Text), "Text output" },
               clEnumValN(CoverageViewOptions::OutputFormat::HTML, "html",llvm::cl::OptionEnumValue { "html", int(CoverageViewOptions::
OutputFormat::HTML), "HTML output" }
                          "HTML output")llvm::cl::OptionEnumValue { "html", int(CoverageViewOptions::
OutputFormat::HTML), "HTML output" }),
    cl::init(CoverageViewOptions::OutputFormat::Text));

cl::opt<std::string> PathRemap(
    "path-equivalence", cl::Optional,
    cl::desc("<from>,<to> Map coverage data paths to local source file "
             "paths"));

cl::OptionCategory FilteringCategory("Function filtering options");

cl::list<std::string> NameFilters(
    "name", cl::Optional,
    cl::desc("Show code coverage only for functions with the given name"),
    cl::ZeroOrMore, cl::cat(FilteringCategory));

cl::list<std::string> NameFilterFiles(
    "name-whitelist", cl::Optional,
    cl::desc("Show code coverage only for functions listed in the given "
             "file"),
    cl::ZeroOrMore, cl::cat(FilteringCategory));

cl::list<std::string> NameRegexFilters(
    "name-regex", cl::Optional,
    cl::desc("Show code coverage only for functions that match the given "
             "regular expression"),
    cl::ZeroOrMore, cl::cat(FilteringCategory));

cl::list<std::string> IgnoreFilenameRegexFilters(
    "ignore-filename-regex", cl::Optional,
    cl::desc("Skip source code files with file paths that match the given "
             "regular expression"),
    cl::ZeroOrMore, cl::cat(FilteringCategory));

cl::opt<double> RegionCoverageLtFilter(
    "region-coverage-lt", cl::Optional,
    cl::desc("Show code coverage only for functions with region coverage "
             "less than the given threshold"),
    cl::cat(FilteringCategory));

cl::opt<double> RegionCoverageGtFilter(
    "region-coverage-gt", cl::Optional,
    cl::desc("Show code coverage only for functions with region coverage "
             "greater than the given threshold"),
    cl::cat(FilteringCategory));

cl::opt<double> LineCoverageLtFilter(
    "line-coverage-lt", cl::Optional,
    cl::desc("Show code coverage only for functions with line coverage less "
             "than the given threshold"),
    cl::cat(FilteringCategory));

cl::opt<double> LineCoverageGtFilter(
    "line-coverage-gt", cl::Optional,
    cl::desc("Show code coverage only for functions with line coverage "
             "greater than the given threshold"),
    cl::cat(FilteringCategory));

cl::opt<cl::boolOrDefault> UseColor(
    "use-color", cl::desc("Emit colored output (default=autodetect)"),
    cl::init(cl::BOU_UNSET));

cl::list<std::string> DemanglerOpts(
    "Xdemangler", cl::desc("<demangler-path>|<demangler-option>"));

cl::opt<bool> RegionSummary(
    "show-region-summary", cl::Optional,
    cl::desc("Show region statistics in summary table"),
    cl::init(true));

cl::opt<bool> InstantiationSummary(
    "show-instantiation-summary", cl::Optional,
    cl::desc("Show instantiation statistics in summary table"));

cl::opt<bool> SummaryOnly(
    "summary-only", cl::Optional,
    cl::desc("Export only summary information for each source file"));

cl::opt<unsigned> NumThreads(
    "num-threads", cl::init(0),
    cl::desc("Number of merge threads to use (default: autodetect)"));
cl::alias NumThreadsA("j", cl::desc("Alias for --num-threads"),
                      cl::aliasopt(NumThreads));

auto commandLineParser = [&, this](int argc, const char **argv) -> int {
  cl::ParseCommandLineOptions(argc, argv, "LLVM code coverage tool\n");
  ViewOpts.Debug = DebugDump;

  if (!CovFilename.empty())
    ObjectFilenames.emplace_back(CovFilename);
  for (const std::string &Filename : CovFilenames)
    ObjectFilenames.emplace_back(Filename);
  if (ObjectFilenames.empty()) {
    errs() << "No filenames specified!\n";
    ::exit(1);
  }

  ViewOpts.Format = Format;
  switch (ViewOpts.Format) {
  case CoverageViewOptions::OutputFormat::Text:
    ViewOpts.Colors = UseColor == cl::BOU_UNSET
                          ? sys::Process::StandardOutHasColors()
                          : UseColor == cl::BOU_TRUE;
    break;
  case CoverageViewOptions::OutputFormat::HTML:
    if (UseColor == cl::BOU_FALSE)
      errs() << "Color output cannot be disabled when generating html.\n";
    ViewOpts.Colors = true;
    break;
  }

  // If path-equivalence was given and is a comma seperated pair then set
  // PathRemapping.
  auto EquivPair = StringRef(PathRemap).split(',');
  if (!(EquivPair.first.empty() && EquivPair.second.empty()))
    PathRemapping = EquivPair;

  // If a demangler is supplied, check if it exists and register it.
  if (DemanglerOpts.size()) {
    auto DemanglerPathOrErr = sys::findProgramByName(DemanglerOpts[0]);
    if (!DemanglerPathOrErr) {
      error("Could not find the demangler!",
            DemanglerPathOrErr.getError().message());
      return 1;
    }
    DemanglerOpts[0] = *DemanglerPathOrErr;
    ViewOpts.DemanglerOpts.swap(DemanglerOpts);
  }

  // Read in -name-whitelist files.
  if (!NameFilterFiles.empty()) {
    std::string SpecialCaseListErr;
    NameWhitelist =
        SpecialCaseList::create(NameFilterFiles, SpecialCaseListErr);
    if (!NameWhitelist)
      error(SpecialCaseListErr);
  }

  // Create the function filters
  if (!NameFilters.empty() || NameWhitelist || !NameRegexFilters.empty()) {
    auto NameFilterer = llvm::make_unique<CoverageFilters>();
    for (const auto &Name : NameFilters)
      NameFilterer->push_back(llvm::make_unique<NameCoverageFilter>(Name));
    if (NameWhitelist)
      NameFilterer->push_back(
          llvm::make_unique<NameWhitelistCoverageFilter>(*NameWhitelist));
    for (const auto &Regex : NameRegexFilters)
      NameFilterer->push_back(
          llvm::make_unique<NameRegexCoverageFilter>(Regex));
    Filters.push_back(std::move(NameFilterer));
  }

  if (RegionCoverageLtFilter.getNumOccurrences() ||
      RegionCoverageGtFilter.getNumOccurrences() ||
      LineCoverageLtFilter.getNumOccurrences() ||
      LineCoverageGtFilter.getNumOccurrences()) {
    auto StatFilterer = llvm::make_unique<CoverageFilters>();
    if (RegionCoverageLtFilter.getNumOccurrences())
      StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
          RegionCoverageFilter::LessThan, RegionCoverageLtFilter));
    if (RegionCoverageGtFilter.getNumOccurrences())
      StatFilterer->push_back(llvm::make_unique<RegionCoverageFilter>(
          RegionCoverageFilter::GreaterThan, RegionCoverageGtFilter));
    if (LineCoverageLtFilter.getNumOccurrences())
      StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
          LineCoverageFilter::LessThan, LineCoverageLtFilter));
    if (LineCoverageGtFilter.getNumOccurrences())
      StatFilterer->push_back(llvm::make_unique<LineCoverageFilter>(
          RegionCoverageFilter::GreaterThan, LineCoverageGtFilter));
    Filters.push_back(std::move(StatFilterer));
  }

  // Create the ignore filename filters.
  for (const auto &RE : IgnoreFilenameRegexFilters)
    IgnoreFilenameFilters.push_back(
        llvm::make_unique<NameRegexCoverageFilter>(RE));

  if (!Arches.empty()) {
    for (const std::string &Arch : Arches) {
      if (Triple(Arch).getArch() == llvm::Triple::ArchType::UnknownArch) {
        error("Unknown architecture: " + Arch);
        return 1;
      }
      CoverageArches.emplace_back(Arch);
    }
    if (CoverageArches.size() != ObjectFilenames.size()) {
      error("Number of architectures doesn't match the number of objects");
      return 1;
    }
  }

  // IgnoreFilenameFilters are applied even when InputSourceFiles specified.
  for (const std::string &File : InputSourceFiles)
    collectPaths(File);

  if (DebugDumpCollectedPaths) {
    for (const std::string &SF : SourceFiles)
      outs() << SF << '\n';
    ::exit(0);
  }

  ViewOpts.ShowRegionSummary = RegionSummary;
  ViewOpts.ShowInstantiationSummary = InstantiationSummary;
  ViewOpts.ExportSummaryOnly = SummaryOnly;
  ViewOpts.NumThreads = NumThreads;

  return 0;
};

switch (Cmd) {
2
←
Control jumps to 'case Export:'  at line 782→
case Show:
  return doShow(argc, argv, commandLineParser);
case Report:
  return doReport(argc, argv, commandLineParser);
case Export:
  return doExport(argc, argv, commandLineParser);
3
←
Calling 'CodeCoverageTool::doExport'→
}
return 0;
786}

788int CodeCoverageTool::doShow(int argc, const char **argv,
                           CommandLineParserType commandLineParser) {

cl::OptionCategory ViewCategory("Viewing options");

cl::opt<bool> ShowLineExecutionCounts(
    "show-line-counts", cl::Optional,
    cl::desc("Show the execution counts for each line"), cl::init(true),
    cl::cat(ViewCategory));

cl::opt<bool> ShowRegions(
    "show-regions", cl::Optional,
    cl::desc("Show the execution counts for each region"),
    cl::cat(ViewCategory));

cl::opt<bool> ShowBestLineRegionsCounts(
    "show-line-counts-or-regions", cl::Optional,
    cl::desc("Show the execution counts for each line, or the execution "
             "counts for each region on lines that have multiple regions"),
    cl::cat(ViewCategory));

cl::opt<bool> ShowExpansions("show-expansions", cl::Optional,
                             cl::desc("Show expanded source regions"),
                             cl::cat(ViewCategory));

cl::opt<bool> ShowInstantiations("show-instantiations", cl::Optional,
                                 cl::desc("Show function instantiations"),
                                 cl::init(true), cl::cat(ViewCategory));

cl::opt<std::string> ShowOutputDirectory(
    "output-dir", cl::init(""),
    cl::desc("Directory in which coverage information is written out"));
cl::alias ShowOutputDirectoryA("o", cl::desc("Alias for --output-dir"),
                               cl::aliasopt(ShowOutputDirectory));

cl::opt<uint32_t> TabSize(
    "tab-size", cl::init(2),
    cl::desc(
        "Set tab expansion size for html coverage reports (default = 2)"));

cl::opt<std::string> ProjectTitle(
    "project-title", cl::Optional,
    cl::desc("Set project title for the coverage report"));

auto Err = commandLineParser(argc, argv);
if (Err)
  return Err;

ViewOpts.ShowLineNumbers = true;
ViewOpts.ShowLineStats = ShowLineExecutionCounts.getNumOccurrences() != 0 ||
                         !ShowRegions || ShowBestLineRegionsCounts;
ViewOpts.ShowRegionMarkers = ShowRegions || ShowBestLineRegionsCounts;
ViewOpts.ShowExpandedRegions = ShowExpansions;
ViewOpts.ShowFunctionInstantiations = ShowInstantiations;
ViewOpts.ShowOutputDirectory = ShowOutputDirectory;
ViewOpts.TabSize = TabSize;
ViewOpts.ProjectTitle = ProjectTitle;

if (ViewOpts.hasOutputDirectory()) {
  if (auto E = sys::fs::create_directories(ViewOpts.ShowOutputDirectory)) {
    error("Could not create output directory!", E.message());
    return 1;
  }
}

sys::fs::file_status Status;
if (sys::fs::status(PGOFilename, Status)) {
  error("profdata file error: can not get the file status. \n");
  return 1;
}

auto ModifiedTime = Status.getLastModificationTime();
std::string ModifiedTimeStr = to_string(ModifiedTime);
size_t found = ModifiedTimeStr.rfind(':');
ViewOpts.CreatedTimeStr = (found != std::string::npos)
                              ? "Created: " + ModifiedTimeStr.substr(0, found)
                              : "Created: " + ModifiedTimeStr;

auto Coverage = load();
if (!Coverage)
  return 1;

auto Printer = CoveragePrinter::create(ViewOpts);

if (SourceFiles.empty())
  // Get the source files from the function coverage mapping.
  for (StringRef Filename : Coverage->getUniqueSourceFiles()) {
    if (!IgnoreFilenameFilters.matchesFilename(Filename))
      SourceFiles.push_back(Filename);
  }

// Create an index out of the source files.
if (ViewOpts.hasOutputDirectory()) {
  if (Error E = Printer->createIndexFile(SourceFiles, *Coverage, Filters)) {
    error("Could not create index file!", toString(std::move(E)));
    return 1;
  }
}

if (!Filters.empty()) {
  // Build the map of filenames to functions.
  std::map<llvm::StringRef, std::vector<const FunctionRecord *>>
      FilenameFunctionMap;
  for (const auto &SourceFile : SourceFiles)
    for (const auto &Function : Coverage->getCoveredFunctions(SourceFile))
      if (Filters.matches(*Coverage.get(), Function))
        FilenameFunctionMap[SourceFile].push_back(&Function);

  // Only print filter matching functions for each file.
  for (const auto &FileFunc : FilenameFunctionMap) {
    StringRef File = FileFunc.first;
    const auto &Functions = FileFunc.second;

    auto OSOrErr = Printer->createViewFile(File, /*InToplevel=*/false);
    if (Error E = OSOrErr.takeError()) {
      error("Could not create view file!", toString(std::move(E)));
      return 1;
    }
    auto OS = std::move(OSOrErr.get());

    bool ShowTitle = ViewOpts.hasOutputDirectory();
    for (const auto *Function : Functions) {
      auto FunctionView = createFunctionView(*Function, *Coverage);
      if (!FunctionView) {
        warning("Could not read coverage for '" + Function->Name + "'.");
        continue;
      }
      FunctionView->print(*OS.get(), /*WholeFile=*/false,
                          /*ShowSourceName=*/true, ShowTitle);
      ShowTitle = false;
    }

    Printer->closeViewFile(std::move(OS));
  }
  return 0;
}

// Show files
bool ShowFilenames =
    (SourceFiles.size() != 1) || ViewOpts.hasOutputDirectory() ||
    (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML);

auto NumThreads = ViewOpts.NumThreads;

// If NumThreads is not specified, auto-detect a good default.
if (NumThreads == 0)
  NumThreads =
      std::max(1U, std::min(llvm::heavyweight_hardware_concurrency(),
                            unsigned(SourceFiles.size())));

if (!ViewOpts.hasOutputDirectory() || NumThreads == 1) {
  for (const std::string &SourceFile : SourceFiles)
    writeSourceFileView(SourceFile, Coverage.get(), Printer.get(),
                        ShowFilenames);
} else {
  // In -output-dir mode, it's safe to use multiple threads to print files.
  ThreadPool Pool(NumThreads);
  for (const std::string &SourceFile : SourceFiles)
    Pool.async(&CodeCoverageTool::writeSourceFileView, this, SourceFile,
               Coverage.get(), Printer.get(), ShowFilenames);
  Pool.wait();
}

return 0;
952}

954int CodeCoverageTool::doReport(int argc, const char **argv,
                             CommandLineParserType commandLineParser) {
cl::opt<bool> ShowFunctionSummaries(
    "show-functions", cl::Optional, cl::init(false),
    cl::desc("Show coverage summaries for each function"));

auto Err = commandLineParser(argc, argv);
if (Err)
  return Err;

if (ViewOpts.Format == CoverageViewOptions::OutputFormat::HTML) {
  error("HTML output for summary reports is not yet supported.");
  return 1;
}

auto Coverage = load();
if (!Coverage)
  return 1;

CoverageReport Report(ViewOpts, *Coverage.get());
if (!ShowFunctionSummaries) {
  if (SourceFiles.empty())
    Report.renderFileReports(llvm::outs(), IgnoreFilenameFilters);
  else
    Report.renderFileReports(llvm::outs(), SourceFiles);
} else {
  if (SourceFiles.empty()) {
    error("Source files must be specified when -show-functions=true is "
          "specified");
    return 1;
  }

  Report.renderFunctionReports(SourceFiles, DC, llvm::outs());
}
return 0;
989}

991int CodeCoverageTool::doExport(int argc, const char **argv,
                             CommandLineParserType commandLineParser) {

auto Err = commandLineParser(argc, argv);
if (Err)
4
←
Taking false branch→
  return Err;

if (ViewOpts.Format != CoverageViewOptions::OutputFormat::Text) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
  error("Coverage data can only be exported as textual JSON.");
  return 1;
}

auto Coverage = load();
7
←
Calling 'CodeCoverageTool::load'→
if (!Coverage) {
  error("Could not load coverage information");
  return 1;
}

auto Exporter = CoverageExporterJson(*Coverage.get(), ViewOpts, outs());

if (SourceFiles.empty())
  Exporter.renderRoot(IgnoreFilenameFilters);
else
  Exporter.renderRoot(SourceFiles);

return 0;
1017}

1019int showMain(int argc, const char *argv[]) {
CodeCoverageTool Tool;
return Tool.run(CodeCoverageTool::Show, argc, argv);
1022}

1024int reportMain(int argc, const char *argv[]) {
CodeCoverageTool Tool;
return Tool.run(CodeCoverageTool::Report, argc, argv);
1027}

1029int exportMain(int argc, const char *argv[]) {
CodeCoverageTool Tool;
return Tool.run(CodeCoverageTool::Export, argc, argv);
1
Calling 'CodeCoverageTool::run'→
1032}

←

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