/build/source/llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

Bug Summary

File:	build/source/llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp
Warning:	line 1504, column 18 Moved-from object 'EC' 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 DumpOutputStyle.cpp -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/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/llvm-pdbutil -I /build/source/llvm/tools/llvm-pdbutil -I include -I /build/source/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-17/lib/clang/17/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/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -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 -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -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-2023-05-10-133810-16478-1 -x c++ /build/source/llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

/build/source/llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

→

1//===- DumpOutputStyle.cpp ------------------------------------ *- 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//===----------------------------------------------------------------------===//

9#include "DumpOutputStyle.h"

11#include "MinimalSymbolDumper.h"
12#include "MinimalTypeDumper.h"
13#include "StreamUtil.h"
14#include "TypeReferenceTracker.h"
15#include "llvm-pdbutil.h"

17#include "llvm/ADT/STLExtras.h"
18#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
19#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
20#include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
21#include "llvm/DebugInfo/CodeView/DebugCrossExSubsection.h"
22#include "llvm/DebugInfo/CodeView/DebugCrossImpSubsection.h"
23#include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
24#include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
25#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
26#include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
27#include "llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h"
28#include "llvm/DebugInfo/CodeView/Formatters.h"
29#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
30#include "llvm/DebugInfo/CodeView/Line.h"
31#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
32#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
33#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
34#include "llvm/DebugInfo/CodeView/TypeHashing.h"
35#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
36#include "llvm/DebugInfo/MSF/MappedBlockStream.h"
37#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
38#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
39#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
40#include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
41#include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
42#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
43#include "llvm/DebugInfo/PDB/Native/InputFile.h"
44#include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
45#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
46#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
47#include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
48#include "llvm/DebugInfo/PDB/Native/RawError.h"
49#include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
50#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
51#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
52#include "llvm/Object/COFF.h"
53#include "llvm/Support/BinaryStreamReader.h"
54#include "llvm/Support/FormatAdapters.h"
55#include "llvm/Support/FormatVariadic.h"

57#include <cctype>

59using namespace llvm;
60using namespace llvm::codeview;
61using namespace llvm::msf;
62using namespace llvm::pdb;

64DumpOutputStyle::DumpOutputStyle(InputFile &File)
  : File(File), P(2, false, outs(), opts::Filters) {
if (opts::dump::DumpTypeRefStats)
  RefTracker.reset(new TypeReferenceTracker(File));
68}

70DumpOutputStyle::~DumpOutputStyle() {}

72PDBFile &DumpOutputStyle::getPdb() { return File.pdb(); }
73object::COFFObjectFile &DumpOutputStyle::getObj() { return File.obj(); }

75void DumpOutputStyle::printStreamNotValidForObj() {
AutoIndent Indent(P, 4);
P.formatLine("Dumping this stream is not valid for object files");
78}

80void DumpOutputStyle::printStreamNotPresent(StringRef StreamName) {
AutoIndent Indent(P, 4);
P.formatLine("{0} stream not present", StreamName);
83}

85Error DumpOutputStyle::dump() {
// Walk symbols & globals if we are supposed to mark types referenced.
if (opts::dump::DumpTypeRefStats)
  RefTracker->mark();

if (opts::dump::DumpSummary) {
  if (auto EC = dumpFileSummary())
    return EC;
  P.NewLine();
}

if (opts::dump::DumpStreams) {
  if (auto EC = dumpStreamSummary())
    return EC;
  P.NewLine();
}

if (opts::dump::DumpSymbolStats) {
  ExitOnError Err("Unexpected error processing module stats: ");
  Err(dumpSymbolStats());
  P.NewLine();
}

if (opts::dump::DumpUdtStats) {
  if (auto EC = dumpUdtStats())
    return EC;
  P.NewLine();
}

if (opts::dump::DumpTypeStats || opts::dump::DumpIDStats) {
  if (auto EC = dumpTypeStats())
    return EC;
  P.NewLine();
}

if (opts::dump::DumpNamedStreams) {
  if (auto EC = dumpNamedStreams())
    return EC;
  P.NewLine();
}

if (opts::dump::DumpStringTable || opts::dump::DumpStringTableDetails) {
  if (auto EC = dumpStringTable())
    return EC;
  P.NewLine();
}

if (opts::dump::DumpModules) {
  ExitOnError Err("Unexpected error processing modules: ");
  Err(dumpModules());
}

if (opts::dump::DumpModuleFiles) {
  ExitOnError Err("Unexpected error processing files: ");
  Err(dumpModuleFiles());
}

if (opts::dump::DumpLines) {
  ExitOnError Err("Unexpected error processing lines: ");
  Err(dumpLines());
}

if (opts::dump::DumpInlineeLines) {
  ExitOnError Err("Unexpected error processing inlinee lines: ");
  Err(dumpInlineeLines());
}

if (opts::dump::DumpXmi) {
  ExitOnError Err("Unexpected error processing cross module imports: ");
  Err(dumpXmi());
}

if (opts::dump::DumpXme) {
  ExitOnError Err("Unexpected error processing cross module exports: ");
  Err(dumpXme());
}

if (opts::dump::DumpFpo) {
  if (auto EC = dumpFpo())
    return EC;
}

if (File.isObj()) {
  if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
      opts::dump::DumpTypeExtras)
    if (auto EC = dumpTypesFromObjectFile())
      return EC;
} else {
  if (opts::dump::DumpTypes || !opts::dump::DumpTypeIndex.empty() ||
      opts::dump::DumpTypeExtras) {
    if (auto EC = dumpTpiStream(StreamTPI))
      return EC;
  }

  if (opts::dump::DumpIds || !opts::dump::DumpIdIndex.empty() ||
      opts::dump::DumpIdExtras) {
    if (auto EC = dumpTpiStream(StreamIPI))
      return EC;
  }
}

if (opts::dump::DumpGSIRecords) {
  if (auto EC = dumpGSIRecords())
    return EC;
}

if (opts::dump::DumpGlobals) {
  if (auto EC = dumpGlobals())
    return EC;
}

if (opts::dump::DumpPublics) {
  if (auto EC = dumpPublics())
    return EC;
}

if (opts::dump::DumpSymbols) {
  ExitOnError Err("Unexpected error processing symbols: ");
  Err(File.isPdb() ? dumpModuleSymsForPdb() : dumpModuleSymsForObj());
}

if (opts::dump::DumpTypeRefStats) {
  if (auto EC = dumpTypeRefStats())
    return EC;
}

if (opts::dump::DumpSectionHeaders) {
  if (auto EC = dumpSectionHeaders())
    return EC;
}

if (opts::dump::DumpSectionContribs) {
  if (auto EC = dumpSectionContribs())
    return EC;
}

if (opts::dump::DumpSectionMap) {
  if (auto EC = dumpSectionMap())
    return EC;
}

P.NewLine();

return Error::success();
229}

231static void printHeader(LinePrinter &P, const Twine &S) {
P.NewLine();
P.formatLine("{0,=60}", S);
P.formatLine("{0}", fmt_repeat('=', 60));
235}

237Error DumpOutputStyle::dumpFileSummary() {
printHeader(P, "Summary");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

AutoIndent Indent(P);
ExitOnError Err("Invalid PDB Format: ");

P.formatLine("Block Size: {0}", getPdb().getBlockSize());
P.formatLine("Number of blocks: {0}", getPdb().getBlockCount());
P.formatLine("Number of streams: {0}", getPdb().getNumStreams());

auto &PS = Err(getPdb().getPDBInfoStream());
P.formatLine("Signature: {0}", PS.getSignature());
P.formatLine("Age: {0}", PS.getAge());
P.formatLine("GUID: {0}", fmt_guid(PS.getGuid().Guid));
P.formatLine("Features: {0:x+}", static_cast<uint32_t>(PS.getFeatures()));
P.formatLine("Has Debug Info: {0}", getPdb().hasPDBDbiStream());
P.formatLine("Has Types: {0}", getPdb().hasPDBTpiStream());
P.formatLine("Has IDs: {0}", getPdb().hasPDBIpiStream());
P.formatLine("Has Globals: {0}", getPdb().hasPDBGlobalsStream());
P.formatLine("Has Publics: {0}", getPdb().hasPDBPublicsStream());
if (getPdb().hasPDBDbiStream()) {
  DbiStream &DBI = Err(getPdb().getPDBDbiStream());
  P.formatLine("Is incrementally linked: {0}", DBI.isIncrementallyLinked());
  P.formatLine("Has conflicting types: {0}", DBI.hasCTypes());
  P.formatLine("Is stripped: {0}", DBI.isStripped());
}

return Error::success();
270}

272static StatCollection getSymbolStats(const SymbolGroup &SG,
                                   StatCollection &CumulativeStats) {
StatCollection Stats;
if (SG.getFile().isPdb() && SG.hasDebugStream()) {
  // For PDB files, all symbols are packed into one stream.
  for (const auto &S : SG.getPdbModuleStream().symbols(nullptr)) {
    Stats.update(S.kind(), S.length());
    CumulativeStats.update(S.kind(), S.length());
  }
  return Stats;
}

for (const auto &SS : SG.getDebugSubsections()) {
  // For object files, all symbols are spread across multiple Symbol
  // subsections of a given .debug$S section.
  if (SS.kind() != DebugSubsectionKind::Symbols)
    continue;
  DebugSymbolsSubsectionRef Symbols;
  BinaryStreamReader Reader(SS.getRecordData());
  cantFail(Symbols.initialize(Reader));
  for (const auto &S : Symbols) {
    Stats.update(S.kind(), S.length());
    CumulativeStats.update(S.kind(), S.length());
  }
}
return Stats;
298}

300static StatCollection getChunkStats(const SymbolGroup &SG,
                                  StatCollection &CumulativeStats) {
StatCollection Stats;
for (const auto &Chunk : SG.getDebugSubsections()) {
  Stats.update(uint32_t(Chunk.kind()), Chunk.getRecordLength());
  CumulativeStats.update(uint32_t(Chunk.kind()), Chunk.getRecordLength());
}
return Stats;
308}

310static inline std::string formatModuleDetailKind(DebugSubsectionKind K) {
return formatChunkKind(K, false);
312}

314static inline std::string formatModuleDetailKind(SymbolKind K) {
return formatSymbolKind(K);
316}

318// Get the stats sorted by size, descending.
319std::vector<StatCollection::KindAndStat>
320StatCollection::getStatsSortedBySize() const {
std::vector<KindAndStat> SortedStats(Individual.begin(), Individual.end());
llvm::stable_sort(SortedStats,
                  [](const KindAndStat &LHS, const KindAndStat &RHS) {
                    return LHS.second.Size > RHS.second.Size;
                  });
return SortedStats;
327}

329template <typename Kind>
330static void printModuleDetailStats(LinePrinter &P, StringRef Label,
                                 const StatCollection &Stats) {
P.NewLine();
P.formatLine("  {0}", Label);
AutoIndent Indent(P);
P.formatLine("{0,40}: {1,7} entries ({2,12:N} bytes)", "Total",
             Stats.Totals.Count, Stats.Totals.Size);
P.formatLine("{0}", fmt_repeat('-', 74));

for (const auto &K : Stats.getStatsSortedBySize()) {
  std::string KindName = formatModuleDetailKind(Kind(K.first));
  P.formatLine("{0,40}: {1,7} entries ({2,12:N} bytes)", KindName,
               K.second.Count, K.second.Size);
}
344}

346Error DumpOutputStyle::dumpStreamSummary() {
printHeader(P, "Streams");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

AutoIndent Indent(P);

if (StreamPurposes.empty())
  discoverStreamPurposes(getPdb(), StreamPurposes);

uint32_t StreamCount = getPdb().getNumStreams();
uint32_t MaxStreamSize = getPdb().getMaxStreamSize();

for (uint32_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
  P.formatLine(
      "Stream {0} ({1} bytes): [{2}]",
      fmt_align(StreamIdx, AlignStyle::Right, NumDigits(StreamCount)),
      fmt_align(getPdb().getStreamByteSize(StreamIdx), AlignStyle::Right,
                NumDigits(MaxStreamSize)),
      StreamPurposes[StreamIdx].getLongName());

  if (opts::dump::DumpStreamBlocks) {
    auto Blocks = getPdb().getStreamBlockList(StreamIdx);
    std::vector<uint32_t> BV(Blocks.begin(), Blocks.end());
    P.formatLine("       {0}  Blocks: [{1}]",
                 fmt_repeat(' ', NumDigits(StreamCount)),
                 make_range(BV.begin(), BV.end()));
  }
}

return Error::success();
380}

382static Expected<std::pair<std::unique_ptr<MappedBlockStream>,
                        ArrayRef<llvm::object::coff_section>>>
384loadSectionHeaders(PDBFile &File, DbgHeaderType Type) {
if (!File.hasPDBDbiStream())
  return make_error<StringError>(
      "Section headers require a DBI Stream, which could not be loaded",
      inconvertibleErrorCode());

DbiStream &Dbi = cantFail(File.getPDBDbiStream());
uint32_t SI = Dbi.getDebugStreamIndex(Type);

if (SI == kInvalidStreamIndex)
  return make_error<StringError>(
      "PDB does not contain the requested image section header type",
      inconvertibleErrorCode());

auto Stream = File.createIndexedStream(SI);
if (!Stream)
  return make_error<StringError>("Could not load the required stream data",
                                 inconvertibleErrorCode());

ArrayRef<object::coff_section> Headers;
if (Stream->getLength() % sizeof(object::coff_section) != 0)
  return make_error<StringError>(
      "Section header array size is not a multiple of section header size",
      inconvertibleErrorCode());

uint32_t NumHeaders = Stream->getLength() / sizeof(object::coff_section);
BinaryStreamReader Reader(*Stream);
cantFail(Reader.readArray(Headers, NumHeaders));
return std::make_pair(std::move(Stream), Headers);
413}

415static Expected<std::vector<std::string>> getSectionNames(PDBFile &File) {
auto ExpectedHeaders = loadSectionHeaders(File, DbgHeaderType::SectionHdr);
if (!ExpectedHeaders)
  return ExpectedHeaders.takeError();

std::unique_ptr<MappedBlockStream> Stream;
ArrayRef<object::coff_section> Headers;
std::tie(Stream, Headers) = std::move(*ExpectedHeaders);
std::vector<std::string> Names;
for (const auto &H : Headers)
  Names.push_back(H.Name);
return Names;
427}

429static void dumpSectionContrib(LinePrinter &P, const SectionContrib &SC,
                             ArrayRef<std::string> SectionNames,
                             uint32_t FieldWidth) {
std::string NameInsert;
if (SC.ISect > 0 && SC.ISect <= SectionNames.size()) {
  StringRef SectionName = SectionNames[SC.ISect - 1];
  NameInsert = formatv("[{0}]", SectionName).str();
} else
  NameInsert = "[???]";
P.formatLine("SC{5}  | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
             "crc = {4}",
             formatSegmentOffset(SC.ISect, SC.Off), fmtle(SC.Size),
             fmtle(SC.Imod), fmtle(SC.DataCrc), fmtle(SC.RelocCrc),
             fmt_align(NameInsert, AlignStyle::Left, FieldWidth + 2));
AutoIndent Indent(P, FieldWidth + 2);
P.formatLine("      {0}",
             formatSectionCharacteristics(P.getIndentLevel() + 6,
                                          SC.Characteristics, 3, " | "));
447}

449static void dumpSectionContrib(LinePrinter &P, const SectionContrib2 &SC,
                             ArrayRef<std::string> SectionNames,
                             uint32_t FieldWidth) {
P.formatLine("SC2[{6}] | mod = {2}, {0}, size = {1}, data crc = {3}, reloc "
             "crc = {4}, coff section = {5}",
             formatSegmentOffset(SC.Base.ISect, SC.Base.Off),
             fmtle(SC.Base.Size), fmtle(SC.Base.Imod), fmtle(SC.Base.DataCrc),
             fmtle(SC.Base.RelocCrc), fmtle(SC.ISectCoff));
P.formatLine("      {0}",
             formatSectionCharacteristics(P.getIndentLevel() + 6,
                                          SC.Base.Characteristics, 3, " | "));
460}

462Error DumpOutputStyle::dumpModules() {
printHeader(P, "Modules");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

if (!getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

AutoIndent Indent(P);

Expected<DbiStream &> StreamOrErr = getPdb().getPDBDbiStream();
if (!StreamOrErr)
  return StreamOrErr.takeError();
DbiStream &Stream = *StreamOrErr;

const DbiModuleList &Modules = Stream.modules();
return iterateSymbolGroups(
    File, PrintScope{P, 11},
    [&](uint32_t Modi, const SymbolGroup &Strings) -> Error {
      auto Desc = Modules.getModuleDescriptor(Modi);
      if (opts::dump::DumpSectionContribs) {
        auto SectionsOrErr = getSectionNames(getPdb());
        if (!SectionsOrErr)
          return SectionsOrErr.takeError();
        ArrayRef<std::string> Sections = *SectionsOrErr;
        dumpSectionContrib(P, Desc.getSectionContrib(), Sections, 0);
      }
      P.formatLine("Obj: `{0}`: ", Desc.getObjFileName());
      P.formatLine("debug stream: {0}, # files: {1}, has ec info: {2}",
                   Desc.getModuleStreamIndex(), Desc.getNumberOfFiles(),
                   Desc.hasECInfo());

      auto PdbPathOrErr = Stream.getECName(Desc.getPdbFilePathNameIndex());
      if (!PdbPathOrErr)
        return PdbPathOrErr.takeError();
      StringRef PdbFilePath = *PdbPathOrErr;

      auto SrcPathOrErr = Stream.getECName(Desc.getSourceFileNameIndex());
      if (!SrcPathOrErr)
        return SrcPathOrErr.takeError();
      StringRef SrcFilePath = *SrcPathOrErr;

      P.formatLine("pdb file ni: {0} `{1}`, src file ni: {2} `{3}`",
                   Desc.getPdbFilePathNameIndex(), PdbFilePath,
                   Desc.getSourceFileNameIndex(), SrcFilePath);
      return Error::success();
    });
514}

516Error DumpOutputStyle::dumpModuleFiles() {
printHeader(P, "Files");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

if (!getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

return iterateSymbolGroups(
    File, PrintScope{P, 11},
    [this](uint32_t Modi, const SymbolGroup &Strings) -> Error {
      Expected<DbiStream &> StreamOrErr = getPdb().getPDBDbiStream();
      if (!StreamOrErr)
        return StreamOrErr.takeError();
      DbiStream &Stream = *StreamOrErr;

      const DbiModuleList &Modules = Stream.modules();
      for (const auto &F : Modules.source_files(Modi)) {
        Strings.formatFromFileName(P, F);
      }
      return Error::success();
    });
543}

545Error DumpOutputStyle::dumpSymbolStats() {
printHeader(P, "Module Stats");

if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

StatCollection SymStats;
StatCollection ChunkStats;
PrintScope Scope(P, 2);

if (Error Err = iterateSymbolGroups(
        File, Scope, [&](uint32_t Modi, const SymbolGroup &SG) -> Error {
          StatCollection SS = getSymbolStats(SG, SymStats);
          StatCollection CS = getChunkStats(SG, ChunkStats);

          if (!SG.getFile().isPdb())
            return Error::success();

          AutoIndent Indent(P);
          auto Modules = cantFail(File.pdb().getPDBDbiStream()).modules();
          uint32_t ModCount = Modules.getModuleCount();
          DbiModuleDescriptor Desc = Modules.getModuleDescriptor(Modi);
          uint32_t StreamIdx = Desc.getModuleStreamIndex();

          if (StreamIdx == kInvalidStreamIndex) {
            P.formatLine(
                "Mod {0} (debug info not present): [{1}]",
                fmt_align(Modi, AlignStyle::Right, NumDigits(ModCount)),
                Desc.getModuleName());
            return Error::success();
          }
          P.formatLine("Stream {0}, {1} bytes", StreamIdx,
                       getPdb().getStreamByteSize(StreamIdx));

          printModuleDetailStats<SymbolKind>(P, "Symbols", SS);
          printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", CS);

          return Error::success();
        }))
  return Err;

if (SymStats.Totals.Count > 0) {
  P.printLine("  Summary |");
  AutoIndent Indent(P, 4);
  printModuleDetailStats<SymbolKind>(P, "Symbols", SymStats);
  printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", ChunkStats);
}

return Error::success();
596}

598Error DumpOutputStyle::dumpTypeStats() {
printHeader(P, "Type Record Stats");

// Iterate the types, categorize by kind, accumulate size stats.
StatCollection TypeStats;
LazyRandomTypeCollection &Types =
    opts::dump::DumpTypeStats ? File.types() : File.ids();
for (std::optional<TypeIndex> TI = Types.getFirst(); TI;
     TI = Types.getNext(*TI)) {
  CVType Type = Types.getType(*TI);
  TypeStats.update(uint32_t(Type.kind()), Type.length());
}

P.NewLine();
P.formatLine("  Types");
AutoIndent Indent(P);
P.formatLine("{0,16}: {1,7} entries ({2,12:N} bytes, {3,7} avg)", "Total",
             TypeStats.Totals.Count, TypeStats.Totals.Size,
             (double)TypeStats.Totals.Size / TypeStats.Totals.Count);
P.formatLine("{0}", fmt_repeat('-', 74));

for (const auto &K : TypeStats.getStatsSortedBySize()) {
  P.formatLine("{0,16}: {1,7} entries ({2,12:N} bytes, {3,7} avg)",
               formatTypeLeafKind(TypeLeafKind(K.first)), K.second.Count,
               K.second.Size, (double)K.second.Size / K.second.Count);
}
return Error::success();
625}

627static bool isValidNamespaceIdentifier(StringRef S) {
if (S.empty())
  return false;

if (std::isdigit(S[0]))
  return false;

return llvm::all_of(S, [](char C) { return std::isalnum(C); });
635}

637namespace {
638constexpr uint32_t kNoneUdtKind = 0;
639constexpr uint32_t kSimpleUdtKind = 1;
640constexpr uint32_t kUnknownUdtKind = 2;
641} // namespace

643static std::string getUdtStatLabel(uint32_t Kind) {
if (Kind == kNoneUdtKind)
  return "<none type>";

if (Kind == kSimpleUdtKind)
  return "<simple type>";

if (Kind == kUnknownUdtKind)
  return "<unknown type>";

return formatTypeLeafKind(static_cast<TypeLeafKind>(Kind));
654}

656static uint32_t getLongestTypeLeafName(const StatCollection &Stats) {
size_t L = 0;
for (const auto &Stat : Stats.Individual) {
  std::string Label = getUdtStatLabel(Stat.first);
  L = std::max(L, Label.size());
}
return static_cast<uint32_t>(L);
663}

665Error DumpOutputStyle::dumpUdtStats() {
printHeader(P, "S_UDT Record Stats");

if (File.isPdb() && !getPdb().hasPDBGlobalsStream()) {
  printStreamNotPresent("Globals");
  return Error::success();
}

StatCollection UdtStats;
StatCollection UdtTargetStats;
AutoIndent Indent(P, 4);

auto &TpiTypes = File.types();

StringMap<StatCollection::Stat> NamespacedStats;

size_t LongestNamespace = 0;
auto HandleOneSymbol = [&](const CVSymbol &Sym) {
  if (Sym.kind() != SymbolKind::S_UDT)
    return;
  UdtStats.update(SymbolKind::S_UDT, Sym.length());

  UDTSym UDT = cantFail(SymbolDeserializer::deserializeAs<UDTSym>(Sym));

  uint32_t Kind = 0;
  uint32_t RecordSize = 0;

  if (UDT.Type.isNoneType())
    Kind = kNoneUdtKind;
  else if (UDT.Type.isSimple())
    Kind = kSimpleUdtKind;
  else if (std::optional<CVType> T = TpiTypes.tryGetType(UDT.Type)) {
    Kind = T->kind();
    RecordSize = T->length();
  } else
    Kind = kUnknownUdtKind;

  UdtTargetStats.update(Kind, RecordSize);

  size_t Pos = UDT.Name.find("::");
  if (Pos == StringRef::npos)
    return;

  StringRef Scope = UDT.Name.take_front(Pos);
  if (Scope.empty() || !isValidNamespaceIdentifier(Scope))
    return;

  LongestNamespace = std::max(LongestNamespace, Scope.size());
  NamespacedStats[Scope].update(RecordSize);
};

P.NewLine();

if (File.isPdb()) {
  auto &SymbolRecords = cantFail(getPdb().getPDBSymbolStream());
  auto ExpGlobals = getPdb().getPDBGlobalsStream();
  if (!ExpGlobals)
    return ExpGlobals.takeError();

  for (uint32_t PubSymOff : ExpGlobals->getGlobalsTable()) {
    CVSymbol Sym = SymbolRecords.readRecord(PubSymOff);
    HandleOneSymbol(Sym);
  }
} else {
  for (const auto &Sec : File.symbol_groups()) {
    for (const auto &SS : Sec.getDebugSubsections()) {
      if (SS.kind() != DebugSubsectionKind::Symbols)
        continue;

      DebugSymbolsSubsectionRef Symbols;
      BinaryStreamReader Reader(SS.getRecordData());
      cantFail(Symbols.initialize(Reader));
      for (const auto &S : Symbols)
        HandleOneSymbol(S);
    }
  }
}

LongestNamespace += StringRef(" namespace ''").size();
size_t LongestTypeLeafKind = getLongestTypeLeafName(UdtTargetStats);
size_t FieldWidth = std::max(LongestNamespace, LongestTypeLeafKind);

// Compute the max number of digits for count and size fields, including comma
// separators.
StringRef CountHeader("Count");
StringRef SizeHeader("Size");
size_t CD = NumDigits(UdtStats.Totals.Count);
CD += (CD - 1) / 3;
CD = std::max(CD, CountHeader.size());

size_t SD = NumDigits(UdtStats.Totals.Size);
SD += (SD - 1) / 3;
SD = std::max(SD, SizeHeader.size());

uint32_t TableWidth = FieldWidth + 3 + CD + 2 + SD + 1;

P.formatLine("{0} | {1}  {2}",
             fmt_align("Record Kind", AlignStyle::Right, FieldWidth),
             fmt_align(CountHeader, AlignStyle::Right, CD),
             fmt_align(SizeHeader, AlignStyle::Right, SD));

P.formatLine("{0}", fmt_repeat('-', TableWidth));
for (const auto &Stat : UdtTargetStats.getStatsSortedBySize()) {
  std::string Label = getUdtStatLabel(Stat.first);
  P.formatLine("{0} | {1:N}  {2:N}",
               fmt_align(Label, AlignStyle::Right, FieldWidth),
               fmt_align(Stat.second.Count, AlignStyle::Right, CD),
               fmt_align(Stat.second.Size, AlignStyle::Right, SD));
}
P.formatLine("{0}", fmt_repeat('-', TableWidth));
P.formatLine("{0} | {1:N}  {2:N}",
             fmt_align("Total (S_UDT)", AlignStyle::Right, FieldWidth),
             fmt_align(UdtStats.Totals.Count, AlignStyle::Right, CD),
             fmt_align(UdtStats.Totals.Size, AlignStyle::Right, SD));
P.formatLine("{0}", fmt_repeat('-', TableWidth));
struct StrAndStat {
  StringRef Key;
  StatCollection::Stat Stat;
};

// Print namespace stats in descending order of size.
std::vector<StrAndStat> NamespacedStatsSorted;
for (const auto &Stat : NamespacedStats)
  NamespacedStatsSorted.push_back({Stat.getKey(), Stat.second});
llvm::stable_sort(NamespacedStatsSorted,
                  [](const StrAndStat &L, const StrAndStat &R) {
                    return L.Stat.Size > R.Stat.Size;
                  });
for (const auto &Stat : NamespacedStatsSorted) {
  std::string Label = std::string(formatv("namespace '{0}'", Stat.Key));
  P.formatLine("{0} | {1:N}  {2:N}",
               fmt_align(Label, AlignStyle::Right, FieldWidth),
               fmt_align(Stat.Stat.Count, AlignStyle::Right, CD),
               fmt_align(Stat.Stat.Size, AlignStyle::Right, SD));
}
return Error::success();
801}

803static void typesetLinesAndColumns(LinePrinter &P, uint32_t Start,
                                 const LineColumnEntry &E) {
const uint32_t kMaxCharsPerLineNumber = 4; // 4 digit line number
uint32_t MinColumnWidth = kMaxCharsPerLineNumber + 5;

// Let's try to keep it under 100 characters
constexpr uint32_t kMaxRowLength = 100;
// At least 3 spaces between columns.
uint32_t ColumnsPerRow = kMaxRowLength / (MinColumnWidth + 3);
uint32_t ItemsLeft = E.LineNumbers.size();
auto LineIter = E.LineNumbers.begin();
while (ItemsLeft != 0) {
  uint32_t RowColumns = std::min(ItemsLeft, ColumnsPerRow);
  for (uint32_t I = 0; I < RowColumns; ++I) {
    LineInfo Line(LineIter->Flags);
    std::string LineStr;
    if (Line.isAlwaysStepInto())
      LineStr = "ASI";
    else if (Line.isNeverStepInto())
      LineStr = "NSI";
    else
      LineStr = utostr(Line.getStartLine());
    char Statement = Line.isStatement() ? ' ' : '!';
    P.format("{0} {1:X-} {2} ",
             fmt_align(LineStr, AlignStyle::Right, kMaxCharsPerLineNumber),
             fmt_align(Start + LineIter->Offset, AlignStyle::Right, 8, '0'),
             Statement);
    ++LineIter;
    --ItemsLeft;
  }
  P.NewLine();
}
835}

837Error DumpOutputStyle::dumpLines() {
printHeader(P, "Lines");

if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

uint32_t LastModi = UINT32_MAX(4294967295U);
uint32_t LastNameIndex = UINT32_MAX(4294967295U);
return iterateModuleSubsections<DebugLinesSubsectionRef>(
    File, PrintScope{P, 4},
    [this, &LastModi,
     &LastNameIndex](uint32_t Modi, const SymbolGroup &Strings,
                     DebugLinesSubsectionRef &Lines) -> Error {
      uint16_t Segment = Lines.header()->RelocSegment;
      uint32_t Begin = Lines.header()->RelocOffset;
      uint32_t End = Begin + Lines.header()->CodeSize;
      for (const auto &Block : Lines) {
        if (LastModi != Modi || LastNameIndex != Block.NameIndex) {
          LastModi = Modi;
          LastNameIndex = Block.NameIndex;
          Strings.formatFromChecksumsOffset(P, Block.NameIndex);
        }

        AutoIndent Indent(P, 2);
        P.formatLine("{0:X-4}:{1:X-8}-{2:X-8}, ", Segment, Begin, End);
        uint32_t Count = Block.LineNumbers.size();
        if (Lines.hasColumnInfo())
          P.format("line/column/addr entries = {0}", Count);
        else
          P.format("line/addr entries = {0}", Count);

        P.NewLine();
        typesetLinesAndColumns(P, Begin, Block);
      }
      return Error::success();
    });
875}

877Error DumpOutputStyle::dumpInlineeLines() {
printHeader(P, "Inlinee Lines");

if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

return iterateModuleSubsections<DebugInlineeLinesSubsectionRef>(
    File, PrintScope{P, 2},
    [this](uint32_t Modi, const SymbolGroup &Strings,
           DebugInlineeLinesSubsectionRef &Lines) -> Error {
      P.formatLine("{0,+8} | {1,+5} | {2}", "Inlinee", "Line", "Source File");
      for (const auto &Entry : Lines) {
        P.formatLine("{0,+8} | {1,+5} | ", Entry.Header->Inlinee,
                     fmtle(Entry.Header->SourceLineNum));
        Strings.formatFromChecksumsOffset(P, Entry.Header->FileID, true);
        for (const auto &ExtraFileID : Entry.ExtraFiles) {
          P.formatLine("                   ");
          Strings.formatFromChecksumsOffset(P, ExtraFileID, true);
        }
      }
      P.NewLine();
      return Error::success();
    });
902}

904Error DumpOutputStyle::dumpXmi() {
printHeader(P, "Cross Module Imports");

if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

return iterateModuleSubsections<DebugCrossModuleImportsSubsectionRef>(
    File, PrintScope{P, 2},
    [this](uint32_t Modi, const SymbolGroup &Strings,
           DebugCrossModuleImportsSubsectionRef &Imports) -> Error {
      P.formatLine("{0,=32} | {1}", "Imported Module", "Type IDs");

      for (const auto &Xmi : Imports) {
        auto ExpectedModule =
            Strings.getNameFromStringTable(Xmi.Header->ModuleNameOffset);
        StringRef Module;
        SmallString<32> ModuleStorage;
        if (!ExpectedModule) {
          Module = "(unknown module)";
          consumeError(ExpectedModule.takeError());
        } else
          Module = *ExpectedModule;
        if (Module.size() > 32) {
          ModuleStorage = "...";
          ModuleStorage += Module.take_back(32 - 3);
          Module = ModuleStorage;
        }
        std::vector<std::string> TIs;
        for (const auto I : Xmi.Imports)
          TIs.push_back(std::string(formatv("{0,+10:X+}", fmtle(I))));
        std::string Result =
            typesetItemList(TIs, P.getIndentLevel() + 35, 12, " ");
        P.formatLine("{0,+32} | {1}", Module, Result);
      }
      return Error::success();
    });
942}

944Error DumpOutputStyle::dumpXme() {
printHeader(P, "Cross Module Exports");

if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

return iterateModuleSubsections<DebugCrossModuleExportsSubsectionRef>(
    File, PrintScope{P, 2},
    [this](uint32_t Modi, const SymbolGroup &Strings,
           DebugCrossModuleExportsSubsectionRef &Exports) -> Error {
      P.formatLine("{0,-10} | {1}", "Local ID", "Global ID");
      for (const auto &Export : Exports) {
        P.formatLine("{0,+10:X+} | {1}", TypeIndex(Export.Local),
                     TypeIndex(Export.Global));
      }
      return Error::success();
    });
963}

965std::string formatFrameType(object::frame_type FT) {
switch (FT) {
case object::frame_type::Fpo:
  return "FPO";
case object::frame_type::NonFpo:
  return "Non-FPO";
case object::frame_type::Trap:
  return "Trap";
case object::frame_type::Tss:
  return "TSS";
}
return "<unknown>";
977}

979Error DumpOutputStyle::dumpOldFpo(PDBFile &File) {
printHeader(P, "Old FPO Data");

ExitOnError Err("Error dumping old fpo data:");
DbiStream &Dbi = Err(File.getPDBDbiStream());

if (!Dbi.hasOldFpoRecords()) {
  printStreamNotPresent("FPO");
  return Error::success();
}

const FixedStreamArray<object::FpoData>& Records = Dbi.getOldFpoRecords();

P.printLine("  RVA    | Code | Locals | Params | Prolog | Saved Regs | Use "
            "BP | Has SEH | Frame Type");

for (const object::FpoData &FD : Records) {
  P.formatLine("{0:X-8} | {1,4} | {2,6} | {3,6} | {4,6} | {5,10} | {6,6} | "
               "{7,7} | {8,9}",
               uint32_t(FD.Offset), uint32_t(FD.Size), uint32_t(FD.NumLocals),
               uint32_t(FD.NumParams), FD.getPrologSize(),
               FD.getNumSavedRegs(), FD.useBP(), FD.hasSEH(),
               formatFrameType(FD.getFP()));
}
return Error::success();
1004}

1006Error DumpOutputStyle::dumpNewFpo(PDBFile &File) {
printHeader(P, "New FPO Data");

ExitOnError Err("Error dumping new fpo data:");
DbiStream &Dbi = Err(File.getPDBDbiStream());

if (!Dbi.hasNewFpoRecords()) {
  printStreamNotPresent("New FPO");
  return Error::success();
}

const DebugFrameDataSubsectionRef& FDS = Dbi.getNewFpoRecords();

P.printLine("  RVA    | Code | Locals | Params | Stack | Prolog | Saved Regs "
            "| Has SEH | Has C++EH | Start | Program");
for (const FrameData &FD : FDS) {
  bool IsFuncStart = FD.Flags & FrameData::IsFunctionStart;
  bool HasEH = FD.Flags & FrameData::HasEH;
  bool HasSEH = FD.Flags & FrameData::HasSEH;

  auto &StringTable = Err(File.getStringTable());

  auto Program = Err(StringTable.getStringForID(FD.FrameFunc));
  P.formatLine("{0:X-8} | {1,4} | {2,6} | {3,6} | {4,5} | {5,6} | {6,10} | "
               "{7,7} | {8,9} | {9,5} | {10}",
               uint32_t(FD.RvaStart), uint32_t(FD.CodeSize),
               uint32_t(FD.LocalSize), uint32_t(FD.ParamsSize),
               uint32_t(FD.MaxStackSize), uint16_t(FD.PrologSize),
               uint16_t(FD.SavedRegsSize), HasSEH, HasEH, IsFuncStart,
               Program);
}
return Error::success();
1038}

1040Error DumpOutputStyle::dumpFpo() {
if (!File.isPdb()) {
  printStreamNotValidForObj();
  return Error::success();
}

PDBFile &File = getPdb();
if (!File.hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

if (auto EC = dumpOldFpo(File))
  return EC;
if (auto EC = dumpNewFpo(File))
  return EC;
return Error::success();
1057}

1059Error DumpOutputStyle::dumpStringTableFromPdb() {
AutoIndent Indent(P);
auto IS = getPdb().getStringTable();
if (!IS) {
  P.formatLine("Not present in file");
  consumeError(IS.takeError());
  return Error::success();
}

if (opts::dump::DumpStringTable) {
  if (IS->name_ids().empty())
    P.formatLine("Empty");
  else {
    auto MaxID =
        std::max_element(IS->name_ids().begin(), IS->name_ids().end());
    uint32_t Digits = NumDigits(*MaxID);

    P.formatLine("{0} | {1}", fmt_align("ID", AlignStyle::Right, Digits),
                 "String");

    std::vector<uint32_t> SortedIDs(IS->name_ids().begin(),
                                    IS->name_ids().end());
    llvm::sort(SortedIDs);
    for (uint32_t I : SortedIDs) {
      auto ES = IS->getStringForID(I);
      llvm::SmallString<32> Str;
      if (!ES) {
        consumeError(ES.takeError());
        Str = "Error reading string";
      } else if (!ES->empty()) {
        Str.append("'");
        Str.append(*ES);
        Str.append("'");
      }

      if (!Str.empty())
        P.formatLine("{0} | {1}", fmt_align(I, AlignStyle::Right, Digits),
                     Str);
    }
  }
}

if (opts::dump::DumpStringTableDetails) {
  P.NewLine();
  {
    P.printLine("String Table Header:");
    AutoIndent Indent(P);
    P.formatLine("Signature: {0}", IS->getSignature());
    P.formatLine("Hash Version: {0}", IS->getHashVersion());
    P.formatLine("Name Buffer Size: {0}", IS->getByteSize());
    P.NewLine();
  }

  BinaryStreamRef NameBuffer = IS->getStringTable().getBuffer();
  ArrayRef<uint8_t> Contents;
  cantFail(NameBuffer.readBytes(0, NameBuffer.getLength(), Contents));
  P.formatBinary("Name Buffer", Contents, 0);
  P.NewLine();
  {
    P.printLine("Hash Table:");
    AutoIndent Indent(P);
    P.formatLine("Bucket Count: {0}", IS->name_ids().size());
    for (const auto &Entry : enumerate(IS->name_ids()))
      P.formatLine("Bucket[{0}] : {1}", Entry.index(),
                   uint32_t(Entry.value()));
    P.formatLine("Name Count: {0}", IS->getNameCount());
  }
}
return Error::success();
1128}

1130Error DumpOutputStyle::dumpStringTableFromObj() {
return iterateModuleSubsections<DebugStringTableSubsectionRef>(
    File, PrintScope{P, 4},
    [&](uint32_t Modi, const SymbolGroup &Strings,
        DebugStringTableSubsectionRef &Strings2) -> Error {
      BinaryStreamRef StringTableBuffer = Strings2.getBuffer();
      BinaryStreamReader Reader(StringTableBuffer);
      while (Reader.bytesRemaining() > 0) {
        StringRef Str;
        uint32_t Offset = Reader.getOffset();
        cantFail(Reader.readCString(Str));
        if (Str.empty())
          continue;

        P.formatLine("{0} | {1}", fmt_align(Offset, AlignStyle::Right, 4),
                     Str);
      }
      return Error::success();
    });
1149}

1151Error DumpOutputStyle::dumpNamedStreams() {
printHeader(P, "Named Streams");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

AutoIndent Indent(P);
ExitOnError Err("Invalid PDB File: ");

auto &IS = Err(File.pdb().getPDBInfoStream());
const NamedStreamMap &NS = IS.getNamedStreams();
for (const auto &Entry : NS.entries()) {
  P.printLine(Entry.getKey());
  AutoIndent Indent2(P, 2);
  P.formatLine("Index: {0}", Entry.getValue());
  P.formatLine("Size in bytes: {0}",
               File.pdb().getStreamByteSize(Entry.getValue()));
}

return Error::success();
1173}

1175Error DumpOutputStyle::dumpStringTable() {
printHeader(P, "String Table");

if (File.isPdb())
  return dumpStringTableFromPdb();

return dumpStringTableFromObj();
1182}

1184static void buildDepSet(LazyRandomTypeCollection &Types,
                      ArrayRef<TypeIndex> Indices,
                      std::map<TypeIndex, CVType> &DepSet) {
SmallVector<TypeIndex, 4> DepList;
for (const auto &I : Indices) {
  TypeIndex TI(I);
  if (DepSet.find(TI) != DepSet.end() || TI.isSimple() || TI.isNoneType())
    continue;

  CVType Type = Types.getType(TI);
  DepSet[TI] = Type;
  codeview::discoverTypeIndices(Type, DepList);
  buildDepSet(Types, DepList, DepSet);
}
1198}

1200static void
1201dumpFullTypeStream(LinePrinter &Printer, LazyRandomTypeCollection &Types,
                 TypeReferenceTracker *RefTracker, uint32_t NumTypeRecords,
                 uint32_t NumHashBuckets,
                 FixedStreamArray<support::ulittle32_t> HashValues,
                 TpiStream *Stream, bool Bytes, bool Extras) {

Printer.formatLine("Showing {0:N} records", NumTypeRecords);
uint32_t Width = NumDigits(TypeIndex::FirstNonSimpleIndex + NumTypeRecords);

MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types, RefTracker,
                         NumHashBuckets, HashValues, Stream);

if (auto EC = codeview::visitTypeStream(Types, V)) {
  Printer.formatLine("An error occurred dumping type records: {0}",
                     toString(std::move(EC)));
}
1217}

1219static void dumpPartialTypeStream(LinePrinter &Printer,
                                LazyRandomTypeCollection &Types,
                                TypeReferenceTracker *RefTracker,
                                TpiStream &Stream, ArrayRef<TypeIndex> TiList,
                                bool Bytes, bool Extras, bool Deps) {
uint32_t Width =
    NumDigits(TypeIndex::FirstNonSimpleIndex + Stream.getNumTypeRecords());

MinimalTypeDumpVisitor V(Printer, Width + 2, Bytes, Extras, Types, RefTracker,
                         Stream.getNumHashBuckets(), Stream.getHashValues(),
                         &Stream);

if (opts::dump::DumpTypeDependents) {
  // If we need to dump all dependents, then iterate each index and find
  // all dependents, adding them to a map ordered by TypeIndex.
  std::map<TypeIndex, CVType> DepSet;
  buildDepSet(Types, TiList, DepSet);

  Printer.formatLine(
      "Showing {0:N} records and their dependents ({1:N} records total)",
      TiList.size(), DepSet.size());

  for (auto &Dep : DepSet) {
    if (auto EC = codeview::visitTypeRecord(Dep.second, Dep.first, V))
      Printer.formatLine("An error occurred dumping type record {0}: {1}",
                         Dep.first, toString(std::move(EC)));
  }
} else {
  Printer.formatLine("Showing {0:N} records.", TiList.size());

  for (const auto &I : TiList) {
    TypeIndex TI(I);
    if (TI.isSimple()) {
      Printer.formatLine("{0} | {1}", fmt_align(I, AlignStyle::Right, Width),
                         Types.getTypeName(TI));
    } else if (std::optional<CVType> Type = Types.tryGetType(TI)) {
      if (auto EC = codeview::visitTypeRecord(*Type, TI, V))
        Printer.formatLine("An error occurred dumping type record {0}: {1}",
                           TI, toString(std::move(EC)));
    } else {
      Printer.formatLine("Type {0} doesn't exist in TPI stream", TI);
    }
  }
}
1263}

1265Error DumpOutputStyle::dumpTypesFromObjectFile() {
LazyRandomTypeCollection Types(100);

for (const auto &S : getObj().sections()) {
  Expected<StringRef> NameOrErr = S.getName();
  if (!NameOrErr)
    return NameOrErr.takeError();
  StringRef SectionName = *NameOrErr;

  // .debug$T is a standard CodeView type section, while .debug$P is the same
  // format but used for MSVC precompiled header object files.
  if (SectionName == ".debug$T")
    printHeader(P, "Types (.debug$T)");
  else if (SectionName == ".debug$P")
    printHeader(P, "Precompiled Types (.debug$P)");
  else
    continue;

  Expected<StringRef> ContentsOrErr = S.getContents();
  if (!ContentsOrErr)
    return ContentsOrErr.takeError();

  uint32_t Magic;
  BinaryStreamReader Reader(*ContentsOrErr, llvm::support::little);
  if (auto EC = Reader.readInteger(Magic))
    return EC;
  if (Magic != COFF::DEBUG_SECTION_MAGIC)
    return make_error<StringError>("Invalid CodeView debug section.",
                                   inconvertibleErrorCode());

  Types.reset(Reader, 100);

  if (opts::dump::DumpTypes) {
    dumpFullTypeStream(P, Types, RefTracker.get(), 0, 0, {}, nullptr,
                       opts::dump::DumpTypeData, false);
  } else if (opts::dump::DumpTypeExtras) {
    auto LocalHashes = LocallyHashedType::hashTypeCollection(Types);
    auto GlobalHashes = GloballyHashedType::hashTypeCollection(Types);
    assert(LocalHashes.size() == GlobalHashes.size())(static_cast <bool> (LocalHashes.size() == GlobalHashes
.size()) ? void (0) : __assert_fail ("LocalHashes.size() == GlobalHashes.size()"
, "llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp", 1303, __extension__
 __PRETTY_FUNCTION__));

    P.formatLine("Local / Global hashes:");
    TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
    for (auto H : zip(LocalHashes, GlobalHashes)) {
      AutoIndent Indent2(P);
      LocallyHashedType &L = std::get<0>(H);
      GloballyHashedType &G = std::get<1>(H);

      P.formatLine("TI: {0}, LocalHash: {1:X}, GlobalHash: {2}", TI, L, G);

      ++TI;
    }
    P.NewLine();
  }
}

return Error::success();
1321}

1323Error DumpOutputStyle::dumpTpiStream(uint32_t StreamIdx) {
assert(StreamIdx == StreamTPI || StreamIdx == StreamIPI)(static_cast <bool> (StreamIdx == StreamTPI || StreamIdx
 == StreamIPI) ? void (0) : __assert_fail ("StreamIdx == StreamTPI || StreamIdx == StreamIPI"
, "llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp", 1324, __extension__
 __PRETTY_FUNCTION__));

if (StreamIdx == StreamTPI) {
  printHeader(P, "Types (TPI Stream)");
} else if (StreamIdx == StreamIPI) {
  printHeader(P, "Types (IPI Stream)");
}

assert(!File.isObj())(static_cast <bool> (!File.isObj()) ? void (0) : __assert_fail
 ("!File.isObj()", "llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp"
, 1332, __extension__ __PRETTY_FUNCTION__));

bool Present = false;
bool DumpTypes = false;
bool DumpBytes = false;
bool DumpExtras = false;
std::vector<uint32_t> Indices;
if (StreamIdx == StreamTPI) {
  Present = getPdb().hasPDBTpiStream();
  DumpTypes = opts::dump::DumpTypes;
  DumpBytes = opts::dump::DumpTypeData;
  DumpExtras = opts::dump::DumpTypeExtras;
  Indices.assign(opts::dump::DumpTypeIndex.begin(),
                 opts::dump::DumpTypeIndex.end());
} else if (StreamIdx == StreamIPI) {
  Present = getPdb().hasPDBIpiStream();
  DumpTypes = opts::dump::DumpIds;
  DumpBytes = opts::dump::DumpIdData;
  DumpExtras = opts::dump::DumpIdExtras;
  Indices.assign(opts::dump::DumpIdIndex.begin(),
                 opts::dump::DumpIdIndex.end());
}

if (!Present) {
  printStreamNotPresent(StreamIdx == StreamTPI ? "TPI" : "IPI");
  return Error::success();
}

AutoIndent Indent(P);
ExitOnError Err("Unexpected error processing types: ");

auto &Stream = Err((StreamIdx == StreamTPI) ? getPdb().getPDBTpiStream()
                                            : getPdb().getPDBIpiStream());

auto &Types = (StreamIdx == StreamTPI) ? File.types() : File.ids();

// Only emit notes about referenced/unreferenced for types.
TypeReferenceTracker *MaybeTracker =
    (StreamIdx == StreamTPI) ? RefTracker.get() : nullptr;

// Enable resolving forward decls.
Stream.buildHashMap();

if (DumpTypes || !Indices.empty()) {
  if (Indices.empty())
    dumpFullTypeStream(P, Types, MaybeTracker, Stream.getNumTypeRecords(),
                       Stream.getNumHashBuckets(), Stream.getHashValues(),
                       &Stream, DumpBytes, DumpExtras);
  else {
    std::vector<TypeIndex> TiList(Indices.begin(), Indices.end());
    dumpPartialTypeStream(P, Types, MaybeTracker, Stream, TiList, DumpBytes,
                          DumpExtras, opts::dump::DumpTypeDependents);
  }
}

if (DumpExtras) {
  P.NewLine();

  P.formatLine("Header Version: {0}",
               static_cast<uint32_t>(Stream.getTpiVersion()));
  P.formatLine("Hash Stream Index: {0}", Stream.getTypeHashStreamIndex());
  P.formatLine("Aux Hash Stream Index: {0}",
               Stream.getTypeHashStreamAuxIndex());
  P.formatLine("Hash Key Size: {0}", Stream.getHashKeySize());
  P.formatLine("Num Hash Buckets: {0}", Stream.getNumHashBuckets());

  auto IndexOffsets = Stream.getTypeIndexOffsets();
  P.formatLine("Type Index Offsets:");
  for (const auto &IO : IndexOffsets) {
    AutoIndent Indent2(P);
    P.formatLine("TI: {0}, Offset: {1}", IO.Type, fmtle(IO.Offset));
  }

  if (getPdb().hasPDBStringTable()) {
    P.NewLine();
    P.formatLine("Hash Adjusters:");
    auto &Adjusters = Stream.getHashAdjusters();
    auto &Strings = Err(getPdb().getStringTable());
    for (const auto &A : Adjusters) {
      AutoIndent Indent2(P);
      auto ExpectedStr = Strings.getStringForID(A.first);
      TypeIndex TI(A.second);
      if (ExpectedStr)
        P.formatLine("`{0}` -> {1}", *ExpectedStr, TI);
      else {
        P.formatLine("unknown str id ({0}) -> {1}", A.first, TI);
        consumeError(ExpectedStr.takeError());
      }
    }
  }
}
return Error::success();
1424}

1426Error DumpOutputStyle::dumpModuleSymsForObj() {
printHeader(P, "Symbols");

AutoIndent Indent(P);

auto &Types = File.types();

SymbolVisitorCallbackPipeline Pipeline;
SymbolDeserializer Deserializer(nullptr, CodeViewContainer::ObjectFile);
MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Types, Types);

Pipeline.addCallbackToPipeline(Deserializer);
Pipeline.addCallbackToPipeline(Dumper);
CVSymbolVisitor Visitor(Pipeline);

return iterateModuleSubsections<DebugSymbolsSubsectionRef>(
    File, PrintScope{P, 2},
    [&](uint32_t Modi, const SymbolGroup &Strings,
        DebugSymbolsSubsectionRef &Symbols) -> Error {
      Dumper.setSymbolGroup(&Strings);
      for (auto Symbol : Symbols) {
        if (auto EC = Visitor.visitSymbolRecord(Symbol)) {
          return EC;
        }
      }
      return Error::success();
    });
1453}

1455Error DumpOutputStyle::dumpModuleSymsForPdb() {
printHeader(P, "Symbols");

if (File.isPdb() && !getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

AutoIndent Indent(P);

auto &Ids = File.ids();
auto &Types = File.types();

return iterateSymbolGroups(
    File, PrintScope{P, 2},
    [&](uint32_t I, const SymbolGroup &Strings) -> Error {
      auto ExpectedModS = getModuleDebugStream(File.pdb(), I);
      if (!ExpectedModS) {
1
Taking false branch→
        P.formatLine("Error loading module stream {0}.  {1}", I,
                     toString(ExpectedModS.takeError()));
        return Error::success();
      }

      ModuleDebugStreamRef &ModS = *ExpectedModS;

      SymbolVisitorCallbackPipeline Pipeline;
      SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
      MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Strings,
                                 Ids, Types);

      Pipeline.addCallbackToPipeline(Deserializer);
      Pipeline.addCallbackToPipeline(Dumper);
      CVSymbolVisitor Visitor(Pipeline);
      auto SS = ModS.getSymbolsSubstream();
      if (opts::Filters.SymbolOffset) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
        CVSymbolVisitor::FilterOptions Filter;
        Filter.SymbolOffset = opts::Filters.SymbolOffset;
        Filter.ParentRecursiveDepth = opts::Filters.ParentRecurseDepth;
        Filter.ChildRecursiveDepth = opts::Filters.ChildrenRecurseDepth;
        if (auto EC = Visitor.visitSymbolStreamFiltered(ModS.getSymbolArray(),
                                                        Filter)) {
          P.formatLine("Error while processing symbol records.  {0}",
                       toString(std::move(EC)));
          return EC;
        }
      } else if (auto EC = Visitor.visitSymbolStream(ModS.getSymbolArray(),
4
←
Assuming the condition is true→
5
←
Taking true branch→
                                                     SS.Offset)) {
        P.formatLine("Error while processing symbol records.  {0}",
                     toString(std::move(EC)));
6
←
Calling move constructor for 'Error'→
8
←
Returning from move constructor for 'Error'→
        return EC;
9
←
Moved-from object 'EC' is moved
      }
      return Error::success();
    });
1508}

1510Error DumpOutputStyle::dumpTypeRefStats() {
printHeader(P, "Type Reference Statistics");
AutoIndent Indent(P);

// Sum the byte size of all type records, and the size and count of all
// referenced records.
size_t TotalRecs = File.types().size();
size_t RefRecs = 0;
size_t TotalBytes = 0;
size_t RefBytes = 0;
auto &Types = File.types();
for (std::optional<TypeIndex> TI = Types.getFirst(); TI;
     TI = Types.getNext(*TI)) {
  CVType Type = File.types().getType(*TI);
  TotalBytes += Type.length();
  if (RefTracker->isTypeReferenced(*TI)) {
    ++RefRecs;
    RefBytes += Type.length();
  }
}

P.formatLine("Records referenced: {0:N} / {1:N} {2:P}", RefRecs, TotalRecs,
             (double)RefRecs / TotalRecs);
P.formatLine("Bytes referenced: {0:N} / {1:N} {2:P}", RefBytes, TotalBytes,
             (double)RefBytes / TotalBytes);

return Error::success();
1537}

1539Error DumpOutputStyle::dumpGSIRecords() {
printHeader(P, "GSI Records");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

if (!getPdb().hasPDBSymbolStream()) {
  printStreamNotPresent("GSI Common Symbol");
  return Error::success();
}

AutoIndent Indent(P);

auto &Records = cantFail(getPdb().getPDBSymbolStream());
auto &Types = File.types();
auto &Ids = File.ids();

P.printLine("Records");
SymbolVisitorCallbackPipeline Pipeline;
SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);

Pipeline.addCallbackToPipeline(Deserializer);
Pipeline.addCallbackToPipeline(Dumper);
CVSymbolVisitor Visitor(Pipeline);

BinaryStreamRef SymStream = Records.getSymbolArray().getUnderlyingStream();
if (auto E = Visitor.visitSymbolStream(Records.getSymbolArray(), 0))
  return E;
return Error::success();
1571}

1573Error DumpOutputStyle::dumpGlobals() {
printHeader(P, "Global Symbols");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

if (!getPdb().hasPDBGlobalsStream()) {
  printStreamNotPresent("Globals");
  return Error::success();
}

AutoIndent Indent(P);
ExitOnError Err("Error dumping globals stream: ");
auto &Globals = Err(getPdb().getPDBGlobalsStream());

if (opts::dump::DumpGlobalNames.empty()) {
  const GSIHashTable &Table = Globals.getGlobalsTable();
  Err(dumpSymbolsFromGSI(Table, opts::dump::DumpGlobalExtras));
} else {
  SymbolStream &SymRecords = cantFail(getPdb().getPDBSymbolStream());
  auto &Types = File.types();
  auto &Ids = File.ids();

  SymbolVisitorCallbackPipeline Pipeline;
  SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
  MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);

  Pipeline.addCallbackToPipeline(Deserializer);
  Pipeline.addCallbackToPipeline(Dumper);
  CVSymbolVisitor Visitor(Pipeline);

  using ResultEntryType = std::pair<uint32_t, CVSymbol>;
  for (StringRef Name : opts::dump::DumpGlobalNames) {
    AutoIndent Indent(P);
    P.formatLine("Global Name `{0}`", Name);
    std::vector<ResultEntryType> Results =
        Globals.findRecordsByName(Name, SymRecords);
    if (Results.empty()) {
      AutoIndent Indent(P);
      P.printLine("(no matching records found)");
      continue;
    }

    for (ResultEntryType Result : Results) {
      if (auto E = Visitor.visitSymbolRecord(Result.second, Result.first))
        return E;
    }
  }
}
return Error::success();
1625}

1627Error DumpOutputStyle::dumpPublics() {
printHeader(P, "Public Symbols");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

if (!getPdb().hasPDBPublicsStream()) {
  printStreamNotPresent("Publics");
  return Error::success();
}

AutoIndent Indent(P);
ExitOnError Err("Error dumping publics stream: ");
auto &Publics = Err(getPdb().getPDBPublicsStream());

const GSIHashTable &PublicsTable = Publics.getPublicsTable();
if (opts::dump::DumpPublicExtras) {
  P.printLine("Publics Header");
  AutoIndent Indent(P);
  P.formatLine("sym hash = {0}, thunk table addr = {1}", Publics.getSymHash(),
               formatSegmentOffset(Publics.getThunkTableSection(),
                                   Publics.getThunkTableOffset()));
}
Err(dumpSymbolsFromGSI(PublicsTable, opts::dump::DumpPublicExtras));

// Skip the rest if we aren't dumping extras.
if (!opts::dump::DumpPublicExtras)
  return Error::success();

P.formatLine("Address Map");
{
  // These are offsets into the publics stream sorted by secidx:secrel.
  AutoIndent Indent2(P);
  for (uint32_t Addr : Publics.getAddressMap())
    P.formatLine("off = {0}", Addr);
}

// The thunk map is optional debug info used for ILT thunks.
if (!Publics.getThunkMap().empty()) {
  P.formatLine("Thunk Map");
  AutoIndent Indent2(P);
  for (uint32_t Addr : Publics.getThunkMap())
    P.formatLine("{0:x8}", Addr);
}

// The section offsets table appears to be empty when incremental linking
// isn't in use.
if (!Publics.getSectionOffsets().empty()) {
  P.formatLine("Section Offsets");
  AutoIndent Indent2(P);
  for (const SectionOffset &SO : Publics.getSectionOffsets())
    P.formatLine("{0:x4}:{1:x8}", uint16_t(SO.Isect), uint32_t(SO.Off));
}

return Error::success();
1684}

1686Error DumpOutputStyle::dumpSymbolsFromGSI(const GSIHashTable &Table,
                                        bool HashExtras) {
auto ExpectedSyms = getPdb().getPDBSymbolStream();
if (!ExpectedSyms)
  return ExpectedSyms.takeError();
auto &Types = File.types();
auto &Ids = File.ids();

if (HashExtras) {
  P.printLine("GSI Header");
  AutoIndent Indent(P);
  P.formatLine("sig = {0:X}, hdr = {1:X}, hr size = {2}, num buckets = {3}",
               Table.getVerSignature(), Table.getVerHeader(),
               Table.getHashRecordSize(), Table.getNumBuckets());
}

{
  P.printLine("Records");
  SymbolVisitorCallbackPipeline Pipeline;
  SymbolDeserializer Deserializer(nullptr, CodeViewContainer::Pdb);
  MinimalSymbolDumper Dumper(P, opts::dump::DumpSymRecordBytes, Ids, Types);

  Pipeline.addCallbackToPipeline(Deserializer);
  Pipeline.addCallbackToPipeline(Dumper);
  CVSymbolVisitor Visitor(Pipeline);


  BinaryStreamRef SymStream =
      ExpectedSyms->getSymbolArray().getUnderlyingStream();
  for (uint32_t PubSymOff : Table) {
    Expected<CVSymbol> Sym = readSymbolFromStream(SymStream, PubSymOff);
    if (!Sym)
      return Sym.takeError();
    if (auto E = Visitor.visitSymbolRecord(*Sym, PubSymOff))
      return E;
  }
}

// Return early if we aren't dumping public hash table and address map info.
if (HashExtras) {
  P.formatLine("Hash Entries");
  {
    AutoIndent Indent2(P);
    for (const PSHashRecord &HR : Table.HashRecords)
      P.formatLine("off = {0}, refcnt = {1}", uint32_t(HR.Off),
        uint32_t(HR.CRef));
  }

  P.formatLine("Hash Buckets");
  {
    AutoIndent Indent2(P);
    for (uint32_t Hash : Table.HashBuckets)
      P.formatLine("{0:x8}", Hash);
  }
}

return Error::success();
1743}

1745static std::string formatSegMapDescriptorFlag(uint32_t IndentLevel,
                                            OMFSegDescFlags Flags) {
std::vector<std::string> Opts;
if (Flags == OMFSegDescFlags::None)
  return "none";

PUSH_FLAG(OMFSegDescFlags, Read, Flags, "read")if (OMFSegDescFlags::Read == (Flags & OMFSegDescFlags::Read
)) Opts.push_back("read");;
PUSH_FLAG(OMFSegDescFlags, Write, Flags, "write")if (OMFSegDescFlags::Write == (Flags & OMFSegDescFlags::Write
)) Opts.push_back("write");;
PUSH_FLAG(OMFSegDescFlags, Execute, Flags, "execute")if (OMFSegDescFlags::Execute == (Flags & OMFSegDescFlags::
Execute)) Opts.push_back("execute");;
PUSH_FLAG(OMFSegDescFlags, AddressIs32Bit, Flags, "32 bit addr")if (OMFSegDescFlags::AddressIs32Bit == (Flags & OMFSegDescFlags
::AddressIs32Bit)) Opts.push_back("32 bit addr");;
PUSH_FLAG(OMFSegDescFlags, IsSelector, Flags, "selector")if (OMFSegDescFlags::IsSelector == (Flags & OMFSegDescFlags
::IsSelector)) Opts.push_back("selector");;
PUSH_FLAG(OMFSegDescFlags, IsAbsoluteAddress, Flags, "absolute addr")if (OMFSegDescFlags::IsAbsoluteAddress == (Flags & OMFSegDescFlags
::IsAbsoluteAddress)) Opts.push_back("absolute addr");;
PUSH_FLAG(OMFSegDescFlags, IsGroup, Flags, "group")if (OMFSegDescFlags::IsGroup == (Flags & OMFSegDescFlags::
IsGroup)) Opts.push_back("group");;
return typesetItemList(Opts, IndentLevel, 4, " | ");
1759}

1761Error DumpOutputStyle::dumpSectionHeaders() {
dumpSectionHeaders("Section Headers", DbgHeaderType::SectionHdr);
dumpSectionHeaders("Original Section Headers", DbgHeaderType::SectionHdrOrig);
return Error::success();
1765}

1767void DumpOutputStyle::dumpSectionHeaders(StringRef Label, DbgHeaderType Type) {
printHeader(P, Label);

if (File.isObj()) {
  printStreamNotValidForObj();
  return;
}

if (!getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return;
}

AutoIndent Indent(P);
ExitOnError Err("Error dumping section headers: ");
std::unique_ptr<MappedBlockStream> Stream;
ArrayRef<object::coff_section> Headers;
auto ExpectedHeaders = loadSectionHeaders(getPdb(), Type);
if (!ExpectedHeaders) {
  P.printLine(toString(ExpectedHeaders.takeError()));
  return;
}
std::tie(Stream, Headers) = std::move(*ExpectedHeaders);

uint32_t I = 1;
for (const auto &Header : Headers) {
  P.NewLine();
  P.formatLine("SECTION HEADER #{0}", I);
  P.formatLine("{0,8} name", Header.Name);
  P.formatLine("{0,8:X-} virtual size", uint32_t(Header.VirtualSize));
  P.formatLine("{0,8:X-} virtual address", uint32_t(Header.VirtualAddress));
  P.formatLine("{0,8:X-} size of raw data", uint32_t(Header.SizeOfRawData));
  P.formatLine("{0,8:X-} file pointer to raw data",
               uint32_t(Header.PointerToRawData));
  P.formatLine("{0,8:X-} file pointer to relocation table",
               uint32_t(Header.PointerToRelocations));
  P.formatLine("{0,8:X-} file pointer to line numbers",
               uint32_t(Header.PointerToLinenumbers));
  P.formatLine("{0,8:X-} number of relocations",
               uint32_t(Header.NumberOfRelocations));
  P.formatLine("{0,8:X-} number of line numbers",
               uint32_t(Header.NumberOfLinenumbers));
  P.formatLine("{0,8:X-} flags", uint32_t(Header.Characteristics));
  AutoIndent IndentMore(P, 9);
  P.formatLine("{0}", formatSectionCharacteristics(
                          P.getIndentLevel(), Header.Characteristics, 1, ""));
  ++I;
}
1815}

1817Error DumpOutputStyle::dumpSectionContribs() {
printHeader(P, "Section Contributions");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

if (!getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

AutoIndent Indent(P);
ExitOnError Err("Error dumping section contributions: ");

DbiStream &Dbi = Err(getPdb().getPDBDbiStream());

class Visitor : public ISectionContribVisitor {
public:
  Visitor(LinePrinter &P, ArrayRef<std::string> Names) : P(P), Names(Names) {
    auto Max = std::max_element(
        Names.begin(), Names.end(),
        [](StringRef S1, StringRef S2) { return S1.size() < S2.size(); });
    MaxNameLen = (Max == Names.end() ? 0 : Max->size());
  }
  void visit(const SectionContrib &SC) override {
    dumpSectionContrib(P, SC, Names, MaxNameLen);
  }
  void visit(const SectionContrib2 &SC) override {
    dumpSectionContrib(P, SC, Names, MaxNameLen);
  }

private:
  LinePrinter &P;
  uint32_t MaxNameLen;
  ArrayRef<std::string> Names;
};

auto NamesOrErr = getSectionNames(getPdb());
if (!NamesOrErr)
  return NamesOrErr.takeError();
ArrayRef<std::string> Names = *NamesOrErr;
Visitor V(P, Names);
Dbi.visitSectionContributions(V);
return Error::success();
1863}

1865Error DumpOutputStyle::dumpSectionMap() {
printHeader(P, "Section Map");

if (File.isObj()) {
  printStreamNotValidForObj();
  return Error::success();
}

if (!getPdb().hasPDBDbiStream()) {
  printStreamNotPresent("DBI");
  return Error::success();
}

AutoIndent Indent(P);
ExitOnError Err("Error dumping section map: ");

DbiStream &Dbi = Err(getPdb().getPDBDbiStream());

uint32_t I = 0;
for (auto &M : Dbi.getSectionMap()) {
  P.formatLine(
      "Section {0:4} | ovl = {1}, group = {2}, frame = {3}, name = {4}", I,
      fmtle(M.Ovl), fmtle(M.Group), fmtle(M.Frame), fmtle(M.SecName));
  P.formatLine("               class = {0}, offset = {1}, size = {2}",
               fmtle(M.ClassName), fmtle(M.Offset), fmtle(M.SecByteLength));
  P.formatLine("               flags = {0}",
               formatSegMapDescriptorFlag(
                   P.getIndentLevel() + 13,
                   static_cast<OMFSegDescFlags>(uint16_t(M.Flags))));
  ++I;
}
return Error::success();
1897}

←

/build/source/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 <optional>
35#include <string>
36#include <system_error>
37#include <type_traits>
38#include <utility>
39#include <vector>
40 
41namespace llvm {
42 
43class ErrorSuccess;
44 
45/// Base class for error info classes. Do not extend this directly: Extend
46/// the ErrorInfo template subclass instead.
47class ErrorInfoBase {
48public:
49  virtual ~ErrorInfoBase() = default;
50 
51  /// Print an error message to an output stream.
52  virtual void log(raw_ostream &OS) const = 0;
53 
54  /// Return the error message as a string.
55  virtual std::string message() const {
56    std::string Msg;
57    raw_string_ostream OS(Msg);
58    log(OS);
59    return OS.str();
60  }
61 
62  /// Convert this error to a std::error_code.
63  ///
64  /// This is a temporary crutch to enable interaction with code still
65  /// using std::error_code. It will be removed in the future.
66  virtual std::error_code convertToErrorCode() const = 0;
67 
68  // Returns the class ID for this type.
69  static const void *classID() { return &ID; }
70 
71  // Returns the class ID for the dynamic type of this ErrorInfoBase instance.
72  virtual const void *dynamicClassID() const = 0;
73 
74  // Check whether this instance is a subclass of the class identified by
75  // ClassID.
76  virtual bool isA(const void *const ClassID) const {
77    return ClassID == classID();
78  }
79 
80  // Check whether this instance is a subclass of ErrorInfoT.
81  template <typename ErrorInfoT> bool isA() const {
82    return isA(ErrorInfoT::classID());
83  }
84 
85private:
86  virtual void anchor();
87 
88  static char ID;
89};
90 
91/// Lightweight error class with error context and mandatory checking.
92///
93/// Instances of this class wrap a ErrorInfoBase pointer. Failure states
94/// are represented by setting the pointer to a ErrorInfoBase subclass
95/// instance containing information describing the failure. Success is
96/// represented by a null pointer value.
97///
98/// Instances of Error also contains a 'Checked' flag, which must be set
99/// before the destructor is called, otherwise the destructor will trigger a
100/// runtime error. This enforces at runtime the requirement that all Error
101/// instances be checked or returned to the caller.
102///
103/// There are two ways to set the checked flag, depending on what state the
104/// Error instance is in. For Error instances indicating success, it
105/// is sufficient to invoke the boolean conversion operator. E.g.:
106///
107///   @code{.cpp}
108///   Error foo(<...>);
109///
110///   if (auto E = foo(<...>))
111///     return E; // <- Return E if it is in the error state.
112///   // We have verified that E was in the success state. It can now be safely
113///   // destroyed.
114///   @endcode
115///
116/// A success value *can not* be dropped. For example, just calling 'foo(<...>)'
117/// without testing the return value will raise a runtime error, even if foo
118/// returns success.
119///
120/// For Error instances representing failure, you must use either the
121/// handleErrors or handleAllErrors function with a typed handler. E.g.:
122///
123///   @code{.cpp}
124///   class MyErrorInfo : public ErrorInfo<MyErrorInfo> {
125///     // Custom error info.
126///   };
127///
128///   Error foo(<...>) { return make_error<MyErrorInfo>(...); }
129///
130///   auto E = foo(<...>); // <- foo returns failure with MyErrorInfo.
131///   auto NewE =
132///     handleErrors(E,
133///       [](const MyErrorInfo &M) {
134///         // Deal with the error.
135///       },
136///       [](std::unique_ptr<OtherError> M) -> Error {
137///         if (canHandle(*M)) {
138///           // handle error.
139///           return Error::success();
140///         }
141///         // Couldn't handle this error instance. Pass it up the stack.
142///         return Error(std::move(M));
143///       );
144///   // Note - we must check or return NewE in case any of the handlers
145///   // returned a new error.
146///   @endcode
147///
148/// The handleAllErrors function is identical to handleErrors, except
149/// that it has a void return type, and requires all errors to be handled and
150/// no new errors be returned. It prevents errors (assuming they can all be
151/// handled) from having to be bubbled all the way to the top-level.
152///
153/// *All* Error instances must be checked before destruction, even if
154/// they're moved-assigned or constructed from Success values that have already
155/// been checked. This enforces checking through all levels of the call stack.
156class [[nodiscard]] Error {
157  // ErrorList needs to be able to yank ErrorInfoBase pointers out of Errors
158  // to add to the error list. It can't rely on handleErrors for this, since
159  // handleErrors does not support ErrorList handlers.
160  friend class ErrorList;
161 
162  // handleErrors needs to be able to set the Checked flag.
163  template <typename... HandlerTs>
164  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
165 
166  // Expected<T> needs to be able to steal the payload when constructed from an
167  // error.
168  template <typename T> friend class Expected;
169 
170  // wrap needs to be able to steal the payload.
171  friend LLVMErrorRef wrap(Error);
172 
173protected:
174  /// Create a success value. Prefer using 'Error::success()' for readability
175  Error() {
176    setPtr(nullptr);
177    setChecked(false);
178  }
179 
180public:
181  /// Create a success value.
182  static ErrorSuccess success();
183 
184  // Errors are not copy-constructable.
185  Error(const Error &Other) = delete;
186 
187  /// Move-construct an error value. The newly constructed error is considered
188  /// unchecked, even if the source error had been checked. The original error
189  /// becomes a checked Success value, regardless of its original state.
190  Error(Error &&Other) {
191    setChecked(true);
192    *this = std::move(Other);
7
←
Object 'EC' is moved→
193  }
194 
195  /// Create an error value. Prefer using the 'make_error' function, but
196  /// this constructor can be useful when "re-throwing" errors from handlers.
197  Error(std::unique_ptr<ErrorInfoBase> Payload) {
198    setPtr(Payload.release());
199    setChecked(false);
200  }
201 
202  // Errors are not copy-assignable.
203  Error &operator=(const Error &Other) = delete;
204 
205  /// Move-assign an error value. The current error must represent success, you
206  /// you cannot overwrite an unhandled error. The current error is then
207  /// considered unchecked. The source error becomes a checked success value,
208  /// regardless of its original state.
209  Error &operator=(Error &&Other) {
210    // Don't allow overwriting of unchecked values.
211    assertIsChecked();
212    setPtr(Other.getPtr());
213 
214    // This Error is unchecked, even if the source error was checked.
215    setChecked(false);
216 
217    // Null out Other's payload and set its checked bit.
218    Other.setPtr(nullptr);
219    Other.setChecked(true);
220 
221    return *this;
222  }
223 
224  /// Destroy a Error. Fails with a call to abort() if the error is
225  /// unchecked.
226  ~Error() {
227    assertIsChecked();
228    delete getPtr();
229  }
230 
231  /// Bool conversion. Returns true if this Error is in a failure state,
232  /// and false if it is in an accept state. If the error is in a Success state
233  /// it will be considered checked.
234  explicit operator bool() {
235    setChecked(getPtr() == nullptr);
236    return getPtr() != nullptr;
237  }
238 
239  /// Check whether one error is a subclass of another.
240  template <typename ErrT> bool isA() const {
241    return getPtr() && getPtr()->isA(ErrT::classID());
242  }
243 
244  /// Returns the dynamic class id of this error, or null if this is a success
245  /// value.
246  const void* dynamicClassID() const {
247    if (!getPtr())
248      return nullptr;
249    return getPtr()->dynamicClassID();
250  }
251 
252private:
253#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
254  // assertIsChecked() happens very frequently, but under normal circumstances
255  // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
256  // of debug prints can cause the function to be too large for inlining.  So
257  // it's important that we define this function out of line so that it can't be
258  // inlined.
259  [[noreturn]] void fatalUncheckedError() const;
260#endif
261 
262  void assertIsChecked() {
263#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
264    if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
265      fatalUncheckedError();
266#endif
267  }
268 
269  ErrorInfoBase *getPtr() const {
270#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
271    return reinterpret_cast<ErrorInfoBase*>(
272             reinterpret_cast<uintptr_t>(Payload) &
273             ~static_cast<uintptr_t>(0x1));
274#else
275    return Payload;
276#endif
277  }
278 
279  void setPtr(ErrorInfoBase *EI) {
280#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
281    Payload = reinterpret_cast<ErrorInfoBase*>(
282                (reinterpret_cast<uintptr_t>(EI) &
283                 ~static_cast<uintptr_t>(0x1)) |
284                (reinterpret_cast<uintptr_t>(Payload) & 0x1));
285#else
286    Payload = EI;
287#endif
288  }
289 
290  bool getChecked() const {
291#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
292    return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
293#else
294    return true;
295#endif
296  }
297 
298  void setChecked(bool V) {
299#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
300    Payload = reinterpret_cast<ErrorInfoBase*>(
301                (reinterpret_cast<uintptr_t>(Payload) &
302                  ~static_cast<uintptr_t>(0x1)) |
303                  (V ? 0 : 1));
304#endif
305  }
306 
307  std::unique_ptr<ErrorInfoBase> takePayload() {
308    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
309    setPtr(nullptr);
310    setChecked(true);
311    return Tmp;
312  }
313 
314  friend raw_ostream &operator<<(raw_ostream &OS, const Error &E) {
315    if (auto *P = E.getPtr())
316      P->log(OS);
317    else
318      OS << "success";
319    return OS;
320  }
321 
322  ErrorInfoBase *Payload = nullptr;
323};
324 
325/// Subclass of Error for the sole purpose of identifying the success path in
326/// the type system. This allows to catch invalid conversion to Expected<T> at
327/// compile time.
328class ErrorSuccess final : public Error {};
329 
330inline ErrorSuccess Error::success() { return ErrorSuccess(); }
331 
332/// Make a Error instance representing failure using the given error info
333/// type.
334template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
335  return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
336}
337 
338/// Base class for user error types. Users should declare their error types
339/// like:
340///
341/// class MyError : public ErrorInfo<MyError> {
342///   ....
343/// };
344///
345/// This class provides an implementation of the ErrorInfoBase::kind
346/// method, which is used by the Error RTTI system.
347template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
348class ErrorInfo : public ParentErrT {
349public:
350  using ParentErrT::ParentErrT; // inherit constructors
351 
352  static const void *classID() { return &ThisErrT::ID; }
353 
354  const void *dynamicClassID() const override { return &ThisErrT::ID; }
355 
356  bool isA(const void *const ClassID) const override {
357    return ClassID == classID() || ParentErrT::isA(ClassID);
358  }
359};
360 
361/// Special ErrorInfo subclass representing a list of ErrorInfos.
362/// Instances of this class are constructed by joinError.
363class ErrorList final : public ErrorInfo<ErrorList> {
364  // handleErrors needs to be able to iterate the payload list of an
365  // ErrorList.
366  template <typename... HandlerTs>
367  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
368 
369  // joinErrors is implemented in terms of join.
370  friend Error joinErrors(Error, Error);
371 
372public:
373  void log(raw_ostream &OS) const override {
374    OS << "Multiple errors:\n";
375    for (const auto &ErrPayload : Payloads) {
376      ErrPayload->log(OS);
377      OS << "\n";
378    }
379  }
380 
381  std::error_code convertToErrorCode() const override;
382 
383  // Used by ErrorInfo::classID.
384  static char ID;
385 
386private:
387  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
388            std::unique_ptr<ErrorInfoBase> Payload2) {
389    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", 390, __extension__ __PRETTY_FUNCTION__
))
390           "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", 390, __extension__ __PRETTY_FUNCTION__
));
391    Payloads.push_back(std::move(Payload1));
392    Payloads.push_back(std::move(Payload2));
393  }
394 
395  static Error join(Error E1, Error E2) {
396    if (!E1)
397      return E2;
398    if (!E2)
399      return E1;
400    if (E1.isA<ErrorList>()) {
401      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
402      if (E2.isA<ErrorList>()) {
403        auto E2Payload = E2.takePayload();
404        auto &E2List = static_cast<ErrorList &>(*E2Payload);
405        for (auto &Payload : E2List.Payloads)
406          E1List.Payloads.push_back(std::move(Payload));
407      } else
408        E1List.Payloads.push_back(E2.takePayload());
409 
410      return E1;
411    }
412    if (E2.isA<ErrorList>()) {
413      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
414      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
415      return E2;
416    }
417    return Error(std::unique_ptr<ErrorList>(
418        new ErrorList(E1.takePayload(), E2.takePayload())));
419  }
420 
421  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
422};
423 
424/// Concatenate errors. The resulting Error is unchecked, and contains the
425/// ErrorInfo(s), if any, contained in E1, followed by the
426/// ErrorInfo(s), if any, contained in E2.
427inline Error joinErrors(Error E1, Error E2) {
428  return ErrorList::join(std::move(E1), std::move(E2));
429}
430 
431/// Tagged union holding either a T or a Error.
432///
433/// This class parallels ErrorOr, but replaces error_code with Error. Since
434/// Error cannot be copied, this class replaces getError() with
435/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
436/// error class type.
437///
438/// Example usage of 'Expected<T>' as a function return type:
439///
440///   @code{.cpp}
441///     Expected<int> myDivide(int A, int B) {
442///       if (B == 0) {
443///         // return an Error
444///         return createStringError(inconvertibleErrorCode(),
445///                                  "B must not be zero!");
446///       }
447///       // return an integer
448///       return A / B;
449///     }
450///   @endcode
451///
452///   Checking the results of to a function returning 'Expected<T>':
453///   @code{.cpp}
454///     if (auto E = Result.takeError()) {
455///       // We must consume the error. Typically one of:
456///       // - return the error to our caller
457///       // - toString(), when logging
458///       // - consumeError(), to silently swallow the error
459///       // - handleErrors(), to distinguish error types
460///       errs() << "Problem with division " << toString(std::move(E)) << "\n";
461///       return;
462///     }
463///     // use the result
464///     outs() << "The answer is " << *Result << "\n";
465///   @endcode
466///
467///  For unit-testing a function returning an 'Expected<T>', see the
468///  'EXPECT_THAT_EXPECTED' macros in llvm/Testing/Support/Error.h
469 
470template <class T> class [[nodiscard]] Expected {
471  template <class T1> friend class ExpectedAsOutParameter;
472  template <class OtherT> friend class Expected;
473 
474  static constexpr bool isRef = std::is_reference_v<T>;
475 
476  using wrap = std::reference_wrapper<std::remove_reference_t<T>>;
477 
478  using error_type = std::unique_ptr<ErrorInfoBase>;
479 
480public:
481  using storage_type = std::conditional_t<isRef, wrap, T>;
482  using value_type = T;
483 
484private:
485  using reference = std::remove_reference_t<T> &;
486  using const_reference = const std::remove_reference_t<T> &;
487  using pointer = std::remove_reference_t<T> *;
488  using const_pointer = const std::remove_reference_t<T> *;
489 
490public:
491  /// Create an Expected<T> error value from the given Error.
492  Expected(Error Err)
493      : HasError(true)
494#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
495        // Expected is unchecked upon construction in Debug builds.
496        , Unchecked(true)
497#endif
498  {
499    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", 499, __extension__ __PRETTY_FUNCTION__
));
500    new (getErrorStorage()) error_type(Err.takePayload());
501  }
502 
503  /// Forbid to convert from Error::success() implicitly, this avoids having
504  /// Expected<T> foo() { return Error::success(); } which compiles otherwise
505  /// but triggers the assertion above.
506  Expected(ErrorSuccess) = delete;
507 
508  /// Create an Expected<T> success value from the given OtherT value, which
509  /// must be convertible to T.
510  template <typename OtherT>
511  Expected(OtherT &&Val,
512           std::enable_if_t<std::is_convertible_v<OtherT, T>> * = nullptr)
513      : HasError(false)
514#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
515        // Expected is unchecked upon construction in Debug builds.
516        ,
517        Unchecked(true)
518#endif
519  {
520    new (getStorage()) storage_type(std::forward<OtherT>(Val));
521  }
522 
523  /// Move construct an Expected<T> value.
524  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
525 
526  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
527  /// must be convertible to T.
528  template <class OtherT>
529  Expected(Expected<OtherT> &&Other,
530           std::enable_if_t<std::is_convertible_v<OtherT, T>> * = 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_v<OtherT, T>> * = 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(
581      OtherT &Value,
582      std::enable_if_t<std::is_assignable_v<OtherT &, T &&>> * = 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<
826          decltype(&std::remove_reference_t<HandlerT>::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 std::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> std::optional<T> expectedToOptional(Expected<T> &&E) {
1055  if (E)
1056    return std::move(*E);
1057  consumeError(E.takeError());
1058  return std::nullopt;
1059}
1060 
1061template <typename T> std::optional<T> expectedToStdOptional(Expected<T> &&E) {
1062  if (E)
1063    return std::move(*E);
1064  consumeError(E.takeError());
1065  return std::nullopt;
1066}
1067 
1068/// Helper for converting an Error to a bool.
1069///
1070/// This method returns true if Err is in an error state, or false if it is
1071/// in a success state.  Puts Err in a checked state in both cases (unlike
1072/// Error::operator bool(), which only does this for success states).
1073inline bool errorToBool(Error Err) {
1074  bool IsError = static_cast<bool>(Err);
1075  if (IsError)
1076    consumeError(std::move(Err));
1077  return IsError;
1078}
1079 
1080/// Helper for Errors used as out-parameters.
1081///
1082/// This helper is for use with the Error-as-out-parameter idiom, where an error
1083/// is passed to a function or method by reference, rather than being returned.
1084/// In such cases it is helpful to set the checked bit on entry to the function
1085/// so that the error can be written to (unchecked Errors abort on assignment)
1086/// and clear the checked bit on exit so that clients cannot accidentally forget
1087/// to check the result. This helper performs these actions automatically using
1088/// RAII:
1089///
1090///   @code{.cpp}
1091///   Result foo(Error &Err) {
1092///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
1093///     // <body of foo>
1094///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
1095///   }
1096///   @endcode
1097///
1098/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
1099/// used with optional Errors (Error pointers that are allowed to be null). If
1100/// ErrorAsOutParameter took an Error reference, an instance would have to be
1101/// created inside every condition that verified that Error was non-null. By
1102/// taking an Error pointer we can just create one instance at the top of the
1103/// function.
1104class ErrorAsOutParameter {
1105public:
1106  ErrorAsOutParameter(Error *Err) : Err(Err) {
1107    // Raise the checked bit if Err is success.
1108    if (Err)
1109      (void)!!*Err;
1110  }
1111 
1112  ~ErrorAsOutParameter() {
1113    // Clear the checked bit.
1114    if (Err && !*Err)
1115      *Err = Error::success();
1116  }
1117 
1118private:
1119  Error *Err;
1120};
1121 
1122/// Helper for Expected<T>s used as out-parameters.
1123///
1124/// See ErrorAsOutParameter.
1125template <typename T>
1126class ExpectedAsOutParameter {
1127public:
1128  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1129    : ValOrErr(ValOrErr) {
1130    if (ValOrErr)
1131      (void)!!*ValOrErr;
1132  }
1133 
1134  ~ExpectedAsOutParameter() {
1135    if (ValOrErr)
1136      ValOrErr->setUnchecked();
1137  }
1138 
1139private:
1140  Expected<T> *ValOrErr;
1141};
1142 
1143/// This class wraps a std::error_code in a Error.
1144///
1145/// This is useful if you're writing an interface that returns a Error
1146/// (or Expected) and you want to call code that still returns
1147/// std::error_codes.
1148class ECError : public ErrorInfo<ECError> {
1149  friend Error errorCodeToError(std::error_code);
1150 
1151  void anchor() override;
1152 
1153public:
1154  void setErrorCode(std::error_code EC) { this->EC = EC; }
1155  std::error_code convertToErrorCode() const override { return EC; }
1156  void log(raw_ostream &OS) const override { OS << EC.message(); }
1157 
1158  // Used by ErrorInfo::classID.
1159  static char ID;
1160 
1161protected:
1162  ECError() = default;
1163  ECError(std::error_code EC) : EC(EC) {}
1164 
1165  std::error_code EC;
1166};
1167 
1168/// The value returned by this function can be returned from convertToErrorCode
1169/// for Error values where no sensible translation to std::error_code exists.
1170/// It should only be used in this situation, and should never be used where a
1171/// sensible conversion to std::error_code is available, as attempts to convert
1172/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1173/// error to try to convert such a value).
1174std::error_code inconvertibleErrorCode();
1175 
1176/// Helper for converting an std::error_code to a Error.
1177Error errorCodeToError(std::error_code EC);
1178 
1179/// Helper for converting an ECError to a std::error_code.
1180///
1181/// This method requires that Err be Error() or an ECError, otherwise it
1182/// will trigger a call to abort().
1183std::error_code errorToErrorCode(Error Err);
1184 
1185/// Convert an ErrorOr<T> to an Expected<T>.
1186template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1187  if (auto EC = EO.getError())
1188    return errorCodeToError(EC);
1189  return std::move(*EO);
1190}
1191 
1192/// Convert an Expected<T> to an ErrorOr<T>.
1193template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1194  if (auto Err = E.takeError())
1195    return errorToErrorCode(std::move(Err));
1196  return std::move(*E);
1197}
1198 
1199/// This class wraps a string in an Error.
1200///
1201/// StringError is useful in cases where the client is not expected to be able
1202/// to consume the specific error message programmatically (for example, if the
1203/// error message is to be presented to the user).
1204///
1205/// StringError can also be used when additional information is to be printed
1206/// along with a error_code message. Depending on the constructor called, this
1207/// class can either display:
1208///    1. the error_code message (ECError behavior)
1209///    2. a string
1210///    3. the error_code message and a string
1211///
1212/// These behaviors are useful when subtyping is required; for example, when a
1213/// specific library needs an explicit error type. In the example below,
1214/// PDBError is derived from StringError:
1215///
1216///   @code{.cpp}
1217///   Expected<int> foo() {
1218///      return llvm::make_error<PDBError>(pdb_error_code::dia_failed_loading,
1219///                                        "Additional information");
1220///   }
1221///   @endcode
1222///
1223class StringError : public ErrorInfo<StringError> {
1224public:
1225  static char ID;
1226 
1227  // Prints EC + S and converts to EC
1228  StringError(std::error_code EC, const Twine &S = Twine());
1229 
1230  // Prints S and converts to EC
1231  StringError(const Twine &S, std::error_code EC);
1232 
1233  void log(raw_ostream &OS) const override;
1234  std::error_code convertToErrorCode() const override;
1235 
1236  const std::string &getMessage() const { return Msg; }
1237 
1238private:
1239  std::string Msg;
1240  std::error_code EC;
1241  const bool PrintMsgOnly = false;
1242};
1243 
1244/// Create formatted StringError object.
1245template <typename... Ts>
1246inline Error createStringError(std::error_code EC, char const *Fmt,
1247                               const Ts &... Vals) {
1248  std::string Buffer;
1249  raw_string_ostream Stream(Buffer);
1250  Stream << format(Fmt, Vals...);
1251  return make_error<StringError>(Stream.str(), EC);
1252}
1253 
1254Error createStringError(std::error_code EC, char const *Msg);
1255 
1256inline Error createStringError(std::error_code EC, const Twine &S) {
1257  return createStringError(EC, S.str().c_str());
1258}
1259 
1260template <typename... Ts>
1261inline Error createStringError(std::errc EC, char const *Fmt,
1262                               const Ts &... Vals) {
1263  return createStringError(std::make_error_code(EC), Fmt, Vals...);
1264}
1265 
1266/// This class wraps a filename and another Error.
1267///
1268/// In some cases, an error needs to live along a 'source' name, in order to
1269/// show more detailed information to the user.
1270class FileError final : public ErrorInfo<FileError> {
1271 
1272  friend Error createFileError(const Twine &, Error);
1273  friend Error createFileError(const Twine &, size_t, Error);
1274 
1275public:
1276  void log(raw_ostream &OS) const override {
1277    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", 1277, __extension__ __PRETTY_FUNCTION__
));
1278    OS << "'" << FileName << "': ";
1279    if (Line)
1280      OS << "line " << *Line << ": ";
1281    Err->log(OS);
1282  }
1283 
1284  std::string messageWithoutFileInfo() const {
1285    std::string Msg;
1286    raw_string_ostream OS(Msg);
1287    Err->log(OS);
1288    return OS.str();
1289  }
1290 
1291  StringRef getFileName() const { return FileName; }
1292 
1293  Error takeError() { return Error(std::move(Err)); }
1294 
1295  std::error_code convertToErrorCode() const override;
1296 
1297  // Used by ErrorInfo::classID.
1298  static char ID;
1299 
1300private:
1301  FileError(const Twine &F, std::optional<size_t> LineNum,
1302            std::unique_ptr<ErrorInfoBase> E) {
1303    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", 1303, __extension__ __PRETTY_FUNCTION__
));
1304    FileName = F.str();
1305    Err = std::move(E);
1306    Line = std::move(LineNum);
1307  }
1308 
1309  static Error build(const Twine &F, std::optional<size_t> Line, Error E) {
1310    std::unique_ptr<ErrorInfoBase> Payload;
1311    handleAllErrors(std::move(E),
1312                    [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error {
1313                      Payload = std::move(EIB);
1314                      return Error::success();
1315                    });
1316    return Error(
1317        std::unique_ptr<FileError>(new FileError(F, Line, std::move(Payload))));
1318  }
1319 
1320  std::string FileName;
1321  std::optional<size_t> Line;
1322  std::unique_ptr<ErrorInfoBase> Err;
1323};
1324 
1325/// Concatenate a source file path and/or name with an Error. The resulting
1326/// Error is unchecked.
1327inline Error createFileError(const Twine &F, Error E) {
1328  return FileError::build(F, std::optional<size_t>(), std::move(E));
1329}
1330 
1331/// Concatenate a source file path and/or name with line number and an Error.
1332/// The resulting Error is unchecked.
1333inline Error createFileError(const Twine &F, size_t Line, Error E) {
1334  return FileError::build(F, std::optional<size_t>(Line), std::move(E));
1335}
1336 
1337/// Concatenate a source file path and/or name with a std::error_code 
1338/// to form an Error object.
1339inline Error createFileError(const Twine &F, std::error_code EC) {
1340  return createFileError(F, errorCodeToError(EC));
1341}
1342 
1343/// Concatenate a source file path and/or name with line number and
1344/// std::error_code to form an Error object.
1345inline Error createFileError(const Twine &F, size_t Line, std::error_code EC) {
1346  return createFileError(F, Line, errorCodeToError(EC));
1347}
1348 
1349Error createFileError(const Twine &F, ErrorSuccess) = delete;
1350 
1351/// Helper for check-and-exit error handling.
1352///
1353/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1354///
1355class ExitOnError {
1356public:
1357  /// Create an error on exit helper.
1358  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1359      : Banner(std::move(Banner)),
1360        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1361 
1362  /// Set the banner string for any errors caught by operator().
1363  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1364 
1365  /// Set the exit-code mapper function.
1366  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1367    this->GetExitCode = std::move(GetExitCode);
1368  }
1369 
1370  /// Check Err. If it's in a failure state log the error(s) and exit.
1371  void operator()(Error Err) const { checkError(std::move(Err)); }
1372 
1373  /// Check E. If it's in a success state then return the contained value. 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 std::move(*E);
1378  }
1379 
1380  /// Check E. If it's in a success state then return the contained reference. If
1381  /// it's in a failure state log the error(s) and exit.
1382  template <typename T> T& operator()(Expected<T&> &&E) const {
1383    checkError(E.takeError());
1384    return *E;
1385  }
1386 
1387private:
1388  void checkError(Error Err) const {
1389    if (Err) {
1390      int ExitCode = GetExitCode(Err);
1391      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1392      exit(ExitCode);
1393    }
1394  }
1395 
1396  std::string Banner;
1397  std::function<int(const Error &)> GetExitCode;
1398};
1399 
1400/// Conversion from Error to LLVMErrorRef for C error bindings.
1401inline LLVMErrorRef wrap(Error Err) {
1402  return reinterpret_cast<LLVMErrorRef>(Err.takePayload().release());
1403}
1404 
1405/// Conversion from LLVMErrorRef to Error for C error bindings.
1406inline Error unwrap(LLVMErrorRef ErrRef) {
1407  return Error(std::unique_ptr<ErrorInfoBase>(
1408      reinterpret_cast<ErrorInfoBase *>(ErrRef)));
1409}
1410 
1411} // end namespace llvm
1412 
1413#endif // LLVM_SUPPORT_ERROR_H