/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/llvm/tools/llvm-profdata/llvm-profdata.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/llvm/tools/llvm-profdata/llvm-profdata.cpp
Warning:	line 95, column 26 Moved-from object 'E' is moved

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name llvm-profdata.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 -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/llvm-profdata -I /build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/llvm/tools/llvm-profdata -I include -I /build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-02-14-124508-141753-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/llvm/tools/llvm-profdata/llvm-profdata.cpp

/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/llvm/tools/llvm-profdata/llvm-profdata.cpp

→

1//===- llvm-profdata.cpp - LLVM profile data tool -------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// llvm-profdata merges .profdata files.
10//
11//===----------------------------------------------------------------------===//

13#include "llvm/ADT/SmallSet.h"
14#include "llvm/ADT/SmallVector.h"
15#include "llvm/ADT/StringRef.h"
16#include "llvm/DebugInfo/DWARF/DWARFContext.h"
17#include "llvm/IR/LLVMContext.h"
18#include "llvm/Object/Binary.h"
19#include "llvm/ProfileData/InstrProfCorrelator.h"
20#include "llvm/ProfileData/InstrProfReader.h"
21#include "llvm/ProfileData/InstrProfWriter.h"
22#include "llvm/ProfileData/MemProf.h"
23#include "llvm/ProfileData/ProfileCommon.h"
24#include "llvm/ProfileData/RawMemProfReader.h"
25#include "llvm/ProfileData/SampleProfReader.h"
26#include "llvm/ProfileData/SampleProfWriter.h"
27#include "llvm/Support/CommandLine.h"
28#include "llvm/Support/Discriminator.h"
29#include "llvm/Support/Errc.h"
30#include "llvm/Support/FileSystem.h"
31#include "llvm/Support/Format.h"
32#include "llvm/Support/FormattedStream.h"
33#include "llvm/Support/InitLLVM.h"
34#include "llvm/Support/MemoryBuffer.h"
35#include "llvm/Support/Path.h"
36#include "llvm/Support/ThreadPool.h"
37#include "llvm/Support/Threading.h"
38#include "llvm/Support/WithColor.h"
39#include "llvm/Support/raw_ostream.h"
40#include <algorithm>

42using namespace llvm;

44enum ProfileFormat {
PF_None = 0,
PF_Text,
PF_Compact_Binary,
PF_Ext_Binary,
PF_GCC,
PF_Binary
51};

53static void warn(Twine Message, std::string Whence = "",
               std::string Hint = "") {
WithColor::warning();
if (!Whence.empty())
  errs() << Whence << ": ";
errs() << Message << "\n";
if (!Hint.empty())
  WithColor::note() << Hint << "\n";
61}

63static void warn(Error E, StringRef Whence = "") {
if (E.isA<InstrProfError>()) {
  handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
    warn(IPE.message(), std::string(Whence), std::string(""));
  });
}
69}

71static void exitWithError(Twine Message, std::string Whence = "",
                        std::string Hint = "") {
WithColor::error();
if (!Whence.empty())
  errs() << Whence << ": ";
errs() << Message << "\n";
if (!Hint.empty())
  WithColor::note() << Hint << "\n";
::exit(1);
80}

82static void exitWithError(Error E, StringRef Whence = "") {
if (E.isA<InstrProfError>()) {
5
←
Assuming the condition is true→
6
←
Taking true branch→
  handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
7
←
Calling move constructor for 'Error'→
9
←
Returning from move constructor for 'Error'→
    instrprof_error instrError = IPE.get();
    StringRef Hint = "";
    if (instrError == instrprof_error::unrecognized_format) {
      // Hint in case user missed specifying the profile type.
      Hint = "Perhaps you forgot to use the --sample or --memory option?";
    }
    exitWithError(IPE.message(), std::string(Whence), std::string(Hint));
  });
}

exitWithError(toString(std::move(E)), std::string(Whence));
10
←
Moved-from object 'E' is moved
96}

98static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
exitWithError(EC.message(), std::string(Whence));
100}

102namespace {
103enum ProfileKinds { instr, sample, memory };
104enum FailureMode { failIfAnyAreInvalid, failIfAllAreInvalid };
105}

107static void warnOrExitGivenError(FailureMode FailMode, std::error_code EC,
                               StringRef Whence = "") {
if (FailMode == failIfAnyAreInvalid)
  exitWithErrorCode(EC, Whence);
else
  warn(EC.message(), std::string(Whence));
113}

115static void handleMergeWriterError(Error E, StringRef WhenceFile = "",
                                 StringRef WhenceFunction = "",
                                 bool ShowHint = true) {
if (!WhenceFile.empty())
  errs() << WhenceFile << ": ";
if (!WhenceFunction.empty())
  errs() << WhenceFunction << ": ";

auto IPE = instrprof_error::success;
E = handleErrors(std::move(E),
                 [&IPE](std::unique_ptr<InstrProfError> E) -> Error {
                   IPE = E->get();
                   return Error(std::move(E));
                 });
errs() << toString(std::move(E)) << "\n";

if (ShowHint) {
  StringRef Hint = "";
  if (IPE != instrprof_error::success) {
    switch (IPE) {
    case instrprof_error::hash_mismatch:
    case instrprof_error::count_mismatch:
    case instrprof_error::value_site_count_mismatch:
      Hint = "Make sure that all profile data to be merged is generated "
             "from the same binary.";
      break;
    default:
      break;
    }
  }

  if (!Hint.empty())
    errs() << Hint << "\n";
}
149}

151namespace {
152/// A remapper from original symbol names to new symbol names based on a file
153/// containing a list of mappings from old name to new name.
154class SymbolRemapper {
std::unique_ptr<MemoryBuffer> File;
DenseMap<StringRef, StringRef> RemappingTable;

158public:
/// Build a SymbolRemapper from a file containing a list of old/new symbols.
static std::unique_ptr<SymbolRemapper> create(StringRef InputFile) {
  auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
  if (!BufOrError)
    exitWithErrorCode(BufOrError.getError(), InputFile);

  auto Remapper = std::make_unique<SymbolRemapper>();
  Remapper->File = std::move(BufOrError.get());

  for (line_iterator LineIt(*Remapper->File, /*SkipBlanks=*/true, '#');
       !LineIt.is_at_eof(); ++LineIt) {
    std::pair<StringRef, StringRef> Parts = LineIt->split(' ');
    if (Parts.first.empty() || Parts.second.empty() ||
        Parts.second.count(' ')) {
      exitWithError("unexpected line in remapping file",
                    (InputFile + ":" + Twine(LineIt.line_number())).str(),
                    "expected 'old_symbol new_symbol'");
    }
    Remapper->RemappingTable.insert(Parts);
  }
  return Remapper;
}

/// Attempt to map the given old symbol into a new symbol.
///
/// \return The new symbol, or \p Name if no such symbol was found.
StringRef operator()(StringRef Name) {
  StringRef New = RemappingTable.lookup(Name);
  return New.empty() ? Name : New;
}
189};
190}

192struct WeightedFile {
std::string Filename;
uint64_t Weight;
195};
196typedef SmallVector<WeightedFile, 5> WeightedFileVector;

198/// Keep track of merged data and reported errors.
199struct WriterContext {
std::mutex Lock;
InstrProfWriter Writer;
std::vector<std::pair<Error, std::string>> Errors;
std::mutex &ErrLock;
SmallSet<instrprof_error, 4> &WriterErrorCodes;

WriterContext(bool IsSparse, std::mutex &ErrLock,
              SmallSet<instrprof_error, 4> &WriterErrorCodes)
    : Writer(IsSparse), ErrLock(ErrLock), WriterErrorCodes(WriterErrorCodes) {
}
210};

212/// Computer the overlap b/w profile BaseFilename and TestFileName,
213/// and store the program level result to Overlap.
214static void overlapInput(const std::string &BaseFilename,
                       const std::string &TestFilename, WriterContext *WC,
                       OverlapStats &Overlap,
                       const OverlapFuncFilters &FuncFilter,
                       raw_fd_ostream &OS, bool IsCS) {
auto ReaderOrErr = InstrProfReader::create(TestFilename);
if (Error E = ReaderOrErr.takeError()) {
  // Skip the empty profiles by returning sliently.
  instrprof_error IPE = InstrProfError::take(std::move(E));
  if (IPE != instrprof_error::empty_raw_profile)
    WC->Errors.emplace_back(make_error<InstrProfError>(IPE), TestFilename);
  return;
}

auto Reader = std::move(ReaderOrErr.get());
for (auto &I : *Reader) {
  OverlapStats FuncOverlap(OverlapStats::FunctionLevel);
  FuncOverlap.setFuncInfo(I.Name, I.Hash);

  WC->Writer.overlapRecord(std::move(I), Overlap, FuncOverlap, FuncFilter);
  FuncOverlap.dump(OS);
}
236}

238/// Load an input into a writer context.
239static void loadInput(const WeightedFile &Input, SymbolRemapper *Remapper,
                    const InstrProfCorrelator *Correlator,
                    WriterContext *WC) {
std::unique_lock<std::mutex> CtxGuard{WC->Lock};

// Copy the filename, because llvm::ThreadPool copied the input "const
// WeightedFile &" by value, making a reference to the filename within it
// invalid outside of this packaged task.
std::string Filename = Input.Filename;

auto ReaderOrErr = InstrProfReader::create(Input.Filename, Correlator);
if (Error E = ReaderOrErr.takeError()) {
  // Skip the empty profiles by returning sliently.
  instrprof_error IPE = InstrProfError::take(std::move(E));
  if (IPE != instrprof_error::empty_raw_profile)
    WC->Errors.emplace_back(make_error<InstrProfError>(IPE), Filename);
  return;
}

auto Reader = std::move(ReaderOrErr.get());
if (Error E = WC->Writer.mergeProfileKind(Reader->getProfileKind())) {
  consumeError(std::move(E));
  WC->Errors.emplace_back(
      make_error<StringError>(
          "Merge IR generated profile with Clang generated profile.",
          std::error_code()),
      Filename);
  return;
}

for (auto &I : *Reader) {
  if (Remapper)
    I.Name = (*Remapper)(I.Name);
  const StringRef FuncName = I.Name;
  bool Reported = false;
  WC->Writer.addRecord(std::move(I), Input.Weight, [&](Error E) {
    if (Reported) {
      consumeError(std::move(E));
      return;
    }
    Reported = true;
    // Only show hint the first time an error occurs.
    instrprof_error IPE = InstrProfError::take(std::move(E));
    std::unique_lock<std::mutex> ErrGuard{WC->ErrLock};
    bool firstTime = WC->WriterErrorCodes.insert(IPE).second;
    handleMergeWriterError(make_error<InstrProfError>(IPE), Input.Filename,
                           FuncName, firstTime);
  });
}
if (Reader->hasError())
  if (Error E = Reader->getError())
    WC->Errors.emplace_back(std::move(E), Filename);
291}

293/// Merge the \p Src writer context into \p Dst.
294static void mergeWriterContexts(WriterContext *Dst, WriterContext *Src) {
for (auto &ErrorPair : Src->Errors)
  Dst->Errors.push_back(std::move(ErrorPair));
Src->Errors.clear();

Dst->Writer.mergeRecordsFromWriter(std::move(Src->Writer), [&](Error E) {
  instrprof_error IPE = InstrProfError::take(std::move(E));
  std::unique_lock<std::mutex> ErrGuard{Dst->ErrLock};
  bool firstTime = Dst->WriterErrorCodes.insert(IPE).second;
  if (firstTime)
    warn(toString(make_error<InstrProfError>(IPE)));
});
306}

308static void writeInstrProfile(StringRef OutputFilename,
                            ProfileFormat OutputFormat,
                            InstrProfWriter &Writer) {
std::error_code EC;
raw_fd_ostream Output(OutputFilename.data(), EC,
                      OutputFormat == PF_Text ? sys::fs::OF_TextWithCRLF
                                              : sys::fs::OF_None);
if (EC)
  exitWithErrorCode(EC, OutputFilename);

if (OutputFormat == PF_Text) {
  if (Error E = Writer.writeText(Output))
    warn(std::move(E));
} else {
  if (Output.is_displayed())
    exitWithError("cannot write a non-text format profile to the terminal");
  if (Error E = Writer.write(Output))
    warn(std::move(E));
}
327}

329static void mergeInstrProfile(const WeightedFileVector &Inputs,
                            StringRef DebugInfoFilename,
                            SymbolRemapper *Remapper,
                            StringRef OutputFilename,
                            ProfileFormat OutputFormat, bool OutputSparse,
                            unsigned NumThreads, FailureMode FailMode) {
if (OutputFormat != PF_Binary && OutputFormat != PF_Compact_Binary &&
    OutputFormat != PF_Ext_Binary && OutputFormat != PF_Text)
  exitWithError("unknown format is specified");

std::unique_ptr<InstrProfCorrelator> Correlator;
if (!DebugInfoFilename.empty()) {
  if (auto Err =
          InstrProfCorrelator::get(DebugInfoFilename).moveInto(Correlator))
    exitWithError(std::move(Err), DebugInfoFilename);
  if (auto Err = Correlator->correlateProfileData())
    exitWithError(std::move(Err), DebugInfoFilename);
}

std::mutex ErrorLock;
SmallSet<instrprof_error, 4> WriterErrorCodes;

// If NumThreads is not specified, auto-detect a good default.
if (NumThreads == 0)
  NumThreads = std::min(hardware_concurrency().compute_thread_count(),
                        unsigned((Inputs.size() + 1) / 2));
// FIXME: There's a bug here, where setting NumThreads = Inputs.size() fails
// the merge_empty_profile.test because the InstrProfWriter.ProfileKind isn't
// merged, thus the emitted file ends up with a PF_Unknown kind.

// Initialize the writer contexts.
SmallVector<std::unique_ptr<WriterContext>, 4> Contexts;
for (unsigned I = 0; I < NumThreads; ++I)
  Contexts.emplace_back(std::make_unique<WriterContext>(
      OutputSparse, ErrorLock, WriterErrorCodes));

if (NumThreads == 1) {
  for (const auto &Input : Inputs)
    loadInput(Input, Remapper, Correlator.get(), Contexts[0].get());
} else {
  ThreadPool Pool(hardware_concurrency(NumThreads));

  // Load the inputs in parallel (N/NumThreads serial steps).
  unsigned Ctx = 0;
  for (const auto &Input : Inputs) {
    Pool.async(loadInput, Input, Remapper, Correlator.get(),
               Contexts[Ctx].get());
    Ctx = (Ctx + 1) % NumThreads;
  }
  Pool.wait();

  // Merge the writer contexts together (~ lg(NumThreads) serial steps).
  unsigned Mid = Contexts.size() / 2;
  unsigned End = Contexts.size();
  assert(Mid > 0 && "Expected more than one context")(static_cast <bool> (Mid > 0 && "Expected more than one context"
) ? void (0) : __assert_fail ("Mid > 0 && \"Expected more than one context\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 383, __extension__
 __PRETTY_FUNCTION__));
  do {
    for (unsigned I = 0; I < Mid; ++I)
      Pool.async(mergeWriterContexts, Contexts[I].get(),
                 Contexts[I + Mid].get());
    Pool.wait();
    if (End & 1) {
      Pool.async(mergeWriterContexts, Contexts[0].get(),
                 Contexts[End - 1].get());
      Pool.wait();
    }
    End = Mid;
    Mid /= 2;
  } while (Mid > 0);
}

// Handle deferred errors encountered during merging. If the number of errors
// is equal to the number of inputs the merge failed.
unsigned NumErrors = 0;
for (std::unique_ptr<WriterContext> &WC : Contexts) {
  for (auto &ErrorPair : WC->Errors) {
    ++NumErrors;
    warn(toString(std::move(ErrorPair.first)), ErrorPair.second);
  }
}
if (NumErrors == Inputs.size() ||
    (NumErrors > 0 && FailMode == failIfAnyAreInvalid))
  exitWithError("no profile can be merged");

writeInstrProfile(OutputFilename, OutputFormat, Contexts[0]->Writer);
413}

415/// The profile entry for a function in instrumentation profile.
416struct InstrProfileEntry {
uint64_t MaxCount = 0;
float ZeroCounterRatio = 0.0;
InstrProfRecord *ProfRecord;
InstrProfileEntry(InstrProfRecord *Record);
InstrProfileEntry() = default;
422};

424InstrProfileEntry::InstrProfileEntry(InstrProfRecord *Record) {
ProfRecord = Record;
uint64_t CntNum = Record->Counts.size();
uint64_t ZeroCntNum = 0;
for (size_t I = 0; I < CntNum; ++I) {
  MaxCount = std::max(MaxCount, Record->Counts[I]);
  ZeroCntNum += !Record->Counts[I];
}
ZeroCounterRatio = (float)ZeroCntNum / CntNum;
433}

435/// Either set all the counters in the instr profile entry \p IFE to -1
436/// in order to drop the profile or scale up the counters in \p IFP to
437/// be above hot threshold. We use the ratio of zero counters in the
438/// profile of a function to decide the profile is helpful or harmful
439/// for performance, and to choose whether to scale up or drop it.
440static void updateInstrProfileEntry(InstrProfileEntry &IFE,
                                  uint64_t HotInstrThreshold,
                                  float ZeroCounterThreshold) {
InstrProfRecord *ProfRecord = IFE.ProfRecord;
if (!IFE.MaxCount || IFE.ZeroCounterRatio > ZeroCounterThreshold) {
  // If all or most of the counters of the function are zero, the
  // profile is unaccountable and shuld be dropped. Reset all the
  // counters to be -1 and PGO profile-use will drop the profile.
  // All counters being -1 also implies that the function is hot so
  // PGO profile-use will also set the entry count metadata to be
  // above hot threshold.
  for (size_t I = 0; I < ProfRecord->Counts.size(); ++I)
    ProfRecord->Counts[I] = -1;
  return;
}

// Scale up the MaxCount to be multiple times above hot threshold.
const unsigned MultiplyFactor = 3;
uint64_t Numerator = HotInstrThreshold * MultiplyFactor;
uint64_t Denominator = IFE.MaxCount;
ProfRecord->scale(Numerator, Denominator, [&](instrprof_error E) {
  warn(toString(make_error<InstrProfError>(E)));
});
463}

465const uint64_t ColdPercentileIdx = 15;
466const uint64_t HotPercentileIdx = 11;

468using sampleprof::FSDiscriminatorPass;

470// Internal options to set FSDiscriminatorPass. Used in merge and show
471// commands.
472static cl::opt<FSDiscriminatorPass> FSDiscriminatorPassOption(
  "fs-discriminator-pass", cl::init(PassLast), cl::Hidden,
  cl::desc("Zero out the discriminator bits for the FS discrimiantor "
           "pass beyond this value. The enum values are defined in "
           "Support/Discriminator.h"),
  cl::values(clEnumVal(Base, "Use base discriminators only")llvm::cl::OptionEnumValue { "Base", int(Base), "Use base discriminators only"
 },
             clEnumVal(Pass1, "Use base and pass 1 discriminators")llvm::cl::OptionEnumValue { "Pass1", int(Pass1), "Use base and pass 1 discriminators"
 },
             clEnumVal(Pass2, "Use base and pass 1-2 discriminators")llvm::cl::OptionEnumValue { "Pass2", int(Pass2), "Use base and pass 1-2 discriminators"
 },
             clEnumVal(Pass3, "Use base and pass 1-3 discriminators")llvm::cl::OptionEnumValue { "Pass3", int(Pass3), "Use base and pass 1-3 discriminators"
 },
             clEnumVal(PassLast, "Use all discriminator bits (default)")llvm::cl::OptionEnumValue { "PassLast", int(PassLast), "Use all discriminator bits (default)"
 }));

483static unsigned getDiscriminatorMask() {
return getN1Bits(getFSPassBitEnd(FSDiscriminatorPassOption.getValue()));
485}

487/// Adjust the instr profile in \p WC based on the sample profile in
488/// \p Reader.
489static void
490adjustInstrProfile(std::unique_ptr<WriterContext> &WC,
                 std::unique_ptr<sampleprof::SampleProfileReader> &Reader,
                 unsigned SupplMinSizeThreshold, float ZeroCounterThreshold,
                 unsigned InstrProfColdThreshold) {
// Function to its entry in instr profile.
StringMap<InstrProfileEntry> InstrProfileMap;
InstrProfSummaryBuilder IPBuilder(ProfileSummaryBuilder::DefaultCutoffs);
for (auto &PD : WC->Writer.getProfileData()) {
  // Populate IPBuilder.
  for (const auto &PDV : PD.getValue()) {
    InstrProfRecord Record = PDV.second;
    IPBuilder.addRecord(Record);
  }

  // If a function has multiple entries in instr profile, skip it.
  if (PD.getValue().size() != 1)
    continue;

  // Initialize InstrProfileMap.
  InstrProfRecord *R = &PD.getValue().begin()->second;
  InstrProfileMap[PD.getKey()] = InstrProfileEntry(R);
}

ProfileSummary InstrPS = *IPBuilder.getSummary();
ProfileSummary SamplePS = Reader->getSummary();

// Compute cold thresholds for instr profile and sample profile.
uint64_t ColdSampleThreshold =
    ProfileSummaryBuilder::getEntryForPercentile(
        SamplePS.getDetailedSummary(),
        ProfileSummaryBuilder::DefaultCutoffs[ColdPercentileIdx])
        .MinCount;
uint64_t HotInstrThreshold =
    ProfileSummaryBuilder::getEntryForPercentile(
        InstrPS.getDetailedSummary(),
        ProfileSummaryBuilder::DefaultCutoffs[HotPercentileIdx])
        .MinCount;
uint64_t ColdInstrThreshold =
    InstrProfColdThreshold
        ? InstrProfColdThreshold
        : ProfileSummaryBuilder::getEntryForPercentile(
              InstrPS.getDetailedSummary(),
              ProfileSummaryBuilder::DefaultCutoffs[ColdPercentileIdx])
              .MinCount;

// Find hot/warm functions in sample profile which is cold in instr profile
// and adjust the profiles of those functions in the instr profile.
for (const auto &PD : Reader->getProfiles()) {
  auto &FContext = PD.first;
  const sampleprof::FunctionSamples &FS = PD.second;
  auto It = InstrProfileMap.find(FContext.toString());
  if (FS.getHeadSamples() > ColdSampleThreshold &&
      It != InstrProfileMap.end() &&
      It->second.MaxCount <= ColdInstrThreshold &&
      FS.getBodySamples().size() >= SupplMinSizeThreshold) {
    updateInstrProfileEntry(It->second, HotInstrThreshold,
                            ZeroCounterThreshold);
  }
}
549}

551/// The main function to supplement instr profile with sample profile.
552/// \Inputs contains the instr profile. \p SampleFilename specifies the
553/// sample profile. \p OutputFilename specifies the output profile name.
554/// \p OutputFormat specifies the output profile format. \p OutputSparse
555/// specifies whether to generate sparse profile. \p SupplMinSizeThreshold
556/// specifies the minimal size for the functions whose profile will be
557/// adjusted. \p ZeroCounterThreshold is the threshold to check whether
558/// a function contains too many zero counters and whether its profile
559/// should be dropped. \p InstrProfColdThreshold is the user specified
560/// cold threshold which will override the cold threshold got from the
561/// instr profile summary.
562static void supplementInstrProfile(
  const WeightedFileVector &Inputs, StringRef SampleFilename,
  StringRef OutputFilename, ProfileFormat OutputFormat, bool OutputSparse,
  unsigned SupplMinSizeThreshold, float ZeroCounterThreshold,
  unsigned InstrProfColdThreshold) {
if (OutputFilename.compare("-") == 0)
  exitWithError("cannot write indexed profdata format to stdout");
if (Inputs.size() != 1)
  exitWithError("expect one input to be an instr profile");
if (Inputs[0].Weight != 1)
  exitWithError("expect instr profile doesn't have weight");

StringRef InstrFilename = Inputs[0].Filename;

// Read sample profile.
LLVMContext Context;
auto ReaderOrErr = sampleprof::SampleProfileReader::create(
    SampleFilename.str(), Context, FSDiscriminatorPassOption);
if (std::error_code EC = ReaderOrErr.getError())
  exitWithErrorCode(EC, SampleFilename);
auto Reader = std::move(ReaderOrErr.get());
if (std::error_code EC = Reader->read())
  exitWithErrorCode(EC, SampleFilename);

// Read instr profile.
std::mutex ErrorLock;
SmallSet<instrprof_error, 4> WriterErrorCodes;
auto WC = std::make_unique<WriterContext>(OutputSparse, ErrorLock,
                                          WriterErrorCodes);
loadInput(Inputs[0], nullptr, nullptr, WC.get());
if (WC->Errors.size() > 0)
  exitWithError(std::move(WC->Errors[0].first), InstrFilename);

adjustInstrProfile(WC, Reader, SupplMinSizeThreshold, ZeroCounterThreshold,
                   InstrProfColdThreshold);
writeInstrProfile(OutputFilename, OutputFormat, WC->Writer);
598}

600/// Make a copy of the given function samples with all symbol names remapped
601/// by the provided symbol remapper.
602static sampleprof::FunctionSamples
603remapSamples(const sampleprof::FunctionSamples &Samples,
           SymbolRemapper &Remapper, sampleprof_error &Error) {
sampleprof::FunctionSamples Result;
Result.setName(Remapper(Samples.getName()));
Result.addTotalSamples(Samples.getTotalSamples());
Result.addHeadSamples(Samples.getHeadSamples());
for (const auto &BodySample : Samples.getBodySamples()) {
  uint32_t MaskedDiscriminator =
      BodySample.first.Discriminator & getDiscriminatorMask();
  Result.addBodySamples(BodySample.first.LineOffset, MaskedDiscriminator,
                        BodySample.second.getSamples());
  for (const auto &Target : BodySample.second.getCallTargets()) {
    Result.addCalledTargetSamples(BodySample.first.LineOffset,
                                  MaskedDiscriminator,
                                  Remapper(Target.first()), Target.second);
  }
}
for (const auto &CallsiteSamples : Samples.getCallsiteSamples()) {
  sampleprof::FunctionSamplesMap &Target =
      Result.functionSamplesAt(CallsiteSamples.first);
  for (const auto &Callsite : CallsiteSamples.second) {
    sampleprof::FunctionSamples Remapped =
        remapSamples(Callsite.second, Remapper, Error);
    MergeResult(Error,
                Target[std::string(Remapped.getName())].merge(Remapped));
  }
}
return Result;
631}

633static sampleprof::SampleProfileFormat FormatMap[] = {
  sampleprof::SPF_None,
  sampleprof::SPF_Text,
  sampleprof::SPF_Compact_Binary,
  sampleprof::SPF_Ext_Binary,
  sampleprof::SPF_GCC,
  sampleprof::SPF_Binary};

641static std::unique_ptr<MemoryBuffer>
642getInputFileBuf(const StringRef &InputFile) {
if (InputFile == "")
  return {};

auto BufOrError = MemoryBuffer::getFileOrSTDIN(InputFile);
if (!BufOrError)
  exitWithErrorCode(BufOrError.getError(), InputFile);

return std::move(*BufOrError);
651}

653static void populateProfileSymbolList(MemoryBuffer *Buffer,
                                    sampleprof::ProfileSymbolList &PSL) {
if (!Buffer)
  return;

SmallVector<StringRef, 32> SymbolVec;
StringRef Data = Buffer->getBuffer();
Data.split(SymbolVec, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);

for (StringRef SymbolStr : SymbolVec)
  PSL.add(SymbolStr.trim());
664}

666static void handleExtBinaryWriter(sampleprof::SampleProfileWriter &Writer,
                                ProfileFormat OutputFormat,
                                MemoryBuffer *Buffer,
                                sampleprof::ProfileSymbolList &WriterList,
                                bool CompressAllSections, bool UseMD5,
                                bool GenPartialProfile) {
populateProfileSymbolList(Buffer, WriterList);
if (WriterList.size() > 0 && OutputFormat != PF_Ext_Binary)
  warn("Profile Symbol list is not empty but the output format is not "
       "ExtBinary format. The list will be lost in the output. ");

Writer.setProfileSymbolList(&WriterList);

if (CompressAllSections) {
  if (OutputFormat != PF_Ext_Binary)
    warn("-compress-all-section is ignored. Specify -extbinary to enable it");
  else
    Writer.setToCompressAllSections();
}
if (UseMD5) {
  if (OutputFormat != PF_Ext_Binary)
    warn("-use-md5 is ignored. Specify -extbinary to enable it");
  else
    Writer.setUseMD5();
}
if (GenPartialProfile) {
  if (OutputFormat != PF_Ext_Binary)
    warn("-gen-partial-profile is ignored. Specify -extbinary to enable it");
  else
    Writer.setPartialProfile();
}
697}

699static void
700mergeSampleProfile(const WeightedFileVector &Inputs, SymbolRemapper *Remapper,
                 StringRef OutputFilename, ProfileFormat OutputFormat,
                 StringRef ProfileSymbolListFile, bool CompressAllSections,
                 bool UseMD5, bool GenPartialProfile, bool GenCSNestedProfile,
                 bool SampleMergeColdContext, bool SampleTrimColdContext,
                 bool SampleColdContextFrameDepth, FailureMode FailMode) {
using namespace sampleprof;
SampleProfileMap ProfileMap;
SmallVector<std::unique_ptr<sampleprof::SampleProfileReader>, 5> Readers;
LLVMContext Context;
sampleprof::ProfileSymbolList WriterList;
Optional<bool> ProfileIsProbeBased;
Optional<bool> ProfileIsCSFlat;
for (const auto &Input : Inputs) {
  auto ReaderOrErr = SampleProfileReader::create(Input.Filename, Context,
                                                 FSDiscriminatorPassOption);
  if (std::error_code EC = ReaderOrErr.getError()) {
    warnOrExitGivenError(FailMode, EC, Input.Filename);
    continue;
  }

  // We need to keep the readers around until after all the files are
  // read so that we do not lose the function names stored in each
  // reader's memory. The function names are needed to write out the
  // merged profile map.
  Readers.push_back(std::move(ReaderOrErr.get()));
  const auto Reader = Readers.back().get();
  if (std::error_code EC = Reader->read()) {
    warnOrExitGivenError(FailMode, EC, Input.Filename);
    Readers.pop_back();
    continue;
  }

  SampleProfileMap &Profiles = Reader->getProfiles();
  if (ProfileIsProbeBased.hasValue() &&
      ProfileIsProbeBased != FunctionSamples::ProfileIsProbeBased)
    exitWithError(
        "cannot merge probe-based profile with non-probe-based profile");
  ProfileIsProbeBased = FunctionSamples::ProfileIsProbeBased;
  if (ProfileIsCSFlat.hasValue() &&
      ProfileIsCSFlat != FunctionSamples::ProfileIsCSFlat)
    exitWithError("cannot merge CS profile with non-CS profile");
  ProfileIsCSFlat = FunctionSamples::ProfileIsCSFlat;
  for (SampleProfileMap::iterator I = Profiles.begin(), E = Profiles.end();
       I != E; ++I) {
    sampleprof_error Result = sampleprof_error::success;
    FunctionSamples Remapped =
        Remapper ? remapSamples(I->second, *Remapper, Result)
                 : FunctionSamples();
    FunctionSamples &Samples = Remapper ? Remapped : I->second;
    SampleContext FContext = Samples.getContext();
    MergeResult(Result, ProfileMap[FContext].merge(Samples, Input.Weight));
    if (Result != sampleprof_error::success) {
      std::error_code EC = make_error_code(Result);
      handleMergeWriterError(errorCodeToError(EC), Input.Filename,
                             FContext.toString());
    }
  }

  std::unique_ptr<sampleprof::ProfileSymbolList> ReaderList =
      Reader->getProfileSymbolList();
  if (ReaderList)
    WriterList.merge(*ReaderList);
}

if (ProfileIsCSFlat && (SampleMergeColdContext || SampleTrimColdContext)) {
  // Use threshold calculated from profile summary unless specified.
  SampleProfileSummaryBuilder Builder(ProfileSummaryBuilder::DefaultCutoffs);
  auto Summary = Builder.computeSummaryForProfiles(ProfileMap);
  uint64_t SampleProfColdThreshold =
      ProfileSummaryBuilder::getColdCountThreshold(
          (Summary->getDetailedSummary()));

  // Trim and merge cold context profile using cold threshold above;
  SampleContextTrimmer(ProfileMap)
      .trimAndMergeColdContextProfiles(
          SampleProfColdThreshold, SampleTrimColdContext,
          SampleMergeColdContext, SampleColdContextFrameDepth, false);
}

if (ProfileIsCSFlat && GenCSNestedProfile) {
  CSProfileConverter CSConverter(ProfileMap);
  CSConverter.convertProfiles();
  ProfileIsCSFlat = FunctionSamples::ProfileIsCSFlat = false;
}

auto WriterOrErr =
    SampleProfileWriter::create(OutputFilename, FormatMap[OutputFormat]);
if (std::error_code EC = WriterOrErr.getError())
  exitWithErrorCode(EC, OutputFilename);

auto Writer = std::move(WriterOrErr.get());
// WriterList will have StringRef refering to string in Buffer.
// Make sure Buffer lives as long as WriterList.
auto Buffer = getInputFileBuf(ProfileSymbolListFile);
handleExtBinaryWriter(*Writer, OutputFormat, Buffer.get(), WriterList,
                      CompressAllSections, UseMD5, GenPartialProfile);
if (std::error_code EC = Writer->write(ProfileMap))
  exitWithErrorCode(std::move(EC));
799}

801static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) {
StringRef WeightStr, FileName;
std::tie(WeightStr, FileName) = WeightedFilename.split(',');

uint64_t Weight;
if (WeightStr.getAsInteger(10, Weight) || Weight < 1)
  exitWithError("input weight must be a positive integer");

return {std::string(FileName), Weight};
810}

812static void addWeightedInput(WeightedFileVector &WNI, const WeightedFile &WF) {
StringRef Filename = WF.Filename;
uint64_t Weight = WF.Weight;

// If it's STDIN just pass it on.
if (Filename == "-") {
  WNI.push_back({std::string(Filename), Weight});
  return;
}

llvm::sys::fs::file_status Status;
llvm::sys::fs::status(Filename, Status);
if (!llvm::sys::fs::exists(Status))
  exitWithErrorCode(make_error_code(errc::no_such_file_or_directory),
                    Filename);
// If it's a source file, collect it.
if (llvm::sys::fs::is_regular_file(Status)) {
  WNI.push_back({std::string(Filename), Weight});
  return;
}

if (llvm::sys::fs::is_directory(Status)) {
  std::error_code EC;
  for (llvm::sys::fs::recursive_directory_iterator F(Filename, EC), E;
       F != E && !EC; F.increment(EC)) {
    if (llvm::sys::fs::is_regular_file(F->path())) {
      addWeightedInput(WNI, {F->path(), Weight});
    }
  }
  if (EC)
    exitWithErrorCode(EC, Filename);
}
844}

846static void parseInputFilenamesFile(MemoryBuffer *Buffer,
                                  WeightedFileVector &WFV) {
if (!Buffer)
  return;

SmallVector<StringRef, 8> Entries;
StringRef Data = Buffer->getBuffer();
Data.split(Entries, '\n', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
for (const StringRef &FileWeightEntry : Entries) {
  StringRef SanitizedEntry = FileWeightEntry.trim(" \t\v\f\r");
  // Skip comments.
  if (SanitizedEntry.startswith("#"))
    continue;
  // If there's no comma, it's an unweighted profile.
  else if (!SanitizedEntry.contains(','))
    addWeightedInput(WFV, {std::string(SanitizedEntry), 1});
  else
    addWeightedInput(WFV, parseWeightedFile(SanitizedEntry));
}
865}

867static int merge_main(int argc, const char *argv[]) {
cl::list<std::string> InputFilenames(cl::Positional,
                                     cl::desc("<filename...>"));
cl::list<std::string> WeightedInputFilenames("weighted-input",
                                             cl::desc("<weight>,<filename>"));
cl::opt<std::string> InputFilenamesFile(
    "input-files", cl::init(""),
    cl::desc("Path to file containing newline-separated "
             "[<weight>,]<filename> entries"));
cl::alias InputFilenamesFileA("f", cl::desc("Alias for --input-files"),
                              cl::aliasopt(InputFilenamesFile));
cl::opt<bool> DumpInputFileList(
    "dump-input-file-list", cl::init(false), cl::Hidden,
    cl::desc("Dump the list of input files and their weights, then exit"));
cl::opt<std::string> RemappingFile("remapping-file", cl::value_desc("file"),
                                   cl::desc("Symbol remapping file"));
cl::alias RemappingFileA("r", cl::desc("Alias for --remapping-file"),
                         cl::aliasopt(RemappingFile));
cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
                                    cl::init("-"), cl::desc("Output file"));
cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
                          cl::aliasopt(OutputFilename));
cl::opt<ProfileKinds> ProfileKind(
    cl::desc("Profile kind:"), cl::init(instr),
    cl::values(clEnumVal(instr, "Instrumentation profile (default)")llvm::cl::OptionEnumValue { "instr", int(instr), "Instrumentation profile (default)"
 },
               clEnumVal(sample, "Sample profile")llvm::cl::OptionEnumValue { "sample", int(sample), "Sample profile"
 }));
cl::opt<ProfileFormat> OutputFormat(
    cl::desc("Format of output profile"), cl::init(PF_Binary),
    cl::values(
        clEnumValN(PF_Binary, "binary", "Binary encoding (default)")llvm::cl::OptionEnumValue { "binary", int(PF_Binary), "Binary encoding (default)"
 },
        clEnumValN(PF_Compact_Binary, "compbinary",llvm::cl::OptionEnumValue { "compbinary", int(PF_Compact_Binary
), "Compact binary encoding" }
                   "Compact binary encoding")llvm::cl::OptionEnumValue { "compbinary", int(PF_Compact_Binary
), "Compact binary encoding" },
        clEnumValN(PF_Ext_Binary, "extbinary", "Extensible binary encoding")llvm::cl::OptionEnumValue { "extbinary", int(PF_Ext_Binary), "Extensible binary encoding"
 },
        clEnumValN(PF_Text, "text", "Text encoding")llvm::cl::OptionEnumValue { "text", int(PF_Text), "Text encoding"
 },
        clEnumValN(PF_GCC, "gcc",llvm::cl::OptionEnumValue { "gcc", int(PF_GCC), "GCC encoding (only meaningful for -sample)"
 }
                   "GCC encoding (only meaningful for -sample)")llvm::cl::OptionEnumValue { "gcc", int(PF_GCC), "GCC encoding (only meaningful for -sample)"
 }));
cl::opt<FailureMode> FailureMode(
    "failure-mode", cl::init(failIfAnyAreInvalid), cl::desc("Failure mode:"),
    cl::values(clEnumValN(failIfAnyAreInvalid, "any",llvm::cl::OptionEnumValue { "any", int(failIfAnyAreInvalid), "Fail if any profile is invalid."
 }
                          "Fail if any profile is invalid.")llvm::cl::OptionEnumValue { "any", int(failIfAnyAreInvalid), "Fail if any profile is invalid."
 },
               clEnumValN(failIfAllAreInvalid, "all",llvm::cl::OptionEnumValue { "all", int(failIfAllAreInvalid), "Fail only if all profiles are invalid."
 }
                          "Fail only if all profiles are invalid.")llvm::cl::OptionEnumValue { "all", int(failIfAllAreInvalid), "Fail only if all profiles are invalid."
 }));
cl::opt<bool> OutputSparse("sparse", cl::init(false),
    cl::desc("Generate a sparse profile (only meaningful for -instr)"));
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));
cl::opt<std::string> ProfileSymbolListFile(
    "prof-sym-list", cl::init(""),
    cl::desc("Path to file containing the list of function symbols "
             "used to populate profile symbol list"));
cl::opt<bool> CompressAllSections(
    "compress-all-sections", cl::init(false), cl::Hidden,
    cl::desc("Compress all sections when writing the profile (only "
             "meaningful for -extbinary)"));
cl::opt<bool> UseMD5(
    "use-md5", cl::init(false), cl::Hidden,
    cl::desc("Choose to use MD5 to represent string in name table (only "
             "meaningful for -extbinary)"));
cl::opt<bool> SampleMergeColdContext(
    "sample-merge-cold-context", cl::init(false), cl::Hidden,
    cl::desc(
        "Merge context sample profiles whose count is below cold threshold"));
cl::opt<bool> SampleTrimColdContext(
    "sample-trim-cold-context", cl::init(false), cl::Hidden,
    cl::desc(
        "Trim context sample profiles whose count is below cold threshold"));
cl::opt<uint32_t> SampleColdContextFrameDepth(
    "sample-frame-depth-for-cold-context", cl::init(1), cl::ZeroOrMore,
    cl::desc("Keep the last K frames while merging cold profile. 1 means the "
             "context-less base profile"));
cl::opt<bool> GenPartialProfile(
    "gen-partial-profile", cl::init(false), cl::Hidden,
    cl::desc("Generate a partial profile (only meaningful for -extbinary)"));
cl::opt<std::string> SupplInstrWithSample(
    "supplement-instr-with-sample", cl::init(""), cl::Hidden,
    cl::desc("Supplement an instr profile with sample profile, to correct "
             "the profile unrepresentativeness issue. The sample "
             "profile is the input of the flag. Output will be in instr "
             "format (The flag only works with -instr)"));
cl::opt<float> ZeroCounterThreshold(
    "zero-counter-threshold", cl::init(0.7), cl::Hidden,
    cl::desc("For the function which is cold in instr profile but hot in "
             "sample profile, if the ratio of the number of zero counters "
             "divided by the the total number of counters is above the "
             "threshold, the profile of the function will be regarded as "
             "being harmful for performance and will be dropped."));
cl::opt<unsigned> SupplMinSizeThreshold(
    "suppl-min-size-threshold", cl::init(10), cl::Hidden,
    cl::desc("If the size of a function is smaller than the threshold, "
             "assume it can be inlined by PGO early inliner and it won't "
             "be adjusted based on sample profile."));
cl::opt<unsigned> InstrProfColdThreshold(
    "instr-prof-cold-threshold", cl::init(0), cl::Hidden,
    cl::desc("User specified cold threshold for instr profile which will "
             "override the cold threshold got from profile summary. "));
cl::opt<bool> GenCSNestedProfile(
    "gen-cs-nested-profile", cl::Hidden, cl::init(false),
    cl::desc("Generate nested function profiles for CSSPGO"));
cl::opt<std::string> DebugInfoFilename(
    "debug-info", cl::init(""),
    cl::desc("Use the provided debug info to correlate the raw profile."));

cl::ParseCommandLineOptions(argc, argv, "LLVM profile data merger\n");

WeightedFileVector WeightedInputs;
for (StringRef Filename : InputFilenames)
  addWeightedInput(WeightedInputs, {std::string(Filename), 1});
for (StringRef WeightedFilename : WeightedInputFilenames)
  addWeightedInput(WeightedInputs, parseWeightedFile(WeightedFilename));

// Make sure that the file buffer stays alive for the duration of the
// weighted input vector's lifetime.
auto Buffer = getInputFileBuf(InputFilenamesFile);
parseInputFilenamesFile(Buffer.get(), WeightedInputs);

if (WeightedInputs.empty())
  exitWithError("no input files specified. See " +
                sys::path::filename(argv[0]) + " -help");

if (DumpInputFileList) {
  for (auto &WF : WeightedInputs)
    outs() << WF.Weight << "," << WF.Filename << "\n";
  return 0;
}

std::unique_ptr<SymbolRemapper> Remapper;
if (!RemappingFile.empty())
  Remapper = SymbolRemapper::create(RemappingFile);

if (!SupplInstrWithSample.empty()) {
  if (ProfileKind != instr)
    exitWithError(
        "-supplement-instr-with-sample can only work with -instr. ");

  supplementInstrProfile(WeightedInputs, SupplInstrWithSample, OutputFilename,
                         OutputFormat, OutputSparse, SupplMinSizeThreshold,
                         ZeroCounterThreshold, InstrProfColdThreshold);
  return 0;
}

if (ProfileKind == instr)
  mergeInstrProfile(WeightedInputs, DebugInfoFilename, Remapper.get(),
                    OutputFilename, OutputFormat, OutputSparse, NumThreads,
                    FailureMode);
else
  mergeSampleProfile(WeightedInputs, Remapper.get(), OutputFilename,
                     OutputFormat, ProfileSymbolListFile, CompressAllSections,
                     UseMD5, GenPartialProfile, GenCSNestedProfile,
                     SampleMergeColdContext, SampleTrimColdContext,
                     SampleColdContextFrameDepth, FailureMode);
return 0;
1021}

1023/// Computer the overlap b/w profile BaseFilename and profile TestFilename.
1024static void overlapInstrProfile(const std::string &BaseFilename,
                              const std::string &TestFilename,
                              const OverlapFuncFilters &FuncFilter,
                              raw_fd_ostream &OS, bool IsCS) {
std::mutex ErrorLock;
SmallSet<instrprof_error, 4> WriterErrorCodes;
WriterContext Context(false, ErrorLock, WriterErrorCodes);
WeightedFile WeightedInput{BaseFilename, 1};
OverlapStats Overlap;
Error E = Overlap.accumulateCounts(BaseFilename, TestFilename, IsCS);
if (E)
  exitWithError(std::move(E), "error in getting profile count sums");
if (Overlap.Base.CountSum < 1.0f) {
  OS << "Sum of edge counts for profile " << BaseFilename << " is 0.\n";
  exit(0);
}
if (Overlap.Test.CountSum < 1.0f) {
  OS << "Sum of edge counts for profile " << TestFilename << " is 0.\n";
  exit(0);
}
loadInput(WeightedInput, nullptr, nullptr, &Context);
overlapInput(BaseFilename, TestFilename, &Context, Overlap, FuncFilter, OS,
             IsCS);
Overlap.dump(OS);
1048}

1050namespace {
1051struct SampleOverlapStats {
SampleContext BaseName;
SampleContext TestName;
// Number of overlap units
uint64_t OverlapCount;
// Total samples of overlap units
uint64_t OverlapSample;
// Number of and total samples of units that only present in base or test
// profile
uint64_t BaseUniqueCount;
uint64_t BaseUniqueSample;
uint64_t TestUniqueCount;
uint64_t TestUniqueSample;
// Number of units and total samples in base or test profile
uint64_t BaseCount;
uint64_t BaseSample;
uint64_t TestCount;
uint64_t TestSample;
// Number of and total samples of units that present in at least one profile
uint64_t UnionCount;
uint64_t UnionSample;
// Weighted similarity
double Similarity;
// For SampleOverlapStats instances representing functions, weights of the
// function in base and test profiles
double BaseWeight;
double TestWeight;

SampleOverlapStats()
    : OverlapCount(0), OverlapSample(0), BaseUniqueCount(0),
      BaseUniqueSample(0), TestUniqueCount(0), TestUniqueSample(0),
      BaseCount(0), BaseSample(0), TestCount(0), TestSample(0), UnionCount(0),
      UnionSample(0), Similarity(0.0), BaseWeight(0.0), TestWeight(0.0) {}
1084};
1085} // end anonymous namespace

1087namespace {
1088struct FuncSampleStats {
uint64_t SampleSum;
uint64_t MaxSample;
uint64_t HotBlockCount;
FuncSampleStats() : SampleSum(0), MaxSample(0), HotBlockCount(0) {}
FuncSampleStats(uint64_t SampleSum, uint64_t MaxSample,
                uint64_t HotBlockCount)
    : SampleSum(SampleSum), MaxSample(MaxSample),
      HotBlockCount(HotBlockCount) {}
1097};
1098} // end anonymous namespace

1100namespace {
1101enum MatchStatus { MS_Match, MS_FirstUnique, MS_SecondUnique, MS_None };

1103// Class for updating merging steps for two sorted maps. The class should be
1104// instantiated with a map iterator type.
1105template <class T> class MatchStep {
1106public:
MatchStep() = delete;

MatchStep(T FirstIter, T FirstEnd, T SecondIter, T SecondEnd)
    : FirstIter(FirstIter), FirstEnd(FirstEnd), SecondIter(SecondIter),
      SecondEnd(SecondEnd), Status(MS_None) {}

bool areBothFinished() const {
  return (FirstIter == FirstEnd && SecondIter == SecondEnd);
}

bool isFirstFinished() const { return FirstIter == FirstEnd; }

bool isSecondFinished() const { return SecondIter == SecondEnd; }

/// Advance one step based on the previous match status unless the previous
/// status is MS_None. Then update Status based on the comparison between two
/// container iterators at the current step. If the previous status is
/// MS_None, it means two iterators are at the beginning and no comparison has
/// been made, so we simply update Status without advancing the iterators.
void updateOneStep();

T getFirstIter() const { return FirstIter; }

T getSecondIter() const { return SecondIter; }

MatchStatus getMatchStatus() const { return Status; }

1134private:
// Current iterator and end iterator of the first container.
T FirstIter;
T FirstEnd;
// Current iterator and end iterator of the second container.
T SecondIter;
T SecondEnd;
// Match status of the current step.
MatchStatus Status;
1143};
1144} // end anonymous namespace

1146template <class T> void MatchStep<T>::updateOneStep() {
switch (Status) {
case MS_Match:
  ++FirstIter;
  ++SecondIter;
  break;
case MS_FirstUnique:
  ++FirstIter;
  break;
case MS_SecondUnique:
  ++SecondIter;
  break;
case MS_None:
  break;
}

// Update Status according to iterators at the current step.
if (areBothFinished())
  return;
if (FirstIter != FirstEnd &&
    (SecondIter == SecondEnd || FirstIter->first < SecondIter->first))
  Status = MS_FirstUnique;
else if (SecondIter != SecondEnd &&
         (FirstIter == FirstEnd || SecondIter->first < FirstIter->first))
  Status = MS_SecondUnique;
else
  Status = MS_Match;
1173}

1175// Return the sum of line/block samples, the max line/block sample, and the
1176// number of line/block samples above the given threshold in a function
1177// including its inlinees.
1178static void getFuncSampleStats(const sampleprof::FunctionSamples &Func,
                             FuncSampleStats &FuncStats,
                             uint64_t HotThreshold) {
for (const auto &L : Func.getBodySamples()) {
  uint64_t Sample = L.second.getSamples();
  FuncStats.SampleSum += Sample;
  FuncStats.MaxSample = std::max(FuncStats.MaxSample, Sample);
  if (Sample >= HotThreshold)
    ++FuncStats.HotBlockCount;
}

for (const auto &C : Func.getCallsiteSamples()) {
  for (const auto &F : C.second)
    getFuncSampleStats(F.second, FuncStats, HotThreshold);
}
1193}

1195/// Predicate that determines if a function is hot with a given threshold. We
1196/// keep it separate from its callsites for possible extension in the future.
1197static bool isFunctionHot(const FuncSampleStats &FuncStats,
                        uint64_t HotThreshold) {
// We intentionally compare the maximum sample count in a function with the
// HotThreshold to get an approximate determination on hot functions.
return (FuncStats.MaxSample >= HotThreshold);
1202}

1204namespace {
1205class SampleOverlapAggregator {
1206public:
SampleOverlapAggregator(const std::string &BaseFilename,
                        const std::string &TestFilename,
                        double LowSimilarityThreshold, double Epsilon,
                        const OverlapFuncFilters &FuncFilter)
    : BaseFilename(BaseFilename), TestFilename(TestFilename),
      LowSimilarityThreshold(LowSimilarityThreshold), Epsilon(Epsilon),
      FuncFilter(FuncFilter) {}

/// Detect 0-sample input profile and report to output stream. This interface
/// should be called after loadProfiles().
bool detectZeroSampleProfile(raw_fd_ostream &OS) const;

/// Write out function-level similarity statistics for functions specified by
/// options --function, --value-cutoff, and --similarity-cutoff.
void dumpFuncSimilarity(raw_fd_ostream &OS) const;

/// Write out program-level similarity and overlap statistics.
void dumpProgramSummary(raw_fd_ostream &OS) const;

/// Write out hot-function and hot-block statistics for base_profile,
/// test_profile, and their overlap. For both cases, the overlap HO is
/// calculated as follows:
///    Given the number of functions (or blocks) that are hot in both profiles
///    HCommon and the number of functions (or blocks) that are hot in at
///    least one profile HUnion, HO = HCommon / HUnion.
void dumpHotFuncAndBlockOverlap(raw_fd_ostream &OS) const;

/// This function tries matching functions in base and test profiles. For each
/// pair of matched functions, it aggregates the function-level
/// similarity into a profile-level similarity. It also dump function-level
/// similarity information of functions specified by --function,
/// --value-cutoff, and --similarity-cutoff options. The program-level
/// similarity PS is computed as follows:
///     Given function-level similarity FS(A) for all function A, the
///     weight of function A in base profile WB(A), and the weight of function
///     A in test profile WT(A), compute PS(base_profile, test_profile) =
///     sum_A(FS(A) * avg(WB(A), WT(A))) ranging in [0.0f to 1.0f] with 0.0
///     meaning no-overlap.
void computeSampleProfileOverlap(raw_fd_ostream &OS);

/// Initialize ProfOverlap with the sum of samples in base and test
/// profiles. This function also computes and keeps the sum of samples and
/// max sample counts of each function in BaseStats and TestStats for later
/// use to avoid re-computations.
void initializeSampleProfileOverlap();

/// Load profiles specified by BaseFilename and TestFilename.
std::error_code loadProfiles();

using FuncSampleStatsMap =
    std::unordered_map<SampleContext, FuncSampleStats, SampleContext::Hash>;

1259private:
SampleOverlapStats ProfOverlap;
SampleOverlapStats HotFuncOverlap;
SampleOverlapStats HotBlockOverlap;
std::string BaseFilename;
std::string TestFilename;
std::unique_ptr<sampleprof::SampleProfileReader> BaseReader;
std::unique_ptr<sampleprof::SampleProfileReader> TestReader;
// BaseStats and TestStats hold FuncSampleStats for each function, with
// function name as the key.
FuncSampleStatsMap BaseStats;
FuncSampleStatsMap TestStats;
// Low similarity threshold in floating point number
double LowSimilarityThreshold;
// Block samples above BaseHotThreshold or TestHotThreshold are considered hot
// for tracking hot blocks.
uint64_t BaseHotThreshold;
uint64_t TestHotThreshold;
// A small threshold used to round the results of floating point accumulations
// to resolve imprecision.
const double Epsilon;
std::multimap<double, SampleOverlapStats, std::greater<double>>
    FuncSimilarityDump;
// FuncFilter carries specifications in options --value-cutoff and
// --function.
OverlapFuncFilters FuncFilter;
// Column offsets for printing the function-level details table.
static const unsigned int TestWeightCol = 15;
static const unsigned int SimilarityCol = 30;
static const unsigned int OverlapCol = 43;
static const unsigned int BaseUniqueCol = 53;
static const unsigned int TestUniqueCol = 67;
static const unsigned int BaseSampleCol = 81;
static const unsigned int TestSampleCol = 96;
static const unsigned int FuncNameCol = 111;

/// Return a similarity of two line/block sample counters in the same
/// function in base and test profiles. The line/block-similarity BS(i) is
/// computed as follows:
///    For an offsets i, given the sample count at i in base profile BB(i),
///    the sample count at i in test profile BT(i), the sum of sample counts
///    in this function in base profile SB, and the sum of sample counts in
///    this function in test profile ST, compute BS(i) = 1.0 - fabs(BB(i)/SB -
///    BT(i)/ST), ranging in [0.0f to 1.0f] with 0.0 meaning no-overlap.
double computeBlockSimilarity(uint64_t BaseSample, uint64_t TestSample,
                              const SampleOverlapStats &FuncOverlap) const;

void updateHotBlockOverlap(uint64_t BaseSample, uint64_t TestSample,
                           uint64_t HotBlockCount);

void getHotFunctions(const FuncSampleStatsMap &ProfStats,
                     FuncSampleStatsMap &HotFunc,
                     uint64_t HotThreshold) const;

void computeHotFuncOverlap();

/// This function updates statistics in FuncOverlap, HotBlockOverlap, and
/// Difference for two sample units in a matched function according to the
/// given match status.
void updateOverlapStatsForFunction(uint64_t BaseSample, uint64_t TestSample,
                                   uint64_t HotBlockCount,
                                   SampleOverlapStats &FuncOverlap,
                                   double &Difference, MatchStatus Status);

/// This function updates statistics in FuncOverlap, HotBlockOverlap, and
/// Difference for unmatched callees that only present in one profile in a
/// matched caller function.
void updateForUnmatchedCallee(const sampleprof::FunctionSamples &Func,
                              SampleOverlapStats &FuncOverlap,
                              double &Difference, MatchStatus Status);

/// This function updates sample overlap statistics of an overlap function in
/// base and test profile. It also calculates a function-internal similarity
/// FIS as follows:
///    For offsets i that have samples in at least one profile in this
///    function A, given BS(i) returned by computeBlockSimilarity(), compute
///    FIS(A) = (2.0 - sum_i(1.0 - BS(i))) / 2, ranging in [0.0f to 1.0f] with
///    0.0 meaning no overlap.
double computeSampleFunctionInternalOverlap(
    const sampleprof::FunctionSamples &BaseFunc,
    const sampleprof::FunctionSamples &TestFunc,
    SampleOverlapStats &FuncOverlap);

/// Function-level similarity (FS) is a weighted value over function internal
/// similarity (FIS). This function computes a function's FS from its FIS by
/// applying the weight.
double weightForFuncSimilarity(double FuncSimilarity, uint64_t BaseFuncSample,
                               uint64_t TestFuncSample) const;

/// The function-level similarity FS(A) for a function A is computed as
/// follows:
///     Compute a function-internal similarity FIS(A) by
///     computeSampleFunctionInternalOverlap(). Then, with the weight of
///     function A in base profile WB(A), and the weight of function A in test
///     profile WT(A), compute FS(A) = FIS(A) * (1.0 - fabs(WB(A) - WT(A)))
///     ranging in [0.0f to 1.0f] with 0.0 meaning no overlap.
double
computeSampleFunctionOverlap(const sampleprof::FunctionSamples *BaseFunc,
                             const sampleprof::FunctionSamples *TestFunc,
                             SampleOverlapStats *FuncOverlap,
                             uint64_t BaseFuncSample,
                             uint64_t TestFuncSample);

/// Profile-level similarity (PS) is a weighted aggregate over function-level
/// similarities (FS). This method weights the FS value by the function
/// weights in the base and test profiles for the aggregation.
double weightByImportance(double FuncSimilarity, uint64_t BaseFuncSample,
                          uint64_t TestFuncSample) const;
1367};
1368} // end anonymous namespace

1370bool SampleOverlapAggregator::detectZeroSampleProfile(
  raw_fd_ostream &OS) const {
bool HaveZeroSample = false;
if (ProfOverlap.BaseSample == 0) {
  OS << "Sum of sample counts for profile " << BaseFilename << " is 0.\n";
  HaveZeroSample = true;
}
if (ProfOverlap.TestSample == 0) {
  OS << "Sum of sample counts for profile " << TestFilename << " is 0.\n";
  HaveZeroSample = true;
}
return HaveZeroSample;
1382}

1384double SampleOverlapAggregator::computeBlockSimilarity(
  uint64_t BaseSample, uint64_t TestSample,
  const SampleOverlapStats &FuncOverlap) const {
double BaseFrac = 0.0;
double TestFrac = 0.0;
if (FuncOverlap.BaseSample > 0)
  BaseFrac = static_cast<double>(BaseSample) / FuncOverlap.BaseSample;
if (FuncOverlap.TestSample > 0)
  TestFrac = static_cast<double>(TestSample) / FuncOverlap.TestSample;
return 1.0 - std::fabs(BaseFrac - TestFrac);
1394}

1396void SampleOverlapAggregator::updateHotBlockOverlap(uint64_t BaseSample,
                                                  uint64_t TestSample,
                                                  uint64_t HotBlockCount) {
bool IsBaseHot = (BaseSample >= BaseHotThreshold);
bool IsTestHot = (TestSample >= TestHotThreshold);
if (!IsBaseHot && !IsTestHot)
  return;

HotBlockOverlap.UnionCount += HotBlockCount;
if (IsBaseHot)
  HotBlockOverlap.BaseCount += HotBlockCount;
if (IsTestHot)
  HotBlockOverlap.TestCount += HotBlockCount;
if (IsBaseHot && IsTestHot)
  HotBlockOverlap.OverlapCount += HotBlockCount;
1411}

1413void SampleOverlapAggregator::getHotFunctions(
  const FuncSampleStatsMap &ProfStats, FuncSampleStatsMap &HotFunc,
  uint64_t HotThreshold) const {
for (const auto &F : ProfStats) {
  if (isFunctionHot(F.second, HotThreshold))
    HotFunc.emplace(F.first, F.second);
}
1420}

1422void SampleOverlapAggregator::computeHotFuncOverlap() {
FuncSampleStatsMap BaseHotFunc;
getHotFunctions(BaseStats, BaseHotFunc, BaseHotThreshold);
HotFuncOverlap.BaseCount = BaseHotFunc.size();

FuncSampleStatsMap TestHotFunc;
getHotFunctions(TestStats, TestHotFunc, TestHotThreshold);
HotFuncOverlap.TestCount = TestHotFunc.size();
HotFuncOverlap.UnionCount = HotFuncOverlap.TestCount;

for (const auto &F : BaseHotFunc) {
  if (TestHotFunc.count(F.first))
    ++HotFuncOverlap.OverlapCount;
  else
    ++HotFuncOverlap.UnionCount;
}
1438}

1440void SampleOverlapAggregator::updateOverlapStatsForFunction(
  uint64_t BaseSample, uint64_t TestSample, uint64_t HotBlockCount,
  SampleOverlapStats &FuncOverlap, double &Difference, MatchStatus Status) {
assert(Status != MS_None &&(static_cast <bool> (Status != MS_None && "Match status should be updated before updating overlap statistics"
) ? void (0) : __assert_fail ("Status != MS_None && \"Match status should be updated before updating overlap statistics\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1444, __extension__
 __PRETTY_FUNCTION__))
       "Match status should be updated before updating overlap statistics")(static_cast <bool> (Status != MS_None && "Match status should be updated before updating overlap statistics"
) ? void (0) : __assert_fail ("Status != MS_None && \"Match status should be updated before updating overlap statistics\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1444, __extension__
 __PRETTY_FUNCTION__));
if (Status == MS_FirstUnique) {
  TestSample = 0;
  FuncOverlap.BaseUniqueSample += BaseSample;
} else if (Status == MS_SecondUnique) {
  BaseSample = 0;
  FuncOverlap.TestUniqueSample += TestSample;
} else {
  ++FuncOverlap.OverlapCount;
}

FuncOverlap.UnionSample += std::max(BaseSample, TestSample);
FuncOverlap.OverlapSample += std::min(BaseSample, TestSample);
Difference +=
    1.0 - computeBlockSimilarity(BaseSample, TestSample, FuncOverlap);
updateHotBlockOverlap(BaseSample, TestSample, HotBlockCount);
1460}

1462void SampleOverlapAggregator::updateForUnmatchedCallee(
  const sampleprof::FunctionSamples &Func, SampleOverlapStats &FuncOverlap,
  double &Difference, MatchStatus Status) {
assert((Status == MS_FirstUnique || Status == MS_SecondUnique) &&(static_cast <bool> ((Status == MS_FirstUnique || Status
 == MS_SecondUnique) && "Status must be either of the two unmatched cases"
) ? void (0) : __assert_fail ("(Status == MS_FirstUnique || Status == MS_SecondUnique) && \"Status must be either of the two unmatched cases\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1466, __extension__
 __PRETTY_FUNCTION__))
       "Status must be either of the two unmatched cases")(static_cast <bool> ((Status == MS_FirstUnique || Status
 == MS_SecondUnique) && "Status must be either of the two unmatched cases"
) ? void (0) : __assert_fail ("(Status == MS_FirstUnique || Status == MS_SecondUnique) && \"Status must be either of the two unmatched cases\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1466, __extension__
 __PRETTY_FUNCTION__));
FuncSampleStats FuncStats;
if (Status == MS_FirstUnique) {
  getFuncSampleStats(Func, FuncStats, BaseHotThreshold);
  updateOverlapStatsForFunction(FuncStats.SampleSum, 0,
                                FuncStats.HotBlockCount, FuncOverlap,
                                Difference, Status);
} else {
  getFuncSampleStats(Func, FuncStats, TestHotThreshold);
  updateOverlapStatsForFunction(0, FuncStats.SampleSum,
                                FuncStats.HotBlockCount, FuncOverlap,
                                Difference, Status);
}
1479}

1481double SampleOverlapAggregator::computeSampleFunctionInternalOverlap(
  const sampleprof::FunctionSamples &BaseFunc,
  const sampleprof::FunctionSamples &TestFunc,
  SampleOverlapStats &FuncOverlap) {

using namespace sampleprof;

double Difference = 0;

// Accumulate Difference for regular line/block samples in the function.
// We match them through sort-merge join algorithm because
// FunctionSamples::getBodySamples() returns a map of sample counters ordered
// by their offsets.
MatchStep<BodySampleMap::const_iterator> BlockIterStep(
    BaseFunc.getBodySamples().cbegin(), BaseFunc.getBodySamples().cend(),
    TestFunc.getBodySamples().cbegin(), TestFunc.getBodySamples().cend());
BlockIterStep.updateOneStep();
while (!BlockIterStep.areBothFinished()) {
  uint64_t BaseSample =
      BlockIterStep.isFirstFinished()
          ? 0
          : BlockIterStep.getFirstIter()->second.getSamples();
  uint64_t TestSample =
      BlockIterStep.isSecondFinished()
          ? 0
          : BlockIterStep.getSecondIter()->second.getSamples();
  updateOverlapStatsForFunction(BaseSample, TestSample, 1, FuncOverlap,
                                Difference, BlockIterStep.getMatchStatus());

  BlockIterStep.updateOneStep();
}

// Accumulate Difference for callsite lines in the function. We match
// them through sort-merge algorithm because
// FunctionSamples::getCallsiteSamples() returns a map of callsite records
// ordered by their offsets.
MatchStep<CallsiteSampleMap::const_iterator> CallsiteIterStep(
    BaseFunc.getCallsiteSamples().cbegin(),
    BaseFunc.getCallsiteSamples().cend(),
    TestFunc.getCallsiteSamples().cbegin(),
    TestFunc.getCallsiteSamples().cend());
CallsiteIterStep.updateOneStep();
while (!CallsiteIterStep.areBothFinished()) {
  MatchStatus CallsiteStepStatus = CallsiteIterStep.getMatchStatus();
  assert(CallsiteStepStatus != MS_None &&(static_cast <bool> (CallsiteStepStatus != MS_None &&
 "Match status should be updated before entering loop body") ?
 void (0) : __assert_fail ("CallsiteStepStatus != MS_None && \"Match status should be updated before entering loop body\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1526, __extension__
 __PRETTY_FUNCTION__))
         "Match status should be updated before entering loop body")(static_cast <bool> (CallsiteStepStatus != MS_None &&
 "Match status should be updated before entering loop body") ?
 void (0) : __assert_fail ("CallsiteStepStatus != MS_None && \"Match status should be updated before entering loop body\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1526, __extension__
 __PRETTY_FUNCTION__));

  if (CallsiteStepStatus != MS_Match) {
    auto Callsite = (CallsiteStepStatus == MS_FirstUnique)
                        ? CallsiteIterStep.getFirstIter()
                        : CallsiteIterStep.getSecondIter();
    for (const auto &F : Callsite->second)
      updateForUnmatchedCallee(F.second, FuncOverlap, Difference,
                               CallsiteStepStatus);
  } else {
    // There may be multiple inlinees at the same offset, so we need to try
    // matching all of them. This match is implemented through sort-merge
    // algorithm because callsite records at the same offset are ordered by
    // function names.
    MatchStep<FunctionSamplesMap::const_iterator> CalleeIterStep(
        CallsiteIterStep.getFirstIter()->second.cbegin(),
        CallsiteIterStep.getFirstIter()->second.cend(),
        CallsiteIterStep.getSecondIter()->second.cbegin(),
        CallsiteIterStep.getSecondIter()->second.cend());
    CalleeIterStep.updateOneStep();
    while (!CalleeIterStep.areBothFinished()) {
      MatchStatus CalleeStepStatus = CalleeIterStep.getMatchStatus();
      if (CalleeStepStatus != MS_Match) {
        auto Callee = (CalleeStepStatus == MS_FirstUnique)
                          ? CalleeIterStep.getFirstIter()
                          : CalleeIterStep.getSecondIter();
        updateForUnmatchedCallee(Callee->second, FuncOverlap, Difference,
                                 CalleeStepStatus);
      } else {
        // An inlined function can contain other inlinees inside, so compute
        // the Difference recursively.
        Difference += 2.0 - 2 * computeSampleFunctionInternalOverlap(
                                    CalleeIterStep.getFirstIter()->second,
                                    CalleeIterStep.getSecondIter()->second,
                                    FuncOverlap);
      }
      CalleeIterStep.updateOneStep();
    }
  }
  CallsiteIterStep.updateOneStep();
}

// Difference reflects the total differences of line/block samples in this
// function and ranges in [0.0f to 2.0f]. Take (2.0 - Difference) / 2 to
// reflect the similarity between function profiles in [0.0f to 1.0f].
return (2.0 - Difference) / 2;
1572}

1574double SampleOverlapAggregator::weightForFuncSimilarity(
  double FuncInternalSimilarity, uint64_t BaseFuncSample,
  uint64_t TestFuncSample) const {
// Compute the weight as the distance between the function weights in two
// profiles.
double BaseFrac = 0.0;
double TestFrac = 0.0;
assert(ProfOverlap.BaseSample > 0 &&(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1582, __extension__
 __PRETTY_FUNCTION__))
       "Total samples in base profile should be greater than 0")(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1582, __extension__
 __PRETTY_FUNCTION__));
BaseFrac = static_cast<double>(BaseFuncSample) / ProfOverlap.BaseSample;
assert(ProfOverlap.TestSample > 0 &&(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1585, __extension__
 __PRETTY_FUNCTION__))
       "Total samples in test profile should be greater than 0")(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1585, __extension__
 __PRETTY_FUNCTION__));
TestFrac = static_cast<double>(TestFuncSample) / ProfOverlap.TestSample;
double WeightDistance = std::fabs(BaseFrac - TestFrac);

// Take WeightDistance into the similarity.
return FuncInternalSimilarity * (1 - WeightDistance);
1591}

1593double
1594SampleOverlapAggregator::weightByImportance(double FuncSimilarity,
                                          uint64_t BaseFuncSample,
                                          uint64_t TestFuncSample) const {

double BaseFrac = 0.0;
double TestFrac = 0.0;
assert(ProfOverlap.BaseSample > 0 &&(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1601, __extension__
 __PRETTY_FUNCTION__))
       "Total samples in base profile should be greater than 0")(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1601, __extension__
 __PRETTY_FUNCTION__));
BaseFrac = static_cast<double>(BaseFuncSample) / ProfOverlap.BaseSample / 2.0;
assert(ProfOverlap.TestSample > 0 &&(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1604, __extension__
 __PRETTY_FUNCTION__))
       "Total samples in test profile should be greater than 0")(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1604, __extension__
 __PRETTY_FUNCTION__));
TestFrac = static_cast<double>(TestFuncSample) / ProfOverlap.TestSample / 2.0;
return FuncSimilarity * (BaseFrac + TestFrac);
1607}

1609double SampleOverlapAggregator::computeSampleFunctionOverlap(
  const sampleprof::FunctionSamples *BaseFunc,
  const sampleprof::FunctionSamples *TestFunc,
  SampleOverlapStats *FuncOverlap, uint64_t BaseFuncSample,
  uint64_t TestFuncSample) {
// Default function internal similarity before weighted, meaning two functions
// has no overlap.
const double DefaultFuncInternalSimilarity = 0;
double FuncSimilarity;
double FuncInternalSimilarity;

// If BaseFunc or TestFunc is nullptr, it means the functions do not overlap.
// In this case, we use DefaultFuncInternalSimilarity as the function internal
// similarity.
if (!BaseFunc || !TestFunc) {
  FuncInternalSimilarity = DefaultFuncInternalSimilarity;
} else {
  assert(FuncOverlap != nullptr &&(static_cast <bool> (FuncOverlap != nullptr && "FuncOverlap should be provided in this case"
) ? void (0) : __assert_fail ("FuncOverlap != nullptr && \"FuncOverlap should be provided in this case\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1627, __extension__
 __PRETTY_FUNCTION__))
         "FuncOverlap should be provided in this case")(static_cast <bool> (FuncOverlap != nullptr && "FuncOverlap should be provided in this case"
) ? void (0) : __assert_fail ("FuncOverlap != nullptr && \"FuncOverlap should be provided in this case\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1627, __extension__
 __PRETTY_FUNCTION__));
  FuncInternalSimilarity = computeSampleFunctionInternalOverlap(
      *BaseFunc, *TestFunc, *FuncOverlap);
  // Now, FuncInternalSimilarity may be a little less than 0 due to
  // imprecision of floating point accumulations. Make it zero if the
  // difference is below Epsilon.
  FuncInternalSimilarity = (std::fabs(FuncInternalSimilarity - 0) < Epsilon)
                               ? 0
                               : FuncInternalSimilarity;
}
FuncSimilarity = weightForFuncSimilarity(FuncInternalSimilarity,
                                         BaseFuncSample, TestFuncSample);
return FuncSimilarity;
1640}

1642void SampleOverlapAggregator::computeSampleProfileOverlap(raw_fd_ostream &OS) {
using namespace sampleprof;

std::unordered_map<SampleContext, const FunctionSamples *,
                   SampleContext::Hash>
    BaseFuncProf;
const auto &BaseProfiles = BaseReader->getProfiles();
for (const auto &BaseFunc : BaseProfiles) {
  BaseFuncProf.emplace(BaseFunc.second.getContext(), &(BaseFunc.second));
}
ProfOverlap.UnionCount = BaseFuncProf.size();

const auto &TestProfiles = TestReader->getProfiles();
for (const auto &TestFunc : TestProfiles) {
  SampleOverlapStats FuncOverlap;
  FuncOverlap.TestName = TestFunc.second.getContext();
  assert(TestStats.count(FuncOverlap.TestName) &&(static_cast <bool> (TestStats.count(FuncOverlap.TestName
) && "TestStats should have records for all functions in test profile "
 "except inlinees") ? void (0) : __assert_fail ("TestStats.count(FuncOverlap.TestName) && \"TestStats should have records for all functions in test profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1660, __extension__
 __PRETTY_FUNCTION__))
         "TestStats should have records for all functions in test profile "(static_cast <bool> (TestStats.count(FuncOverlap.TestName
) && "TestStats should have records for all functions in test profile "
 "except inlinees") ? void (0) : __assert_fail ("TestStats.count(FuncOverlap.TestName) && \"TestStats should have records for all functions in test profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1660, __extension__
 __PRETTY_FUNCTION__))
         "except inlinees")(static_cast <bool> (TestStats.count(FuncOverlap.TestName
) && "TestStats should have records for all functions in test profile "
 "except inlinees") ? void (0) : __assert_fail ("TestStats.count(FuncOverlap.TestName) && \"TestStats should have records for all functions in test profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1660, __extension__
 __PRETTY_FUNCTION__));
  FuncOverlap.TestSample = TestStats[FuncOverlap.TestName].SampleSum;

  bool Matched = false;
  const auto Match = BaseFuncProf.find(FuncOverlap.TestName);
  if (Match == BaseFuncProf.end()) {
    const FuncSampleStats &FuncStats = TestStats[FuncOverlap.TestName];
    ++ProfOverlap.TestUniqueCount;
    ProfOverlap.TestUniqueSample += FuncStats.SampleSum;
    FuncOverlap.TestUniqueSample = FuncStats.SampleSum;

    updateHotBlockOverlap(0, FuncStats.SampleSum, FuncStats.HotBlockCount);

    double FuncSimilarity = computeSampleFunctionOverlap(
        nullptr, nullptr, nullptr, 0, FuncStats.SampleSum);
    ProfOverlap.Similarity +=
        weightByImportance(FuncSimilarity, 0, FuncStats.SampleSum);

    ++ProfOverlap.UnionCount;
    ProfOverlap.UnionSample += FuncStats.SampleSum;
  } else {
    ++ProfOverlap.OverlapCount;

    // Two functions match with each other. Compute function-level overlap and
    // aggregate them into profile-level overlap.
    FuncOverlap.BaseName = Match->second->getContext();
    assert(BaseStats.count(FuncOverlap.BaseName) &&(static_cast <bool> (BaseStats.count(FuncOverlap.BaseName
) && "BaseStats should have records for all functions in base profile "
 "except inlinees") ? void (0) : __assert_fail ("BaseStats.count(FuncOverlap.BaseName) && \"BaseStats should have records for all functions in base profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1688, __extension__
 __PRETTY_FUNCTION__))
           "BaseStats should have records for all functions in base profile "(static_cast <bool> (BaseStats.count(FuncOverlap.BaseName
) && "BaseStats should have records for all functions in base profile "
 "except inlinees") ? void (0) : __assert_fail ("BaseStats.count(FuncOverlap.BaseName) && \"BaseStats should have records for all functions in base profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1688, __extension__
 __PRETTY_FUNCTION__))
           "except inlinees")(static_cast <bool> (BaseStats.count(FuncOverlap.BaseName
) && "BaseStats should have records for all functions in base profile "
 "except inlinees") ? void (0) : __assert_fail ("BaseStats.count(FuncOverlap.BaseName) && \"BaseStats should have records for all functions in base profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1688, __extension__
 __PRETTY_FUNCTION__));
    FuncOverlap.BaseSample = BaseStats[FuncOverlap.BaseName].SampleSum;

    FuncOverlap.Similarity = computeSampleFunctionOverlap(
        Match->second, &TestFunc.second, &FuncOverlap, FuncOverlap.BaseSample,
        FuncOverlap.TestSample);
    ProfOverlap.Similarity +=
        weightByImportance(FuncOverlap.Similarity, FuncOverlap.BaseSample,
                           FuncOverlap.TestSample);
    ProfOverlap.OverlapSample += FuncOverlap.OverlapSample;
    ProfOverlap.UnionSample += FuncOverlap.UnionSample;

    // Accumulate the percentage of base unique and test unique samples into
    // ProfOverlap.
    ProfOverlap.BaseUniqueSample += FuncOverlap.BaseUniqueSample;
    ProfOverlap.TestUniqueSample += FuncOverlap.TestUniqueSample;

    // Remove matched base functions for later reporting functions not found
    // in test profile.
    BaseFuncProf.erase(Match);
    Matched = true;
  }

  // Print function-level similarity information if specified by options.
  assert(TestStats.count(FuncOverlap.TestName) &&(static_cast <bool> (TestStats.count(FuncOverlap.TestName
) && "TestStats should have records for all functions in test profile "
 "except inlinees") ? void (0) : __assert_fail ("TestStats.count(FuncOverlap.TestName) && \"TestStats should have records for all functions in test profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1714, __extension__
 __PRETTY_FUNCTION__))
         "TestStats should have records for all functions in test profile "(static_cast <bool> (TestStats.count(FuncOverlap.TestName
) && "TestStats should have records for all functions in test profile "
 "except inlinees") ? void (0) : __assert_fail ("TestStats.count(FuncOverlap.TestName) && \"TestStats should have records for all functions in test profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1714, __extension__
 __PRETTY_FUNCTION__))
         "except inlinees")(static_cast <bool> (TestStats.count(FuncOverlap.TestName
) && "TestStats should have records for all functions in test profile "
 "except inlinees") ? void (0) : __assert_fail ("TestStats.count(FuncOverlap.TestName) && \"TestStats should have records for all functions in test profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1714, __extension__
 __PRETTY_FUNCTION__));
  if (TestStats[FuncOverlap.TestName].MaxSample >= FuncFilter.ValueCutoff ||
      (Matched && FuncOverlap.Similarity < LowSimilarityThreshold) ||
      (Matched && !FuncFilter.NameFilter.empty() &&
       FuncOverlap.BaseName.toString().find(FuncFilter.NameFilter) !=
           std::string::npos)) {
    assert(ProfOverlap.BaseSample > 0 &&(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1721, __extension__
 __PRETTY_FUNCTION__))
           "Total samples in base profile should be greater than 0")(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1721, __extension__
 __PRETTY_FUNCTION__));
    FuncOverlap.BaseWeight =
        static_cast<double>(FuncOverlap.BaseSample) / ProfOverlap.BaseSample;
    assert(ProfOverlap.TestSample > 0 &&(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1725, __extension__
 __PRETTY_FUNCTION__))
           "Total samples in test profile should be greater than 0")(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1725, __extension__
 __PRETTY_FUNCTION__));
    FuncOverlap.TestWeight =
        static_cast<double>(FuncOverlap.TestSample) / ProfOverlap.TestSample;
    FuncSimilarityDump.emplace(FuncOverlap.BaseWeight, FuncOverlap);
  }
}

// Traverse through functions in base profile but not in test profile.
for (const auto &F : BaseFuncProf) {
  assert(BaseStats.count(F.second->getContext()) &&(static_cast <bool> (BaseStats.count(F.second->getContext
()) && "BaseStats should have records for all functions in base profile "
 "except inlinees") ? void (0) : __assert_fail ("BaseStats.count(F.second->getContext()) && \"BaseStats should have records for all functions in base profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1736, __extension__
 __PRETTY_FUNCTION__))
         "BaseStats should have records for all functions in base profile "(static_cast <bool> (BaseStats.count(F.second->getContext
()) && "BaseStats should have records for all functions in base profile "
 "except inlinees") ? void (0) : __assert_fail ("BaseStats.count(F.second->getContext()) && \"BaseStats should have records for all functions in base profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1736, __extension__
 __PRETTY_FUNCTION__))
         "except inlinees")(static_cast <bool> (BaseStats.count(F.second->getContext
()) && "BaseStats should have records for all functions in base profile "
 "except inlinees") ? void (0) : __assert_fail ("BaseStats.count(F.second->getContext()) && \"BaseStats should have records for all functions in base profile \" \"except inlinees\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1736, __extension__
 __PRETTY_FUNCTION__));
  const FuncSampleStats &FuncStats = BaseStats[F.second->getContext()];
  ++ProfOverlap.BaseUniqueCount;
  ProfOverlap.BaseUniqueSample += FuncStats.SampleSum;

  updateHotBlockOverlap(FuncStats.SampleSum, 0, FuncStats.HotBlockCount);

  double FuncSimilarity = computeSampleFunctionOverlap(
      nullptr, nullptr, nullptr, FuncStats.SampleSum, 0);
  ProfOverlap.Similarity +=
      weightByImportance(FuncSimilarity, FuncStats.SampleSum, 0);

  ProfOverlap.UnionSample += FuncStats.SampleSum;
}

// Now, ProfSimilarity may be a little greater than 1 due to imprecision
// of floating point accumulations. Make it 1.0 if the difference is below
// Epsilon.
ProfOverlap.Similarity = (std::fabs(ProfOverlap.Similarity - 1) < Epsilon)
                             ? 1
                             : ProfOverlap.Similarity;

computeHotFuncOverlap();
1759}

1761void SampleOverlapAggregator::initializeSampleProfileOverlap() {
const auto &BaseProf = BaseReader->getProfiles();
for (const auto &I : BaseProf) {
  ++ProfOverlap.BaseCount;
  FuncSampleStats FuncStats;
  getFuncSampleStats(I.second, FuncStats, BaseHotThreshold);
  ProfOverlap.BaseSample += FuncStats.SampleSum;
  BaseStats.emplace(I.second.getContext(), FuncStats);
}

const auto &TestProf = TestReader->getProfiles();
for (const auto &I : TestProf) {
  ++ProfOverlap.TestCount;
  FuncSampleStats FuncStats;
  getFuncSampleStats(I.second, FuncStats, TestHotThreshold);
  ProfOverlap.TestSample += FuncStats.SampleSum;
  TestStats.emplace(I.second.getContext(), FuncStats);
}

ProfOverlap.BaseName = StringRef(BaseFilename);
ProfOverlap.TestName = StringRef(TestFilename);
1782}

1784void SampleOverlapAggregator::dumpFuncSimilarity(raw_fd_ostream &OS) const {
using namespace sampleprof;

if (FuncSimilarityDump.empty())
  return;

formatted_raw_ostream FOS(OS);
FOS << "Function-level details:\n";
FOS << "Base weight";
FOS.PadToColumn(TestWeightCol);
FOS << "Test weight";
FOS.PadToColumn(SimilarityCol);
FOS << "Similarity";
FOS.PadToColumn(OverlapCol);
FOS << "Overlap";
FOS.PadToColumn(BaseUniqueCol);
FOS << "Base unique";
FOS.PadToColumn(TestUniqueCol);
FOS << "Test unique";
FOS.PadToColumn(BaseSampleCol);
FOS << "Base samples";
FOS.PadToColumn(TestSampleCol);
FOS << "Test samples";
FOS.PadToColumn(FuncNameCol);
FOS << "Function name\n";
for (const auto &F : FuncSimilarityDump) {
  double OverlapPercent =
      F.second.UnionSample > 0
          ? static_cast<double>(F.second.OverlapSample) / F.second.UnionSample
          : 0;
  double BaseUniquePercent =
      F.second.BaseSample > 0
          ? static_cast<double>(F.second.BaseUniqueSample) /
                F.second.BaseSample
          : 0;
  double TestUniquePercent =
      F.second.TestSample > 0
          ? static_cast<double>(F.second.TestUniqueSample) /
                F.second.TestSample
          : 0;

  FOS << format("%.2f%%", F.second.BaseWeight * 100);
  FOS.PadToColumn(TestWeightCol);
  FOS << format("%.2f%%", F.second.TestWeight * 100);
  FOS.PadToColumn(SimilarityCol);
  FOS << format("%.2f%%", F.second.Similarity * 100);
  FOS.PadToColumn(OverlapCol);
  FOS << format("%.2f%%", OverlapPercent * 100);
  FOS.PadToColumn(BaseUniqueCol);
  FOS << format("%.2f%%", BaseUniquePercent * 100);
  FOS.PadToColumn(TestUniqueCol);
  FOS << format("%.2f%%", TestUniquePercent * 100);
  FOS.PadToColumn(BaseSampleCol);
  FOS << F.second.BaseSample;
  FOS.PadToColumn(TestSampleCol);
  FOS << F.second.TestSample;
  FOS.PadToColumn(FuncNameCol);
  FOS << F.second.TestName.toString() << "\n";
}
1843}

1845void SampleOverlapAggregator::dumpProgramSummary(raw_fd_ostream &OS) const {
OS << "Profile overlap infomation for base_profile: "
   << ProfOverlap.BaseName.toString()
   << " and test_profile: " << ProfOverlap.TestName.toString()
   << "\nProgram level:\n";

OS << "  Whole program profile similarity: "
   << format("%.3f%%", ProfOverlap.Similarity * 100) << "\n";

assert(ProfOverlap.UnionSample > 0 &&(static_cast <bool> (ProfOverlap.UnionSample > 0 &&
 "Total samples in two profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.UnionSample > 0 && \"Total samples in two profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1855, __extension__
 __PRETTY_FUNCTION__))
       "Total samples in two profile should be greater than 0")(static_cast <bool> (ProfOverlap.UnionSample > 0 &&
 "Total samples in two profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.UnionSample > 0 && \"Total samples in two profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1855, __extension__
 __PRETTY_FUNCTION__));
double OverlapPercent =
    static_cast<double>(ProfOverlap.OverlapSample) / ProfOverlap.UnionSample;
assert(ProfOverlap.BaseSample > 0 &&(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1859, __extension__
 __PRETTY_FUNCTION__))
       "Total samples in base profile should be greater than 0")(static_cast <bool> (ProfOverlap.BaseSample > 0 &&
 "Total samples in base profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.BaseSample > 0 && \"Total samples in base profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1859, __extension__
 __PRETTY_FUNCTION__));
double BaseUniquePercent = static_cast<double>(ProfOverlap.BaseUniqueSample) /
                           ProfOverlap.BaseSample;
assert(ProfOverlap.TestSample > 0 &&(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1863, __extension__
 __PRETTY_FUNCTION__))
       "Total samples in test profile should be greater than 0")(static_cast <bool> (ProfOverlap.TestSample > 0 &&
 "Total samples in test profile should be greater than 0") ? void
 (0) : __assert_fail ("ProfOverlap.TestSample > 0 && \"Total samples in test profile should be greater than 0\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1863, __extension__
 __PRETTY_FUNCTION__));
double TestUniquePercent = static_cast<double>(ProfOverlap.TestUniqueSample) /
                           ProfOverlap.TestSample;

OS << "  Whole program sample overlap: "
   << format("%.3f%%", OverlapPercent * 100) << "\n";
OS << "    percentage of samples unique in base profile: "
   << format("%.3f%%", BaseUniquePercent * 100) << "\n";
OS << "    percentage of samples unique in test profile: "
   << format("%.3f%%", TestUniquePercent * 100) << "\n";
OS << "    total samples in base profile: " << ProfOverlap.BaseSample << "\n"
   << "    total samples in test profile: " << ProfOverlap.TestSample << "\n";

assert(ProfOverlap.UnionCount > 0 &&(static_cast <bool> (ProfOverlap.UnionCount > 0 &&
 "There should be at least one function in two input profiles"
) ? void (0) : __assert_fail ("ProfOverlap.UnionCount > 0 && \"There should be at least one function in two input profiles\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1877, __extension__
 __PRETTY_FUNCTION__))
       "There should be at least one function in two input profiles")(static_cast <bool> (ProfOverlap.UnionCount > 0 &&
 "There should be at least one function in two input profiles"
) ? void (0) : __assert_fail ("ProfOverlap.UnionCount > 0 && \"There should be at least one function in two input profiles\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1877, __extension__
 __PRETTY_FUNCTION__));
double FuncOverlapPercent =
    static_cast<double>(ProfOverlap.OverlapCount) / ProfOverlap.UnionCount;
OS << "  Function overlap: " << format("%.3f%%", FuncOverlapPercent * 100)
   << "\n";
OS << "    overlap functions: " << ProfOverlap.OverlapCount << "\n";
OS << "    functions unique in base profile: " << ProfOverlap.BaseUniqueCount
   << "\n";
OS << "    functions unique in test profile: " << ProfOverlap.TestUniqueCount
   << "\n";
1887}

1889void SampleOverlapAggregator::dumpHotFuncAndBlockOverlap(
  raw_fd_ostream &OS) const {
assert(HotFuncOverlap.UnionCount > 0 &&(static_cast <bool> (HotFuncOverlap.UnionCount > 0 &&
 "There should be at least one hot function in two input profiles"
) ? void (0) : __assert_fail ("HotFuncOverlap.UnionCount > 0 && \"There should be at least one hot function in two input profiles\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1892, __extension__
 __PRETTY_FUNCTION__))
       "There should be at least one hot function in two input profiles")(static_cast <bool> (HotFuncOverlap.UnionCount > 0 &&
 "There should be at least one hot function in two input profiles"
) ? void (0) : __assert_fail ("HotFuncOverlap.UnionCount > 0 && \"There should be at least one hot function in two input profiles\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1892, __extension__
 __PRETTY_FUNCTION__));
OS << "  Hot-function overlap: "
   << format("%.3f%%", static_cast<double>(HotFuncOverlap.OverlapCount) /
                           HotFuncOverlap.UnionCount * 100)
   << "\n";
OS << "    overlap hot functions: " << HotFuncOverlap.OverlapCount << "\n";
OS << "    hot functions unique in base profile: "
   << HotFuncOverlap.BaseCount - HotFuncOverlap.OverlapCount << "\n";
OS << "    hot functions unique in test profile: "
   << HotFuncOverlap.TestCount - HotFuncOverlap.OverlapCount << "\n";

assert(HotBlockOverlap.UnionCount > 0 &&(static_cast <bool> (HotBlockOverlap.UnionCount > 0 &&
 "There should be at least one hot block in two input profiles"
) ? void (0) : __assert_fail ("HotBlockOverlap.UnionCount > 0 && \"There should be at least one hot block in two input profiles\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1904, __extension__
 __PRETTY_FUNCTION__))
       "There should be at least one hot block in two input profiles")(static_cast <bool> (HotBlockOverlap.UnionCount > 0 &&
 "There should be at least one hot block in two input profiles"
) ? void (0) : __assert_fail ("HotBlockOverlap.UnionCount > 0 && \"There should be at least one hot block in two input profiles\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 1904, __extension__
 __PRETTY_FUNCTION__));
OS << "  Hot-block overlap: "
   << format("%.3f%%", static_cast<double>(HotBlockOverlap.OverlapCount) /
                           HotBlockOverlap.UnionCount * 100)
   << "\n";
OS << "    overlap hot blocks: " << HotBlockOverlap.OverlapCount << "\n";
OS << "    hot blocks unique in base profile: "
   << HotBlockOverlap.BaseCount - HotBlockOverlap.OverlapCount << "\n";
OS << "    hot blocks unique in test profile: "
   << HotBlockOverlap.TestCount - HotBlockOverlap.OverlapCount << "\n";
1914}

1916std::error_code SampleOverlapAggregator::loadProfiles() {
using namespace sampleprof;

LLVMContext Context;
auto BaseReaderOrErr = SampleProfileReader::create(BaseFilename, Context,
                                                   FSDiscriminatorPassOption);
if (std::error_code EC = BaseReaderOrErr.getError())
  exitWithErrorCode(EC, BaseFilename);

auto TestReaderOrErr = SampleProfileReader::create(TestFilename, Context,
                                                   FSDiscriminatorPassOption);
if (std::error_code EC = TestReaderOrErr.getError())
  exitWithErrorCode(EC, TestFilename);

BaseReader = std::move(BaseReaderOrErr.get());
TestReader = std::move(TestReaderOrErr.get());

if (std::error_code EC = BaseReader->read())
  exitWithErrorCode(EC, BaseFilename);
if (std::error_code EC = TestReader->read())
  exitWithErrorCode(EC, TestFilename);
if (BaseReader->profileIsProbeBased() != TestReader->profileIsProbeBased())
  exitWithError(
      "cannot compare probe-based profile with non-probe-based profile");
if (BaseReader->profileIsCSFlat() != TestReader->profileIsCSFlat())
  exitWithError("cannot compare CS profile with non-CS profile");

// Load BaseHotThreshold and TestHotThreshold as 99-percentile threshold in
// profile summary.
ProfileSummary &BasePS = BaseReader->getSummary();
ProfileSummary &TestPS = TestReader->getSummary();
BaseHotThreshold =
    ProfileSummaryBuilder::getHotCountThreshold(BasePS.getDetailedSummary());
TestHotThreshold =
    ProfileSummaryBuilder::getHotCountThreshold(TestPS.getDetailedSummary());

return std::error_code();
1953}

1955void overlapSampleProfile(const std::string &BaseFilename,
                        const std::string &TestFilename,
                        const OverlapFuncFilters &FuncFilter,
                        uint64_t SimilarityCutoff, raw_fd_ostream &OS) {
using namespace sampleprof;

// We use 0.000005 to initialize OverlapAggr.Epsilon because the final metrics
// report 2--3 places after decimal point in percentage numbers.
SampleOverlapAggregator OverlapAggr(
    BaseFilename, TestFilename,
    static_cast<double>(SimilarityCutoff) / 1000000, 0.000005, FuncFilter);
if (std::error_code EC = OverlapAggr.loadProfiles())
  exitWithErrorCode(EC);

OverlapAggr.initializeSampleProfileOverlap();
if (OverlapAggr.detectZeroSampleProfile(OS))
  return;

OverlapAggr.computeSampleProfileOverlap(OS);

OverlapAggr.dumpProgramSummary(OS);
OverlapAggr.dumpHotFuncAndBlockOverlap(OS);
OverlapAggr.dumpFuncSimilarity(OS);
1978}

1980static int overlap_main(int argc, const char *argv[]) {
cl::opt<std::string> BaseFilename(cl::Positional, cl::Required,
                                  cl::desc("<base profile file>"));
cl::opt<std::string> TestFilename(cl::Positional, cl::Required,
                                  cl::desc("<test profile file>"));
cl::opt<std::string> Output("output", cl::value_desc("output"), cl::init("-"),
                            cl::desc("Output file"));
cl::alias OutputA("o", cl::desc("Alias for --output"), cl::aliasopt(Output));
cl::opt<bool> IsCS(
    "cs", cl::init(false),
    cl::desc("For context sensitive PGO counts. Does not work with CSSPGO."));
cl::opt<unsigned long long> ValueCutoff(
    "value-cutoff", cl::init(-1),
    cl::desc(
        "Function level overlap information for every function (with calling "
        "context for csspgo) in test "
        "profile with max count value greater then the parameter value"));
cl::opt<std::string> FuncNameFilter(
    "function",
    cl::desc("Function level overlap information for matching functions. For "
             "CSSPGO this takes a a function name with calling context"));
cl::opt<unsigned long long> SimilarityCutoff(
    "similarity-cutoff", cl::init(0),
    cl::desc("For sample profiles, list function names (with calling context "
             "for csspgo) for overlapped functions "
             "with similarities below the cutoff (percentage times 10000)."));
cl::opt<ProfileKinds> ProfileKind(
    cl::desc("Profile kind:"), cl::init(instr),
    cl::values(clEnumVal(instr, "Instrumentation profile (default)")llvm::cl::OptionEnumValue { "instr", int(instr), "Instrumentation profile (default)"
 },
               clEnumVal(sample, "Sample profile")llvm::cl::OptionEnumValue { "sample", int(sample), "Sample profile"
 }));
cl::ParseCommandLineOptions(argc, argv, "LLVM profile data overlap tool\n");

std::error_code EC;
raw_fd_ostream OS(Output.data(), EC, sys::fs::OF_TextWithCRLF);
if (EC)
  exitWithErrorCode(EC, Output);

if (ProfileKind == instr)
  overlapInstrProfile(BaseFilename, TestFilename,
                      OverlapFuncFilters{ValueCutoff, FuncNameFilter}, OS,
                      IsCS);
else
  overlapSampleProfile(BaseFilename, TestFilename,
                       OverlapFuncFilters{ValueCutoff, FuncNameFilter},
                       SimilarityCutoff, OS);

return 0;
2027}

2029namespace {
2030struct ValueSitesStats {
ValueSitesStats()
    : TotalNumValueSites(0), TotalNumValueSitesWithValueProfile(0),
      TotalNumValues(0) {}
uint64_t TotalNumValueSites;
uint64_t TotalNumValueSitesWithValueProfile;
uint64_t TotalNumValues;
std::vector<unsigned> ValueSitesHistogram;
2038};
2039} // namespace

2041static void traverseAllValueSites(const InstrProfRecord &Func, uint32_t VK,
                                ValueSitesStats &Stats, raw_fd_ostream &OS,
                                InstrProfSymtab *Symtab) {
uint32_t NS = Func.getNumValueSites(VK);
Stats.TotalNumValueSites += NS;
for (size_t I = 0; I < NS; ++I) {
  uint32_t NV = Func.getNumValueDataForSite(VK, I);
  std::unique_ptr<InstrProfValueData[]> VD = Func.getValueForSite(VK, I);
  Stats.TotalNumValues += NV;
  if (NV) {
    Stats.TotalNumValueSitesWithValueProfile++;
    if (NV > Stats.ValueSitesHistogram.size())
      Stats.ValueSitesHistogram.resize(NV, 0);
    Stats.ValueSitesHistogram[NV - 1]++;
  }

  uint64_t SiteSum = 0;
  for (uint32_t V = 0; V < NV; V++)
    SiteSum += VD[V].Count;
  if (SiteSum == 0)
    SiteSum = 1;

  for (uint32_t V = 0; V < NV; V++) {
    OS << "\t[ " << format("%2u", I) << ", ";
    if (Symtab == nullptr)
      OS << format("%4" PRIu64"l" "u", VD[V].Value);
    else
      OS << Symtab->getFuncName(VD[V].Value);
    OS << ", " << format("%10" PRId64"l" "d", VD[V].Count) << " ] ("
       << format("%.2f%%", (VD[V].Count * 100.0 / SiteSum)) << ")\n";
  }
}
2073}

2075static void showValueSitesStats(raw_fd_ostream &OS, uint32_t VK,
                              ValueSitesStats &Stats) {
OS << "  Total number of sites: " << Stats.TotalNumValueSites << "\n";
OS << "  Total number of sites with values: "
   << Stats.TotalNumValueSitesWithValueProfile << "\n";
OS << "  Total number of profiled values: " << Stats.TotalNumValues << "\n";

OS << "  Value sites histogram:\n\tNumTargets, SiteCount\n";
for (unsigned I = 0; I < Stats.ValueSitesHistogram.size(); I++) {
  if (Stats.ValueSitesHistogram[I] > 0)
    OS << "\t" << I + 1 << ", " << Stats.ValueSitesHistogram[I] << "\n";
}
2087}

2089static int showInstrProfile(const std::string &Filename, bool ShowCounts,
                          uint32_t TopN, bool ShowIndirectCallTargets,
                          bool ShowMemOPSizes, bool ShowDetailedSummary,
                          std::vector<uint32_t> DetailedSummaryCutoffs,
                          bool ShowAllFunctions, bool ShowCS,
                          uint64_t ValueCutoff, bool OnlyListBelow,
                          const std::string &ShowFunction, bool TextFormat,
                          bool ShowBinaryIds, bool ShowCovered,
                          raw_fd_ostream &OS) {
auto ReaderOrErr = InstrProfReader::create(Filename);
std::vector<uint32_t> Cutoffs = std::move(DetailedSummaryCutoffs);
if (ShowDetailedSummary && Cutoffs.empty()) {
1
Assuming 'ShowDetailedSummary' is false→
  Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
}
InstrProfSummaryBuilder Builder(std::move(Cutoffs));
if (Error E = ReaderOrErr.takeError())
2
←
Assuming the condition is true→
3
←
Taking true branch→
  exitWithError(std::move(E), Filename);
4
←
Calling 'exitWithError'→

auto Reader = std::move(ReaderOrErr.get());
bool IsIRInstr = Reader->isIRLevelProfile();
size_t ShownFunctions = 0;
size_t BelowCutoffFunctions = 0;
int NumVPKind = IPVK_Last - IPVK_First + 1;
std::vector<ValueSitesStats> VPStats(NumVPKind);

auto MinCmp = [](const std::pair<std::string, uint64_t> &v1,
                 const std::pair<std::string, uint64_t> &v2) {
  return v1.second > v2.second;
};

std::priority_queue<std::pair<std::string, uint64_t>,
                    std::vector<std::pair<std::string, uint64_t>>,
                    decltype(MinCmp)>
    HottestFuncs(MinCmp);

if (!TextFormat && OnlyListBelow) {
  OS << "The list of functions with the maximum counter less than "
     << ValueCutoff << ":\n";
}

// Add marker so that IR-level instrumentation round-trips properly.
if (TextFormat && IsIRInstr)
  OS << ":ir\n";

for (const auto &Func : *Reader) {
  if (Reader->isIRLevelProfile()) {
    bool FuncIsCS = NamedInstrProfRecord::hasCSFlagInHash(Func.Hash);
    if (FuncIsCS != ShowCS)
      continue;
  }
  bool Show = ShowAllFunctions ||
              (!ShowFunction.empty() && Func.Name.contains(ShowFunction));

  bool doTextFormatDump = (Show && TextFormat);

  if (doTextFormatDump) {
    InstrProfSymtab &Symtab = Reader->getSymtab();
    InstrProfWriter::writeRecordInText(Func.Name, Func.Hash, Func, Symtab,
                                       OS);
    continue;
  }

  assert(Func.Counts.size() > 0 && "function missing entry counter")(static_cast <bool> (Func.Counts.size() > 0 &&
 "function missing entry counter") ? void (0) : __assert_fail
 ("Func.Counts.size() > 0 && \"function missing entry counter\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 2151, __extension__
 __PRETTY_FUNCTION__));
  Builder.addRecord(Func);

  if (ShowCovered) {
    if (std::any_of(Func.Counts.begin(), Func.Counts.end(),
                    [](uint64_t C) { return C; }))
      OS << Func.Name << "\n";
    continue;
  }

  uint64_t FuncMax = 0;
  uint64_t FuncSum = 0;
  for (size_t I = 0, E = Func.Counts.size(); I < E; ++I) {
    if (Func.Counts[I] == (uint64_t)-1)
      continue;
    FuncMax = std::max(FuncMax, Func.Counts[I]);
    FuncSum += Func.Counts[I];
  }

  if (FuncMax < ValueCutoff) {
    ++BelowCutoffFunctions;
    if (OnlyListBelow) {
      OS << "  " << Func.Name << ": (Max = " << FuncMax
         << " Sum = " << FuncSum << ")\n";
    }
    continue;
  } else if (OnlyListBelow)
    continue;

  if (TopN) {
    if (HottestFuncs.size() == TopN) {
      if (HottestFuncs.top().second < FuncMax) {
        HottestFuncs.pop();
        HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
      }
    } else
      HottestFuncs.emplace(std::make_pair(std::string(Func.Name), FuncMax));
  }

  if (Show) {
    if (!ShownFunctions)
      OS << "Counters:\n";

    ++ShownFunctions;

    OS << "  " << Func.Name << ":\n"
       << "    Hash: " << format("0x%016" PRIx64"l" "x", Func.Hash) << "\n"
       << "    Counters: " << Func.Counts.size() << "\n";
    if (!IsIRInstr)
      OS << "    Function count: " << Func.Counts[0] << "\n";

    if (ShowIndirectCallTargets)
      OS << "    Indirect Call Site Count: "
         << Func.getNumValueSites(IPVK_IndirectCallTarget) << "\n";

    uint32_t NumMemOPCalls = Func.getNumValueSites(IPVK_MemOPSize);
    if (ShowMemOPSizes && NumMemOPCalls > 0)
      OS << "    Number of Memory Intrinsics Calls: " << NumMemOPCalls
         << "\n";

    if (ShowCounts) {
      OS << "    Block counts: [";
      size_t Start = (IsIRInstr ? 0 : 1);
      for (size_t I = Start, E = Func.Counts.size(); I < E; ++I) {
        OS << (I == Start ? "" : ", ") << Func.Counts[I];
      }
      OS << "]\n";
    }

    if (ShowIndirectCallTargets) {
      OS << "    Indirect Target Results:\n";
      traverseAllValueSites(Func, IPVK_IndirectCallTarget,
                            VPStats[IPVK_IndirectCallTarget], OS,
                            &(Reader->getSymtab()));
    }

    if (ShowMemOPSizes && NumMemOPCalls > 0) {
      OS << "    Memory Intrinsic Size Results:\n";
      traverseAllValueSites(Func, IPVK_MemOPSize, VPStats[IPVK_MemOPSize], OS,
                            nullptr);
    }
  }
}
if (Reader->hasError())
  exitWithError(Reader->getError(), Filename);

if (TextFormat || ShowCovered)
  return 0;
std::unique_ptr<ProfileSummary> PS(Builder.getSummary());
bool IsIR = Reader->isIRLevelProfile();
OS << "Instrumentation level: " << (IsIR ? "IR" : "Front-end");
if (IsIR)
  OS << "  entry_first = " << Reader->instrEntryBBEnabled();
OS << "\n";
if (ShowAllFunctions || !ShowFunction.empty())
  OS << "Functions shown: " << ShownFunctions << "\n";
OS << "Total functions: " << PS->getNumFunctions() << "\n";
if (ValueCutoff > 0) {
  OS << "Number of functions with maximum count (< " << ValueCutoff
     << "): " << BelowCutoffFunctions << "\n";
  OS << "Number of functions with maximum count (>= " << ValueCutoff
     << "): " << PS->getNumFunctions() - BelowCutoffFunctions << "\n";
}
OS << "Maximum function count: " << PS->getMaxFunctionCount() << "\n";
OS << "Maximum internal block count: " << PS->getMaxInternalCount() << "\n";

if (TopN) {
  std::vector<std::pair<std::string, uint64_t>> SortedHottestFuncs;
  while (!HottestFuncs.empty()) {
    SortedHottestFuncs.emplace_back(HottestFuncs.top());
    HottestFuncs.pop();
  }
  OS << "Top " << TopN
     << " functions with the largest internal block counts: \n";
  for (auto &hotfunc : llvm::reverse(SortedHottestFuncs))
    OS << "  " << hotfunc.first << ", max count = " << hotfunc.second << "\n";
}

if (ShownFunctions && ShowIndirectCallTargets) {
  OS << "Statistics for indirect call sites profile:\n";
  showValueSitesStats(OS, IPVK_IndirectCallTarget,
                      VPStats[IPVK_IndirectCallTarget]);
}

if (ShownFunctions && ShowMemOPSizes) {
  OS << "Statistics for memory intrinsic calls sizes profile:\n";
  showValueSitesStats(OS, IPVK_MemOPSize, VPStats[IPVK_MemOPSize]);
}

if (ShowDetailedSummary) {
  OS << "Total number of blocks: " << PS->getNumCounts() << "\n";
  OS << "Total count: " << PS->getTotalCount() << "\n";
  PS->printDetailedSummary(OS);
}

if (ShowBinaryIds)
  if (Error E = Reader->printBinaryIds(OS))
    exitWithError(std::move(E), Filename);

return 0;
2291}

2293static void showSectionInfo(sampleprof::SampleProfileReader *Reader,
                          raw_fd_ostream &OS) {
if (!Reader->dumpSectionInfo(OS)) {
  WithColor::warning() << "-show-sec-info-only is only supported for "
                       << "sample profile in extbinary format and is "
                       << "ignored for other formats.\n";
  return;
}
2301}

2303namespace {
2304struct HotFuncInfo {
std::string FuncName;
uint64_t TotalCount;
double TotalCountPercent;
uint64_t MaxCount;
uint64_t EntryCount;

HotFuncInfo()
    : TotalCount(0), TotalCountPercent(0.0f), MaxCount(0), EntryCount(0) {}

HotFuncInfo(StringRef FN, uint64_t TS, double TSP, uint64_t MS, uint64_t ES)
    : FuncName(FN.begin(), FN.end()), TotalCount(TS), TotalCountPercent(TSP),
      MaxCount(MS), EntryCount(ES) {}
2317};
2318} // namespace

2320// Print out detailed information about hot functions in PrintValues vector.
2321// Users specify titles and offset of every columns through ColumnTitle and
2322// ColumnOffset. The size of ColumnTitle and ColumnOffset need to be the same
2323// and at least 4. Besides, users can optionally give a HotFuncMetric string to
2324// print out or let it be an empty string.
2325static void dumpHotFunctionList(const std::vector<std::string> &ColumnTitle,
                              const std::vector<int> &ColumnOffset,
                              const std::vector<HotFuncInfo> &PrintValues,
                              uint64_t HotFuncCount, uint64_t TotalFuncCount,
                              uint64_t HotProfCount, uint64_t TotalProfCount,
                              const std::string &HotFuncMetric,
                              uint32_t TopNFunctions, raw_fd_ostream &OS) {
assert(ColumnOffset.size() == ColumnTitle.size() &&(static_cast <bool> (ColumnOffset.size() == ColumnTitle
.size() && "ColumnOffset and ColumnTitle should have the same size"
) ? void (0) : __assert_fail ("ColumnOffset.size() == ColumnTitle.size() && \"ColumnOffset and ColumnTitle should have the same size\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 2333, __extension__
 __PRETTY_FUNCTION__))
       "ColumnOffset and ColumnTitle should have the same size")(static_cast <bool> (ColumnOffset.size() == ColumnTitle
.size() && "ColumnOffset and ColumnTitle should have the same size"
) ? void (0) : __assert_fail ("ColumnOffset.size() == ColumnTitle.size() && \"ColumnOffset and ColumnTitle should have the same size\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 2333, __extension__
 __PRETTY_FUNCTION__));
assert(ColumnTitle.size() >= 4 &&(static_cast <bool> (ColumnTitle.size() >= 4 &&
 "ColumnTitle should have at least 4 elements") ? void (0) : __assert_fail
 ("ColumnTitle.size() >= 4 && \"ColumnTitle should have at least 4 elements\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 2335, __extension__
 __PRETTY_FUNCTION__))
       "ColumnTitle should have at least 4 elements")(static_cast <bool> (ColumnTitle.size() >= 4 &&
 "ColumnTitle should have at least 4 elements") ? void (0) : __assert_fail
 ("ColumnTitle.size() >= 4 && \"ColumnTitle should have at least 4 elements\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 2335, __extension__
 __PRETTY_FUNCTION__));
assert(TotalFuncCount > 0 &&(static_cast <bool> (TotalFuncCount > 0 && "There should be at least one function in the profile"
) ? void (0) : __assert_fail ("TotalFuncCount > 0 && \"There should be at least one function in the profile\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 2337, __extension__
 __PRETTY_FUNCTION__))
       "There should be at least one function in the profile")(static_cast <bool> (TotalFuncCount > 0 && "There should be at least one function in the profile"
) ? void (0) : __assert_fail ("TotalFuncCount > 0 && \"There should be at least one function in the profile\""
, "llvm/tools/llvm-profdata/llvm-profdata.cpp", 2337, __extension__
 __PRETTY_FUNCTION__));
double TotalProfPercent = 0;
if (TotalProfCount > 0)
  TotalProfPercent = static_cast<double>(HotProfCount) / TotalProfCount * 100;

formatted_raw_ostream FOS(OS);
FOS << HotFuncCount << " out of " << TotalFuncCount
    << " functions with profile ("
    << format("%.2f%%",
              (static_cast<double>(HotFuncCount) / TotalFuncCount * 100))
    << ") are considered hot functions";
if (!HotFuncMetric.empty())
  FOS << " (" << HotFuncMetric << ")";
FOS << ".\n";
FOS << HotProfCount << " out of " << TotalProfCount << " profile counts ("
    << format("%.2f%%", TotalProfPercent) << ") are from hot functions.\n";

for (size_t I = 0; I < ColumnTitle.size(); ++I) {
  FOS.PadToColumn(ColumnOffset[I]);
  FOS << ColumnTitle[I];
}
FOS << "\n";

uint32_t Count = 0;
for (const auto &R : PrintValues) {
  if (TopNFunctions && (Count++ == TopNFunctions))
    break;
  FOS.PadToColumn(ColumnOffset[0]);
  FOS << R.TotalCount << " (" << format("%.2f%%", R.TotalCountPercent) << ")";
  FOS.PadToColumn(ColumnOffset[1]);
  FOS << R.MaxCount;
  FOS.PadToColumn(ColumnOffset[2]);
  FOS << R.EntryCount;
  FOS.PadToColumn(ColumnOffset[3]);
  FOS << R.FuncName << "\n";
}
2373}

2375static int showHotFunctionList(const sampleprof::SampleProfileMap &Profiles,
                             ProfileSummary &PS, uint32_t TopN,
                             raw_fd_ostream &OS) {
using namespace sampleprof;

const uint32_t HotFuncCutoff = 990000;
auto &SummaryVector = PS.getDetailedSummary();
uint64_t MinCountThreshold = 0;
for (const ProfileSummaryEntry &SummaryEntry : SummaryVector) {
  if (SummaryEntry.Cutoff == HotFuncCutoff) {
    MinCountThreshold = SummaryEntry.MinCount;
    break;
  }
}

// Traverse all functions in the profile and keep only hot functions.
// The following loop also calculates the sum of total samples of all
// functions.
std::multimap<uint64_t, std::pair<const FunctionSamples *, const uint64_t>,
              std::greater<uint64_t>>
    HotFunc;
uint64_t ProfileTotalSample = 0;
uint64_t HotFuncSample = 0;
uint64_t HotFuncCount = 0;

for (const auto &I : Profiles) {
  FuncSampleStats FuncStats;
  const FunctionSamples &FuncProf = I.second;
  ProfileTotalSample += FuncProf.getTotalSamples();
  getFuncSampleStats(FuncProf, FuncStats, MinCountThreshold);

  if (isFunctionHot(FuncStats, MinCountThreshold)) {
    HotFunc.emplace(FuncProf.getTotalSamples(),
                    std::make_pair(&(I.second), FuncStats.MaxSample));
    HotFuncSample += FuncProf.getTotalSamples();
    ++HotFuncCount;
  }
}

std::vector<std::string> ColumnTitle{"Total sample (%)", "Max sample",
                                     "Entry sample", "Function name"};
std::vector<int> ColumnOffset{0, 24, 42, 58};
std::string Metric =
    std::string("max sample >= ") + std::to_string(MinCountThreshold);
std::vector<HotFuncInfo> PrintValues;
for (const auto &FuncPair : HotFunc) {
  const FunctionSamples &Func = *FuncPair.second.first;
  double TotalSamplePercent =
      (ProfileTotalSample > 0)
          ? (Func.getTotalSamples() * 100.0) / ProfileTotalSample
          : 0;
  PrintValues.emplace_back(HotFuncInfo(
      Func.getContext().toString(), Func.getTotalSamples(),
      TotalSamplePercent, FuncPair.second.second, Func.getEntrySamples()));
}
dumpHotFunctionList(ColumnTitle, ColumnOffset, PrintValues, HotFuncCount,
                    Profiles.size(), HotFuncSample, ProfileTotalSample,
                    Metric, TopN, OS);

return 0;
2435}

2437static int showSampleProfile(const std::string &Filename, bool ShowCounts,
                           uint32_t TopN, bool ShowAllFunctions,
                           bool ShowDetailedSummary,
                           const std::string &ShowFunction,
                           bool ShowProfileSymbolList,
                           bool ShowSectionInfoOnly, bool ShowHotFuncList,
                           raw_fd_ostream &OS) {
using namespace sampleprof;
LLVMContext Context;
auto ReaderOrErr =
    SampleProfileReader::create(Filename, Context, FSDiscriminatorPassOption);
if (std::error_code EC = ReaderOrErr.getError())
  exitWithErrorCode(EC, Filename);

auto Reader = std::move(ReaderOrErr.get());
if (ShowSectionInfoOnly) {
  showSectionInfo(Reader.get(), OS);
  return 0;
}

if (std::error_code EC = Reader->read())
  exitWithErrorCode(EC, Filename);

if (ShowAllFunctions || ShowFunction.empty())
  Reader->dump(OS);
else
  // TODO: parse context string to support filtering by contexts.
  Reader->dumpFunctionProfile(StringRef(ShowFunction), OS);

if (ShowProfileSymbolList) {
  std::unique_ptr<sampleprof::ProfileSymbolList> ReaderList =
      Reader->getProfileSymbolList();
  ReaderList->dump(OS);
}

if (ShowDetailedSummary) {
  auto &PS = Reader->getSummary();
  PS.printSummary(OS);
  PS.printDetailedSummary(OS);
}

if (ShowHotFuncList || TopN)
  showHotFunctionList(Reader->getProfiles(), Reader->getSummary(), TopN, OS);

return 0;
2482}

2484static int showMemProfProfile(const std::string &Filename,
                            const std::string &ProfiledBinary,
                            raw_fd_ostream &OS) {
auto ReaderOr =
    llvm::memprof::RawMemProfReader::create(Filename, ProfiledBinary);
if (Error E = ReaderOr.takeError())
  // Since the error can be related to the profile or the binary we do not
  // pass whence. Instead additional context is provided where necessary in
  // the error message.
  exitWithError(std::move(E), /*Whence*/ "");

std::unique_ptr<llvm::memprof::RawMemProfReader> Reader(
    ReaderOr.get().release());

Reader->printYAML(OS);
return 0;
2500}

2502static int showDebugInfoCorrelation(const std::string &Filename,
                                  bool ShowDetailedSummary,
                                  bool ShowProfileSymbolList,
                                  raw_fd_ostream &OS) {
std::unique_ptr<InstrProfCorrelator> Correlator;
if (auto Err = InstrProfCorrelator::get(Filename).moveInto(Correlator))
  exitWithError(std::move(Err), Filename);
if (auto Err = Correlator->correlateProfileData())
  exitWithError(std::move(Err), Filename);

InstrProfSymtab Symtab;
if (auto Err = Symtab.create(
        StringRef(Correlator->getNamesPointer(), Correlator->getNamesSize())))
  exitWithError(std::move(Err), Filename);

if (ShowProfileSymbolList)
  Symtab.dumpNames(OS);
// TODO: Read "Profile Data Type" from debug info to compute and show how many
// counters the section holds.
if (ShowDetailedSummary)
  OS << "Counters section size: 0x"
     << Twine::utohexstr(Correlator->getCountersSectionSize()) << " bytes\n";
OS << "Found " << Correlator->getDataSize() << " functions\n";

return 0;
2527}

2529static int show_main(int argc, const char *argv[]) {
cl::opt<std::string> Filename(cl::Positional, cl::desc("<profdata-file>"));

cl::opt<bool> ShowCounts("counts", cl::init(false),
                         cl::desc("Show counter values for shown functions"));
cl::opt<bool> TextFormat(
    "text", cl::init(false),
    cl::desc("Show instr profile data in text dump format"));
cl::opt<bool> ShowIndirectCallTargets(
    "ic-targets", cl::init(false),
    cl::desc("Show indirect call site target values for shown functions"));
cl::opt<bool> ShowMemOPSizes(
    "memop-sizes", cl::init(false),
    cl::desc("Show the profiled sizes of the memory intrinsic calls "
             "for shown functions"));
cl::opt<bool> ShowDetailedSummary("detailed-summary", cl::init(false),
                                  cl::desc("Show detailed profile summary"));
cl::list<uint32_t> DetailedSummaryCutoffs(
    cl::CommaSeparated, "detailed-summary-cutoffs",
    cl::desc(
        "Cutoff percentages (times 10000) for generating detailed summary"),
    cl::value_desc("800000,901000,999999"));
cl::opt<bool> ShowHotFuncList(
    "hot-func-list", cl::init(false),
    cl::desc("Show profile summary of a list of hot functions"));
cl::opt<bool> ShowAllFunctions("all-functions", cl::init(false),
                               cl::desc("Details for every function"));
cl::opt<bool> ShowCS("showcs", cl::init(false),
                     cl::desc("Show context sensitive counts"));
cl::opt<std::string> ShowFunction("function",
                                  cl::desc("Details for matching functions"));

cl::opt<std::string> OutputFilename("output", cl::value_desc("output"),
                                    cl::init("-"), cl::desc("Output file"));
cl::alias OutputFilenameA("o", cl::desc("Alias for --output"),
                          cl::aliasopt(OutputFilename));
cl::opt<ProfileKinds> ProfileKind(
    cl::desc("Profile kind:"), cl::init(instr),
    cl::values(clEnumVal(instr, "Instrumentation profile (default)")llvm::cl::OptionEnumValue { "instr", int(instr), "Instrumentation profile (default)"
 },
               clEnumVal(sample, "Sample profile")llvm::cl::OptionEnumValue { "sample", int(sample), "Sample profile"
 },
               clEnumVal(memory, "MemProf memory access profile")llvm::cl::OptionEnumValue { "memory", int(memory), "MemProf memory access profile"
 }));
cl::opt<uint32_t> TopNFunctions(
    "topn", cl::init(0),
    cl::desc("Show the list of functions with the largest internal counts"));
cl::opt<uint32_t> ValueCutoff(
    "value-cutoff", cl::init(0),
    cl::desc("Set the count value cutoff. Functions with the maximum count "
             "less than this value will not be printed out. (Default is 0)"));
cl::opt<bool> OnlyListBelow(
    "list-below-cutoff", cl::init(false),
    cl::desc("Only output names of functions whose max count values are "
             "below the cutoff value"));
cl::opt<bool> ShowProfileSymbolList(
    "show-prof-sym-list", cl::init(false),
    cl::desc("Show profile symbol list if it exists in the profile. "));
cl::opt<bool> ShowSectionInfoOnly(
    "show-sec-info-only", cl::init(false),
    cl::desc("Show the information of each section in the sample profile. "
             "The flag is only usable when the sample profile is in "
             "extbinary format"));
cl::opt<bool> ShowBinaryIds("binary-ids", cl::init(false),
                            cl::desc("Show binary ids in the profile. "));
cl::opt<std::string> DebugInfoFilename(
    "debug-info", cl::init(""),
    cl::desc("Read and extract profile metadata from debug info and show "
             "the functions it found."));
cl::opt<bool> ShowCovered(
    "covered", cl::init(false),
    cl::desc("Show only the functions that have been executed."));
cl::opt<std::string> ProfiledBinary(
    "profiled-binary", cl::init(""),
    cl::desc("Path to binary from which the profile was collected."));

cl::ParseCommandLineOptions(argc, argv, "LLVM profile data summary\n");

if (Filename.empty() && DebugInfoFilename.empty())
  exitWithError(
      "the positional argument '<profdata-file>' is required unless '--" +
      DebugInfoFilename.ArgStr + "' is provided");

if (Filename == OutputFilename) {
  errs() << sys::path::filename(argv[0])
         << ": Input file name cannot be the same as the output file name!\n";
  return 1;
}

std::error_code EC;
raw_fd_ostream OS(OutputFilename.data(), EC, sys::fs::OF_TextWithCRLF);
if (EC)
  exitWithErrorCode(EC, OutputFilename);

if (ShowAllFunctions && !ShowFunction.empty())
  WithColor::warning() << "-function argument ignored: showing all functions\n";

if (!DebugInfoFilename.empty())
  return showDebugInfoCorrelation(DebugInfoFilename, ShowDetailedSummary,
                                  ShowProfileSymbolList, OS);

if (ProfileKind == instr)
  return showInstrProfile(
      Filename, ShowCounts, TopNFunctions, ShowIndirectCallTargets,
      ShowMemOPSizes, ShowDetailedSummary, DetailedSummaryCutoffs,
      ShowAllFunctions, ShowCS, ValueCutoff, OnlyListBelow, ShowFunction,
      TextFormat, ShowBinaryIds, ShowCovered, OS);
if (ProfileKind == sample)
  return showSampleProfile(Filename, ShowCounts, TopNFunctions,
                           ShowAllFunctions, ShowDetailedSummary,
                           ShowFunction, ShowProfileSymbolList,
                           ShowSectionInfoOnly, ShowHotFuncList, OS);
return showMemProfProfile(Filename, ProfiledBinary, OS);
2639}

2641int main(int argc, const char *argv[]) {
InitLLVM X(argc, argv);

StringRef ProgName(sys::path::filename(argv[0]));
if (argc > 1) {
  int (*func)(int, const char *[]) = nullptr;

  if (strcmp(argv[1], "merge") == 0)
    func = merge_main;
  else if (strcmp(argv[1], "show") == 0)
    func = show_main;
  else if (strcmp(argv[1], "overlap") == 0)
    func = overlap_main;

  if (func) {
    std::string Invocation(ProgName.str() + " " + argv[1]);
    argv[1] = Invocation.c_str();
    return func(argc - 1, argv + 1);
  }

  if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
      strcmp(argv[1], "--help") == 0) {

    errs() << "OVERVIEW: LLVM profile data tools\n\n"
           << "USAGE: " << ProgName << " <command> [args...]\n"
           << "USAGE: " << ProgName << " <command> -help\n\n"
           << "See each individual command --help for more details.\n"
           << "Available commands: merge, show, overlap\n";
    return 0;
  }
}

if (argc < 2)
  errs() << ProgName << ": No command specified!\n";
else
  errs() << ProgName << ": Unknown command!\n";

errs() << "USAGE: " << ProgName << " <merge|show|overlap> [args...]\n";
return 1;
2680}

←

/build/llvm-toolchain-snapshot-15~++20220214111405+a87d3ba61c64/llvm/include/llvm/Support/Error.h

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