/build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp

Bug Summary

File:	tools/llvm-pdbutil/DumpOutputStyle.cpp
Warning:	line 1011, column 15 The left operand of '!=' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name DumpOutputStyle.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/llvm-pdbutil -I /build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil -I /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn326246/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn326246/build-llvm/tools/llvm-pdbutil -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-02-28-041547-14988-1 -x c++ /build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp

/build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp

→

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

10#include "DumpOutputStyle.h"

12#include "FormatUtil.h"
13#include "InputFile.h"
14#include "MinimalSymbolDumper.h"
15#include "MinimalTypeDumper.h"
16#include "StreamUtil.h"
17#include "llvm-pdbutil.h"

19#include "llvm/ADT/STLExtras.h"
20#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
21#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
22#include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
23#include "llvm/DebugInfo/CodeView/DebugCrossExSubsection.h"
24#include "llvm/DebugInfo/CodeView/DebugCrossImpSubsection.h"
25#include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
26#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
27#include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
28#include "llvm/DebugInfo/CodeView/DebugSymbolsSubsection.h"
29#include "llvm/DebugInfo/CodeView/Formatters.h"
30#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
31#include "llvm/DebugInfo/CodeView/Line.h"
32#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
33#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
34#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
35#include "llvm/DebugInfo/CodeView/TypeHashing.h"
36#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
37#include "llvm/DebugInfo/MSF/MappedBlockStream.h"
38#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
39#include "llvm/DebugInfo/PDB/Native/DbiStream.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/ModuleDebugStream.h"
44#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
45#include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
46#include "llvm/DebugInfo/PDB/Native/RawError.h"
47#include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
48#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
49#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
50#include "llvm/Object/COFF.h"
51#include "llvm/Support/BinaryStreamReader.h"
52#include "llvm/Support/FormatAdapters.h"
53#include "llvm/Support/FormatVariadic.h"

55#include <cctype>

57using namespace llvm;
58using namespace llvm::codeview;
59using namespace llvm::msf;
60using namespace llvm::pdb;

62DumpOutputStyle::DumpOutputStyle(InputFile &File)
  : File(File), P(2, false, outs()) {}

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

68Error DumpOutputStyle::dump() {
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) {
  if (auto EC = dumpSymbolStats())
    return EC;
  P.NewLine();
}

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

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

if (opts::dump::DumpModules) {
  if (auto EC = dumpModules())
    return EC;
}

if (opts::dump::DumpModuleFiles) {
  if (auto EC = dumpModuleFiles())
    return EC;
}

if (opts::dump::DumpLines) {
  if (auto EC = dumpLines())
    return EC;
}

if (opts::dump::DumpInlineeLines) {
  if (auto EC = dumpInlineeLines())
    return EC;
}

if (opts::dump::DumpXmi) {
  if (auto EC = dumpXmi())
    return EC;
}

if (opts::dump::DumpXme) {
  if (auto EC = dumpXme())
    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::DumpGlobals) {
  if (auto EC = dumpGlobals())
    return EC;
}

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

if (opts::dump::DumpSymbols) {
  auto EC = File.isPdb() ? dumpModuleSymsForPdb() : dumpModuleSymsForObj();
  if (EC)
    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;
}

return Error::success();
180}

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

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

ExitOnError Err("Invalid PDB Format: ");

AutoIndent Indent(P);
if (File.isObj()) {
  P.formatLine("Dumping File summary is not valid for object files");
  return Error::success();
}

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()) {
  auto &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();
221}

223static StatCollection getSymbolStats(const SymbolGroup &SG,
                                   StatCollection &CumulativeStats) {
StatCollection Stats;
if (SG.getFile().isPdb()) {
  // 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;
249}

251static 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;
259}

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

265static inline std::string formatModuleDetailKind(SymbolKind K) {
return formatSymbolKind(K);
267}

269template <typename Kind>
270static 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,8} bytes)", "Total",
             Stats.Totals.Count, Stats.Totals.Size);
P.formatLine("{0}", fmt_repeat('-', 74));
for (const auto &K : Stats.Individual) {
  std::string KindName = formatModuleDetailKind(Kind(K.first));
  P.formatLine("{0,40}: {1,7} entries ({2,8} bytes)", KindName,
               K.second.Count, K.second.Size);
}
283}

285static bool isMyCode(const SymbolGroup &Group) {
if (Group.getFile().isObj())
  return true;

StringRef Name = Group.name();
if (Name.startswith("Import:"))
  return false;
if (Name.endswith_lower(".dll"))
  return false;
if (Name.equals_lower("* linker *"))
  return false;
if (Name.startswith_lower("f:\\binaries\\Intermediate\\vctools"))
  return false;
if (Name.startswith_lower("f:\\dd\\vctools\\crt"))
  return false;
return true;
301}

303static bool shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group) {
if (opts::dump::JustMyCode && !isMyCode(Group))
  return false;

// If the arg was not specified on the command line, always dump all modules.
if (opts::dump::DumpModi.getNumOccurrences() == 0)
  return true;

// Otherwise, only dump if this is the same module specified.
return (opts::dump::DumpModi == Idx);
313}

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

AutoIndent Indent(P);
if (File.isObj()) {
  P.formatLine("Dumping streams is not valid for object files");
  return Error::success();
}

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

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

for (uint16_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();
348}

350static Expected<ModuleDebugStreamRef> getModuleDebugStream(PDBFile &File,
                                                         uint32_t Index) {
ExitOnError Err("Unexpected error: ");

auto &Dbi = Err(File.getPDBDbiStream());
const auto &Modules = Dbi.modules();
auto Modi = Modules.getModuleDescriptor(Index);

uint16_t ModiStream = Modi.getModuleStreamIndex();
if (ModiStream == kInvalidStreamIndex)
  return make_error<RawError>(raw_error_code::no_stream,
                              "Module stream not present");

auto ModStreamData = File.createIndexedStream(ModiStream);

ModuleDebugStreamRef ModS(Modi, std::move(ModStreamData));
if (auto EC = ModS.reload())
  return make_error<RawError>(raw_error_code::corrupt_file,
                              "Invalid module stream");

return std::move(ModS);
371}

373template <typename CallbackT>
374static void
375iterateOneModule(InputFile &File, const Optional<PrintScope> &HeaderScope,
               const SymbolGroup &SG, uint32_t Modi, CallbackT Callback) {
if (HeaderScope) {
  HeaderScope->P.formatLine(
      "Mod {0:4} | `{1}`: ",
      fmt_align(Modi, AlignStyle::Right, HeaderScope->LabelWidth), SG.name());
}

AutoIndent Indent(HeaderScope);
Callback(Modi, SG);
385}

387template <typename CallbackT>
388static void iterateSymbolGroups(InputFile &Input,
                              const Optional<PrintScope> &HeaderScope,
                              CallbackT Callback) {
AutoIndent Indent(HeaderScope);

ExitOnError Err("Unexpected error processing modules: ");

if (opts::dump::DumpModi.getNumOccurrences() > 0) {
  assert(opts::dump::DumpModi.getNumOccurrences() == 1)(static_cast <bool> (opts::dump::DumpModi.getNumOccurrences
() == 1) ? void (0) : __assert_fail ("opts::dump::DumpModi.getNumOccurrences() == 1"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp"
, 396, __extension__ __PRETTY_FUNCTION__));
  uint32_t Modi = opts::dump::DumpModi;
  SymbolGroup SG(&Input, Modi);
  iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(Modi)), SG,
                   Modi, Callback);
  return;
}

uint32_t I = 0;

for (const auto &SG : Input.symbol_groups()) {
  if (shouldDumpSymbolGroup(I, SG))
    iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(I)), SG, I,
                     Callback);

  ++I;
}
413}

415template <typename SubsectionT>
416static void iterateModuleSubsections(
  InputFile &File, const Optional<PrintScope> &HeaderScope,
  llvm::function_ref<void(uint32_t, const SymbolGroup &, SubsectionT &)>
      Callback) {

iterateSymbolGroups(File, HeaderScope,
                    [&](uint32_t Modi, const SymbolGroup &SG) {
                      for (const auto &SS : SG.getDebugSubsections()) {
                        SubsectionT Subsection;

                        if (SS.kind() != Subsection.kind())
                          continue;

                        BinaryStreamReader Reader(SS.getRecordData());
                        if (auto EC = Subsection.initialize(Reader))
                          continue;
                        Callback(Modi, SG, Subsection);
                      }
                    });
435}

437Error DumpOutputStyle::dumpModules() {
printHeader(P, "Modules");
AutoIndent Indent(P);

if (File.isObj()) {
  P.formatLine("Dumping modules is not supported for object files");
  return Error::success();
}

if (!getPdb().hasPDBDbiStream()) {
  P.formatLine("DBI Stream not present");
  return Error::success();
}

ExitOnError Err("Unexpected error processing modules: ");

auto &Stream = Err(getPdb().getPDBDbiStream());

const DbiModuleList &Modules = Stream.modules();
iterateSymbolGroups(
    File, PrintScope{P, 11}, [&](uint32_t Modi, const SymbolGroup &Strings) {
      auto Desc = Modules.getModuleDescriptor(Modi);
      P.formatLine("Obj: `{0}`: ", Desc.getObjFileName());
      P.formatLine("debug stream: {0}, # files: {1}, has ec info: {2}",
                   Desc.getModuleStreamIndex(), Desc.getNumberOfFiles(),
                   Desc.hasECInfo());
      StringRef PdbFilePath =
          Err(Stream.getECName(Desc.getPdbFilePathNameIndex()));
      StringRef SrcFilePath =
          Err(Stream.getECName(Desc.getSourceFileNameIndex()));
      P.formatLine("pdb file ni: {0} `{1}`, src file ni: {2} `{3}`",
                   Desc.getPdbFilePathNameIndex(), PdbFilePath,
                   Desc.getSourceFileNameIndex(), SrcFilePath);
    });
return Error::success();
472}

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

if (File.isObj()) {
  P.formatLine("Dumping files is not valid for object files");
  return Error::success();
}

ExitOnError Err("Unexpected error processing modules: ");

iterateSymbolGroups(File, PrintScope{P, 11},
                    [this, &Err](uint32_t Modi, const SymbolGroup &Strings) {
                      auto &Stream = Err(getPdb().getPDBDbiStream());

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

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

ExitOnError Err("Unexpected error processing modules: ");

StatCollection SymStats;
StatCollection ChunkStats;

Optional<PrintScope> Scope;
if (File.isPdb())
  Scope.emplace(P, 2);

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

  if (SG.getFile().isPdb()) {
    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;
    }
    P.formatLine("Stream {0}, {1} bytes", StreamIdx,
                 getPdb().getStreamByteSize(StreamIdx));

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

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

return Error::success();
541}

543static 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); });
551}

553namespace {
554constexpr uint32_t kNoneUdtKind = 0;
555constexpr uint32_t kSimpleUdtKind = 1;
556constexpr uint32_t kUnknownUdtKind = 2;
557const StringRef NoneLabel("<none type>");
558const StringRef SimpleLabel("<simple type>");
559const StringRef UnknownLabel("<unknown type>");

561} // namespace

563static StringRef getUdtStatLabel(uint32_t Kind) {
if (Kind == kNoneUdtKind)
  return NoneLabel;

if (Kind == kSimpleUdtKind)
  return SimpleLabel;

if (Kind == kUnknownUdtKind)
  return UnknownLabel;

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

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

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

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 (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()) {
  if (!getPdb().hasPDBGlobalsStream()) {
    P.printLine("- Error: globals stream not present");
    return Error::success();
  }

  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.Individual) {
  StringRef 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));
for (const auto &Stat : NamespacedStats) {
  std::string Label = formatv("namespace '{0}'", Stat.getKey());
  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));
}
return Error::success();
708}

710static 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();
}
742}

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

uint32_t LastModi = UINT32_MAX(4294967295U);
uint32_t LastNameIndex = UINT32_MAX(4294967295U);
iterateModuleSubsections<DebugLinesSubsectionRef>(
    File, PrintScope{P, 4},
    [this, &LastModi, &LastNameIndex](uint32_t Modi,
                                      const SymbolGroup &Strings,
                                      DebugLinesSubsectionRef &Lines) {
      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();
778}

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

iterateModuleSubsections<DebugInlineeLinesSubsectionRef>(
    File, PrintScope{P, 2},
    [this](uint32_t Modi, const SymbolGroup &Strings,
           DebugInlineeLinesSubsectionRef &Lines) {
      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);
      }
      P.NewLine();
    });

return Error::success();
797}

799Error DumpOutputStyle::dumpXmi() {
printHeader(P, "Cross Module Imports");
iterateModuleSubsections<DebugCrossModuleImportsSubsectionRef>(
    File, PrintScope{P, 2},
    [this](uint32_t Modi, const SymbolGroup &Strings,
           DebugCrossModuleImportsSubsectionRef &Imports) {
      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(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();
832}

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

iterateModuleSubsections<DebugCrossModuleExportsSubsectionRef>(
    File, PrintScope{P, 2},
    [this](uint32_t Modi, const SymbolGroup &Strings,
           DebugCrossModuleExportsSubsectionRef &Exports) {
      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();
849}

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

if (IS->name_ids().empty()) {
  P.formatLine("Empty");
  return Error::success();
}

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());
std::sort(SortedIDs.begin(), SortedIDs.end());
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);
}
return Error::success();
889}

891Error DumpOutputStyle::dumpStringTableFromObj() {
iterateModuleSubsections<DebugStringTableSubsectionRef>(
    File, PrintScope{P, 4},
    [&](uint32_t Modi, const SymbolGroup &Strings,
        DebugStringTableSubsectionRef &Strings2) {
      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();
910}

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

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

return dumpStringTableFromObj();
919}

921static 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);
}
935}

937static void
938dumpFullTypeStream(LinePrinter &Printer, LazyRandomTypeCollection &Types,
                 uint32_t NumTypeRecords, uint32_t NumHashBuckets,
                 FixedStreamArray<support::ulittle32_t> HashValues,
                 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,
                         NumHashBuckets, HashValues);

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

955static void dumpPartialTypeStream(LinePrinter &Printer,
                                LazyRandomTypeCollection &Types,
                                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,
                         Stream.getNumHashBuckets(), Stream.getHashValues());

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);
    CVType Type = Types.getType(TI);
    if (auto EC = codeview::visitTypeRecord(Type, TI, V))
      Printer.formatLine("An error occurred dumping type record {0}: {1}", TI,
                         toString(std::move(EC)));
  }
}
991}

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

for (const auto &S : getObj().sections()) {
  StringRef SectionName;
  if (auto EC = S.getName(SectionName))
1
Taking false branch→
66
←
Taking false branch→
    return errorCodeToError(EC);

  if (SectionName != ".debug$T")
2
←
Taking false branch→
67
←
Taking false branch→
    continue;
  StringRef Contents;
  if (auto EC = S.getContents(Contents))
3
←
Taking false branch→
68
←
Taking false branch→
    return errorCodeToError(EC);

  uint32_t Magic;
69
←
'Magic' declared without an initial value→
  BinaryStreamReader Reader(Contents, llvm::support::little);
  if (auto EC = Reader.readInteger(Magic))
4
←
Calling 'BinaryStreamReader::readInteger'→
58
←
Returning from 'BinaryStreamReader::readInteger'→
59
←
Taking false branch→
70
←
Calling 'BinaryStreamReader::readInteger'→
115
←
Returning from 'BinaryStreamReader::readInteger'→
116
←
Taking false branch→
    return EC;
  if (Magic != COFF::DEBUG_SECTION_MAGIC)
60
←
Assuming 'Magic' is equal to DEBUG_SECTION_MAGIC→
61
←
Taking false branch→
117
←
The left operand of '!=' is a garbage value
    return make_error<StringError>("Invalid CodeView debug section.",
                                   inconvertibleErrorCode());

  Types.reset(Reader, 100);

  if (opts::dump::DumpTypes) {
62
←
Assuming the condition is false→
63
←
Taking false branch→
    dumpFullTypeStream(P, Types, 0, 0, {}, opts::dump::DumpTypeData, false);
  } else if (opts::dump::DumpTypeExtras) {
64
←
Assuming the condition is false→
65
←
Taking false branch→
    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()"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp"
, 1022, __extension__ __PRETTY_FUNCTION__));

    P.formatLine("Local / Global hashes:");
    TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
    for (const 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();
1040}

1042Error 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"
, "/build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp"
, 1043, __extension__ __PRETTY_FUNCTION__));

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

AutoIndent Indent(P);
assert(!File.isObj())(static_cast <bool> (!File.isObj()) ? void (0) : __assert_fail
 ("!File.isObj()", "/build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp"
, 1052, __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) {
  P.formatLine("Stream not present");
  return Error::success();
}

ExitOnError Err("Unexpected error processing types: ");

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

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

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

if (DumpExtras) {
  P.NewLine();
  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));
  }

  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();
1125}

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

AutoIndent Indent(P);

ExitOnError Err("Unexpected error processing symbols: ");

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);

std::unique_ptr<llvm::Error> SymbolError;

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

if (SymbolError)
  return std::move(*SymbolError);

return Error::success();
1163}

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

AutoIndent Indent(P);
if (!getPdb().hasPDBDbiStream()) {
  P.formatLine("DBI Stream not present");
  return Error::success();
}

ExitOnError Err("Unexpected error processing symbols: ");

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

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

      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 (auto EC =
              Visitor.visitSymbolStream(ModS.getSymbolArray(), SS.Offset)) {
        P.formatLine("Error while processing symbol records.  {0}",
                     toString(std::move(EC)));
        return;
      }
    });
return Error::success();
1207}

1209Error DumpOutputStyle::dumpGlobals() {
printHeader(P, "Global Symbols");
AutoIndent Indent(P);

if (File.isObj()) {
  P.formatLine("Dumping Globals is not supported for object files");
  return Error::success();
}

if (!getPdb().hasPDBGlobalsStream()) {
  P.formatLine("Globals stream not present");
  return Error::success();
}
ExitOnError Err("Error dumping globals stream: ");
auto &Globals = Err(getPdb().getPDBGlobalsStream());

const GSIHashTable &Table = Globals.getGlobalsTable();
Err(dumpSymbolsFromGSI(Table, opts::dump::DumpGlobalExtras));
return Error::success();
1228}

1230Error DumpOutputStyle::dumpPublics() {
printHeader(P, "Public Symbols");
AutoIndent Indent(P);

if (File.isObj()) {
  P.formatLine("Dumping Globals is not supported for object files");
  return Error::success();
}

if (!getPdb().hasPDBPublicsStream()) {
  P.formatLine("Publics stream not present");
  return Error::success();
}
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();
1286}

1288Error 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)
  return Error::success();

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));
}

// FIXME: Dump the bitmap.

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

return Error::success();
1347}

1349static 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, " | ");
1363}

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

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

auto &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);
1402}

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

AutoIndent Indent(P);
if (File.isObj()) {
  P.formatLine("Dumping Section Headers is not supported for object files");
  return;
}

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;
}
return;
1448}

1450std::vector<std::string> getSectionNames(PDBFile &File) {
auto ExpectedHeaders = loadSectionHeaders(File, DbgHeaderType::SectionHdr);
if (!ExpectedHeaders)
  return {};

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;
1462}

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

AutoIndent Indent(P);
if (File.isObj()) {
  P.formatLine(
      "Dumping section contributions is not supported for object files");
  return Error::success();
}

ExitOnError Err("Error dumping section contributions: ");
if (!getPdb().hasPDBDbiStream()) {
  P.formatLine(
      "Section contribs require a DBI Stream, which could not be loaded");
  return Error::success();
}

auto &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 {
    assert(SC.ISect > 0)(static_cast <bool> (SC.ISect > 0) ? void (0) : __assert_fail
 ("SC.ISect > 0", "/build/llvm-toolchain-snapshot-7~svn326246/tools/llvm-pdbutil/DumpOutputStyle.cpp"
, 1492, __extension__ __PRETTY_FUNCTION__));
    std::string NameInsert;
    if (SC.ISect < Names.size()) {
      StringRef SectionName = Names[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, MaxNameLen + 2));
    AutoIndent Indent(P, MaxNameLen + 2);
    P.formatLine("      {0}",
                 formatSectionCharacteristics(P.getIndentLevel() + 6,
                                              SC.Characteristics, 3, " | "));
  }
  void visit(const SectionContrib2 &SC) override {
    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, " | "));
  }

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

std::vector<std::string> Names = getSectionNames(getPdb());
Visitor V(P, makeArrayRef(Names));
Dbi.visitSectionContributions(V);
return Error::success();
1531}

1533Error DumpOutputStyle::dumpSectionMap() {
printHeader(P, "Section Map");
AutoIndent Indent(P);

if (File.isObj()) {
  P.formatLine("Dumping section map is not supported for object files");
  return Error::success();
}

ExitOnError Err("Error dumping section map: ");

if (!getPdb().hasPDBDbiStream()) {
  P.formatLine("Dumping the section map requires a DBI Stream, which could "
               "not be loaded");
  return Error::success();
}

auto &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();
1566}

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/BinaryStreamReader.h

→

1//===- BinaryStreamReader.h - Reads objects from a binary stream *- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#ifndef LLVM_SUPPORT_BINARYSTREAMREADER_H
11#define LLVM_SUPPORT_BINARYSTREAMREADER_H

13#include "llvm/ADT/ArrayRef.h"
14#include "llvm/ADT/STLExtras.h"
15#include "llvm/Support/BinaryStreamArray.h"
16#include "llvm/Support/BinaryStreamRef.h"
17#include "llvm/Support/ConvertUTF.h"
18#include "llvm/Support/Endian.h"
19#include "llvm/Support/Error.h"
20#include "llvm/Support/type_traits.h"

22#include <string>
23#include <type_traits>

25namespace llvm {

27/// \brief Provides read only access to a subclass of `BinaryStream`.  Provides
28/// bounds checking and helpers for writing certain common data types such as
29/// null-terminated strings, integers in various flavors of endianness, etc.
30/// Can be subclassed to provide reading of custom datatypes, although no
31/// are overridable.
32class BinaryStreamReader {
33public:
BinaryStreamReader() = default;
explicit BinaryStreamReader(BinaryStreamRef Ref);
explicit BinaryStreamReader(BinaryStream &Stream);
explicit BinaryStreamReader(ArrayRef<uint8_t> Data,
                            llvm::support::endianness Endian);
explicit BinaryStreamReader(StringRef Data, llvm::support::endianness Endian);

BinaryStreamReader(const BinaryStreamReader &Other)
    : Stream(Other.Stream), Offset(Other.Offset) {}

BinaryStreamReader &operator=(const BinaryStreamReader &Other) {
  Stream = Other.Stream;
  Offset = Other.Offset;
  return *this;
}

virtual ~BinaryStreamReader() {}

/// Read as much as possible from the underlying string at the current offset
/// without invoking a copy, and set \p Buffer to the resulting data slice.
/// Updates the stream's offset to point after the newly read data.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readLongestContiguousChunk(ArrayRef<uint8_t> &Buffer);

/// Read \p Size bytes from the underlying stream at the current offset and
/// and set \p Buffer to the resulting data slice.  Whether a copy occurs
/// depends on the implementation of the underlying stream.  Updates the
/// stream's offset to point after the newly read data.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size);

/// Read an integer of the specified endianness into \p Dest and update the
/// stream's offset.  The data is always copied from the stream's underlying
/// buffer into \p Dest. Updates the stream's offset to point after the newly
/// read data.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T> Error readInteger(T &Dest) {
  static_assert(std::is_integral<T>::value,
                "Cannot call readInteger with non-integral value!");

  ArrayRef<uint8_t> Bytes;
  if (auto EC = readBytes(Bytes, sizeof(T)))
5
←
Calling move constructor for 'Error'→
29
←
Returning from move constructor for 'Error'→
30
←
Calling 'Error::operator bool'→
39
←
Returning from 'Error::operator bool'→
40
←
Taking false branch→
71
←
Calling move constructor for 'Error'→
95
←
Returning from move constructor for 'Error'→
96
←
Calling 'Error::operator bool'→
105
←
Returning from 'Error::operator bool'→
106
←
Taking true branch→
    return EC;
41
←
Calling '~Error'→
48
←
Returning from '~Error'→
107
←
Calling '~Error'→
114
←
Returning from '~Error'→

  Dest = llvm::support::endian::read<T, llvm::support::unaligned>(
51
←
Calling 'read'→
55
←
Returning from 'read'→
      Bytes.data(), Stream.getEndian());
49
←
Calling 'BinaryStreamRefBase::getEndian'→
50
←
Returning from 'BinaryStreamRefBase::getEndian'→
  return Error::success();
56
←
Calling 'Error::success'→
57
←
Returning from 'Error::success'→
}

/// Similar to readInteger.
template <typename T> Error readEnum(T &Dest) {
  static_assert(std::is_enum<T>::value,
                "Cannot call readEnum with non-enum value!");
  typename std::underlying_type<T>::type N;
  if (auto EC = readInteger(N))
    return EC;
  Dest = static_cast<T>(N);
  return Error::success();
}

/// Read a null terminated string from \p Dest.  Whether a copy occurs depends
/// on the implementation of the underlying stream.  Updates the stream's
/// offset to point after the newly read data.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readCString(StringRef &Dest);

/// Similar to readCString, however read a null-terminated UTF16 string
/// instead.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readWideString(ArrayRef<UTF16> &Dest);

/// Read a \p Length byte string into \p Dest.  Whether a copy occurs depends
/// on the implementation of the underlying stream.  Updates the stream's
/// offset to point after the newly read data.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readFixedString(StringRef &Dest, uint32_t Length);

/// Read the entire remainder of the underlying stream into \p Ref.  This is
/// equivalent to calling getUnderlyingStream().slice(Offset).  Updates the
/// stream's offset to point to the end of the stream.  Never causes a copy.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readStreamRef(BinaryStreamRef &Ref);

/// Read \p Length bytes from the underlying stream into \p Ref.  This is
/// equivalent to calling getUnderlyingStream().slice(Offset, Length).
/// Updates the stream's offset to point after the newly read object.  Never
/// causes a copy.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readStreamRef(BinaryStreamRef &Ref, uint32_t Length);

/// Read \p Length bytes from the underlying stream into \p Stream.  This is
/// equivalent to calling getUnderlyingStream().slice(Offset, Length).
/// Updates the stream's offset to point after the newly read object.  Never
/// causes a copy.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
Error readSubstream(BinarySubstreamRef &Stream, uint32_t Size);

/// Get a pointer to an object of type T from the underlying stream, as if by
/// memcpy, and store the result into \p Dest.  It is up to the caller to
/// ensure that objects of type T can be safely treated in this manner.
/// Updates the stream's offset to point after the newly read object.  Whether
/// a copy occurs depends upon the implementation of the underlying
/// stream.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T> Error readObject(const T *&Dest) {
  ArrayRef<uint8_t> Buffer;
  if (auto EC = readBytes(Buffer, sizeof(T)))
    return EC;
  Dest = reinterpret_cast<const T *>(Buffer.data());
  return Error::success();
}

/// Get a reference to a \p NumElements element array of objects of type T
/// from the underlying stream as if by memcpy, and store the resulting array
/// slice into \p array.  It is up to the caller to ensure that objects of
/// type T can be safely treated in this manner.  Updates the stream's offset
/// to point after the newly read object.  Whether a copy occurs depends upon
/// the implementation of the underlying stream.
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T>
Error readArray(ArrayRef<T> &Array, uint32_t NumElements) {
  ArrayRef<uint8_t> Bytes;
  if (NumElements == 0) {
    Array = ArrayRef<T>();
    return Error::success();
  }

  if (NumElements > UINT32_MAX(4294967295U) / sizeof(T))
    return make_error<BinaryStreamError>(
        stream_error_code::invalid_array_size);

  if (auto EC = readBytes(Bytes, NumElements * sizeof(T)))
    return EC;

  assert(alignmentAdjustment(Bytes.data(), alignof(T)) == 0 &&(static_cast <bool> (alignmentAdjustment(Bytes.data(), alignof
(T)) == 0 && "Reading at invalid alignment!") ? void (
0) : __assert_fail ("alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && \"Reading at invalid alignment!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/BinaryStreamReader.h"
, 191, __extension__ __PRETTY_FUNCTION__))
         "Reading at invalid alignment!")(static_cast <bool> (alignmentAdjustment(Bytes.data(), alignof
(T)) == 0 && "Reading at invalid alignment!") ? void (
0) : __assert_fail ("alignmentAdjustment(Bytes.data(), alignof(T)) == 0 && \"Reading at invalid alignment!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/BinaryStreamReader.h"
, 191, __extension__ __PRETTY_FUNCTION__));

  Array = ArrayRef<T>(reinterpret_cast<const T *>(Bytes.data()), NumElements);
  return Error::success();
}

/// Read a VarStreamArray of size \p Size bytes and store the result into
/// \p Array.  Updates the stream's offset to point after the newly read
/// array.  Never causes a copy (although iterating the elements of the
/// VarStreamArray may, depending upon the implementation of the underlying
/// stream).
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T, typename U>
Error readArray(VarStreamArray<T, U> &Array, uint32_t Size) {
  BinaryStreamRef S;
  if (auto EC = readStreamRef(S, Size))
    return EC;
  Array.setUnderlyingStream(S);
  return Error::success();
}

/// Read a FixedStreamArray of \p NumItems elements and store the result into
/// \p Array.  Updates the stream's offset to point after the newly read
/// array.  Never causes a copy (although iterating the elements of the
/// FixedStreamArray may, depending upon the implementation of the underlying
/// stream).
///
/// \returns a success error code if the data was successfully read, otherwise
/// returns an appropriate error code.
template <typename T>
Error readArray(FixedStreamArray<T> &Array, uint32_t NumItems) {
  if (NumItems == 0) {
    Array = FixedStreamArray<T>();
    return Error::success();
  }

  if (NumItems > UINT32_MAX(4294967295U) / sizeof(T))
    return make_error<BinaryStreamError>(
        stream_error_code::invalid_array_size);

  BinaryStreamRef View;
  if (auto EC = readStreamRef(View, NumItems * sizeof(T)))
    return EC;

  Array = FixedStreamArray<T>(View);
  return Error::success();
}

bool empty() const { return bytesRemaining() == 0; }
void setOffset(uint32_t Off) { Offset = Off; }
uint32_t getOffset() const { return Offset; }
uint32_t getLength() const { return Stream.getLength(); }
uint32_t bytesRemaining() const { return getLength() - getOffset(); }

/// Advance the stream's offset by \p Amount bytes.
///
/// \returns a success error code if at least \p Amount bytes remain in the
/// stream, otherwise returns an appropriate error code.
Error skip(uint32_t Amount);

/// Examine the next byte of the underlying stream without advancing the
/// stream's offset.  If the stream is empty the behavior is undefined.
///
/// \returns the next byte in the stream.
uint8_t peek() const;

Error padToAlignment(uint32_t Align);

std::pair<BinaryStreamReader, BinaryStreamReader>
split(uint32_t Offset) const;

264private:
BinaryStreamRef Stream;
uint32_t Offset = 0;
267};
268} // namespace llvm

270#endif // LLVM_SUPPORT_BINARYSTREAMREADER_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h

→

1//===- llvm/Support/Error.h - Recoverable error handling --------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines an API used to report recoverable errors.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_SUPPORT_ERROR_H
15#define LLVM_SUPPORT_ERROR_H
16 
17#include "llvm/ADT/SmallVector.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/ADT/Twine.h"
21#include "llvm/Config/abi-breaking.h"
22#include "llvm/Support/AlignOf.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Support/Debug.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/ErrorOr.h"
27#include "llvm/Support/raw_ostream.h"
28#include <algorithm>
29#include <cassert>
30#include <cstdint>
31#include <cstdlib>
32#include <functional>
33#include <memory>
34#include <new>
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 LLVM_NODISCARD[[clang::warn_unused_result]] Error {
157  // ErrorList needs to be able to yank ErrorInfoBase pointers out of this
158  // class to add to the error list.
159  friend class ErrorList;
160 
161  // handleErrors needs to be able to set the Checked flag.
162  template <typename... HandlerTs>
163  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
164 
165  // Expected<T> needs to be able to steal the payload when constructed from an
166  // error.
167  template <typename T> friend class Expected;
168 
169protected:
170  /// Create a success value. Prefer using 'Error::success()' for readability
171  Error() {
172    setPtr(nullptr);
173    setChecked(false);
174  }
175 
176public:
177  /// Create a success value.
178  static ErrorSuccess success();
179 
180  // Errors are not copy-constructable.
181  Error(const Error &Other) = delete;
182 
183  /// Move-construct an error value. The newly constructed error is considered
184  /// unchecked, even if the source error had been checked. The original error
185  /// becomes a checked Success value, regardless of its original state.
186  Error(Error &&Other) {
187    setChecked(true);
6
←
Calling 'Error::setChecked'→
8
←
Returning from 'Error::setChecked'→
72
←
Calling 'Error::setChecked'→
74
←
Returning from 'Error::setChecked'→
188    *this = std::move(Other);
9
←
Calling 'move'→
10
←
Returning from 'move'→
11
←
Calling move assignment operator for 'Error'→
28
←
Returning from move assignment operator for 'Error'→
75
←
Calling 'move'→
76
←
Returning from 'move'→
77
←
Calling move assignment operator for 'Error'→
94
←
Returning from move assignment operator for 'Error'→
189  }
190 
191  /// Create an error value. Prefer using the 'make_error' function, but
192  /// this constructor can be useful when "re-throwing" errors from handlers.
193  Error(std::unique_ptr<ErrorInfoBase> Payload) {
194    setPtr(Payload.release());
195    setChecked(false);
196  }
197 
198  // Errors are not copy-assignable.
199  Error &operator=(const Error &Other) = delete;
200 
201  /// Move-assign an error value. The current error must represent success, you
202  /// you cannot overwrite an unhandled error. The current error is then
203  /// considered unchecked. The source error becomes a checked success value,
204  /// regardless of its original state.
205  Error &operator=(Error &&Other) {
206    // Don't allow overwriting of unchecked values.
207    assertIsChecked();
12
←
Calling 'Error::assertIsChecked'→
15
←
Returning from 'Error::assertIsChecked'→
78
←
Calling 'Error::assertIsChecked'→
81
←
Returning from 'Error::assertIsChecked'→
208    setPtr(Other.getPtr());
16
←
Calling 'Error::getPtr'→
17
←
Returning from 'Error::getPtr'→
18
←
Calling 'Error::setPtr'→
19
←
Returning from 'Error::setPtr'→
82
←
Calling 'Error::getPtr'→
83
←
Returning from 'Error::getPtr'→
84
←
Calling 'Error::setPtr'→
85
←
Returning from 'Error::setPtr'→
209 
210    // This Error is unchecked, even if the source error was checked.
211    setChecked(false);
20
←
Calling 'Error::setChecked'→
22
←
Returning from 'Error::setChecked'→
86
←
Calling 'Error::setChecked'→
88
←
Returning from 'Error::setChecked'→
212 
213    // Null out Other's payload and set its checked bit.
214    Other.setPtr(nullptr);
23
←
Calling 'Error::setPtr'→
24
←
Returning from 'Error::setPtr'→
89
←
Calling 'Error::setPtr'→
90
←
Returning from 'Error::setPtr'→
215    Other.setChecked(true);
25
←
Calling 'Error::setChecked'→
27
←
Returning from 'Error::setChecked'→
91
←
Calling 'Error::setChecked'→
93
←
Returning from 'Error::setChecked'→
216 
217    return *this;
218  }
219 
220  /// Destroy a Error. Fails with a call to abort() if the error is
221  /// unchecked.
222  ~Error() {
223    assertIsChecked();
42
←
Calling 'Error::assertIsChecked'→
45
←
Returning from 'Error::assertIsChecked'→
108
←
Calling 'Error::assertIsChecked'→
111
←
Returning from 'Error::assertIsChecked'→
224    delete getPtr();
46
←
Calling 'Error::getPtr'→
47
←
Returning from 'Error::getPtr'→
112
←
Calling 'Error::getPtr'→
113
←
Returning from 'Error::getPtr'→
225  }
226 
227  /// Bool conversion. Returns true if this Error is in a failure state,
228  /// and false if it is in an accept state. If the error is in a Success state
229  /// it will be considered checked.
230  explicit operator bool() {
231    setChecked(getPtr() == nullptr);
31
←
Calling 'Error::getPtr'→
32
←
Returning from 'Error::getPtr'→
33
←
Calling 'Error::setChecked'→
36
←
Returning from 'Error::setChecked'→
97
←
Calling 'Error::getPtr'→
98
←
Returning from 'Error::getPtr'→
99
←
Calling 'Error::setChecked'→
102
←
Returning from 'Error::setChecked'→
232    return getPtr() != nullptr;
37
←
Calling 'Error::getPtr'→
38
←
Returning from 'Error::getPtr'→
103
←
Calling 'Error::getPtr'→
104
←
Returning from 'Error::getPtr'→
233  }
234 
235  /// Check whether one error is a subclass of another.
236  template <typename ErrT> bool isA() const {
237    return getPtr() && getPtr()->isA(ErrT::classID());
238  }
239 
240  /// Returns the dynamic class id of this error, or null if this is a success
241  /// value.
242  const void* dynamicClassID() const {
243    if (!getPtr())
244      return nullptr;
245    return getPtr()->dynamicClassID();
246  }
247 
248private:
249#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
250  // assertIsChecked() happens very frequently, but under normal circumstances
251  // is supposed to be a no-op.  So we want it to be inlined, but having a bunch
252  // of debug prints can cause the function to be too large for inlining.  So
253  // it's important that we define this function out of line so that it can't be
254  // inlined.
255  LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
256  void fatalUncheckedError() const;
257#endif
258 
259  void assertIsChecked() {
260#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
261    if (LLVM_UNLIKELY(!getChecked() || getPtr())__builtin_expect((bool)(!getChecked() || getPtr()), false))
13
←
Within the expansion of the macro 'LLVM_UNLIKELY':
→
a
Calling 'Error::getChecked'
b
Returning from 'Error::getChecked'
c
Calling 'Error::getPtr'
d
Returning from 'Error::getPtr'
14
←
Taking false branch→
43
←
Within the expansion of the macro 'LLVM_UNLIKELY':
→
a
Calling 'Error::getChecked'
b
Returning from 'Error::getChecked'
c
Calling 'Error::getPtr'
d
Returning from 'Error::getPtr'
44
←
Taking false branch→
79
←
Within the expansion of the macro 'LLVM_UNLIKELY':
→
a
Calling 'Error::getChecked'
b
Returning from 'Error::getChecked'
c
Calling 'Error::getPtr'
d
Returning from 'Error::getPtr'
80
←
Taking false branch→
109
←
Within the expansion of the macro 'LLVM_UNLIKELY':
→
a
Calling 'Error::getChecked'
b
Returning from 'Error::getChecked'
110
←
Taking false branch→
262      fatalUncheckedError();
263#endif
264  }
265 
266  ErrorInfoBase *getPtr() const {
267    return reinterpret_cast<ErrorInfoBase*>(
268             reinterpret_cast<uintptr_t>(Payload) &
269             ~static_cast<uintptr_t>(0x1));
270  }
271 
272  void setPtr(ErrorInfoBase *EI) {
273#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
274    Payload = reinterpret_cast<ErrorInfoBase*>(
275                (reinterpret_cast<uintptr_t>(EI) &
276                 ~static_cast<uintptr_t>(0x1)) |
277                (reinterpret_cast<uintptr_t>(Payload) & 0x1));
278#else
279    Payload = EI;
280#endif
281  }
282 
283  bool getChecked() const {
284#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
285    return (reinterpret_cast<uintptr_t>(Payload) & 0x1) == 0;
286#else
287    return true;
288#endif
289  }
290 
291  void setChecked(bool V) {
292    Payload = reinterpret_cast<ErrorInfoBase*>(
293                (reinterpret_cast<uintptr_t>(Payload) &
294                  ~static_cast<uintptr_t>(0x1)) |
295                  (V ? 0 : 1));
7
←
'?' condition is true→
21
←
'?' condition is false→
26
←
'?' condition is true→
34
←
Assuming 'V' is 0→
35
←
'?' condition is false→
73
←
'?' condition is true→
87
←
'?' condition is false→
92
←
'?' condition is true→
100
←
Assuming 'V' is 0→
101
←
'?' condition is false→
296  }
297 
298  std::unique_ptr<ErrorInfoBase> takePayload() {
299    std::unique_ptr<ErrorInfoBase> Tmp(getPtr());
300    setPtr(nullptr);
301    setChecked(true);
302    return Tmp;
303  }
304 
305  ErrorInfoBase *Payload = nullptr;
306};
307 
308/// Subclass of Error for the sole purpose of identifying the success path in
309/// the type system. This allows to catch invalid conversion to Expected<T> at
310/// compile time.
311class ErrorSuccess : public Error {};
312 
313inline ErrorSuccess Error::success() { return ErrorSuccess(); }
314 
315/// Make a Error instance representing failure using the given error info
316/// type.
317template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
318  return Error(llvm::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
319}
320 
321/// Base class for user error types. Users should declare their error types
322/// like:
323///
324/// class MyError : public ErrorInfo<MyError> {
325///   ....
326/// };
327///
328/// This class provides an implementation of the ErrorInfoBase::kind
329/// method, which is used by the Error RTTI system.
330template <typename ThisErrT, typename ParentErrT = ErrorInfoBase>
331class ErrorInfo : public ParentErrT {
332public:
333  static const void *classID() { return &ThisErrT::ID; }
334 
335  const void *dynamicClassID() const override { return &ThisErrT::ID; }
336 
337  bool isA(const void *const ClassID) const override {
338    return ClassID == classID() || ParentErrT::isA(ClassID);
339  }
340};
341 
342/// Special ErrorInfo subclass representing a list of ErrorInfos.
343/// Instances of this class are constructed by joinError.
344class ErrorList final : public ErrorInfo<ErrorList> {
345  // handleErrors needs to be able to iterate the payload list of an
346  // ErrorList.
347  template <typename... HandlerTs>
348  friend Error handleErrors(Error E, HandlerTs &&... Handlers);
349 
350  // joinErrors is implemented in terms of join.
351  friend Error joinErrors(Error, Error);
352 
353public:
354  void log(raw_ostream &OS) const override {
355    OS << "Multiple errors:\n";
356    for (auto &ErrPayload : Payloads) {
357      ErrPayload->log(OS);
358      OS << "\n";
359    }
360  }
361 
362  std::error_code convertToErrorCode() const override;
363 
364  // Used by ErrorInfo::classID.
365  static char ID;
366 
367private:
368  ErrorList(std::unique_ptr<ErrorInfoBase> Payload1,
369            std::unique_ptr<ErrorInfoBase> Payload2) {
370    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\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 371, __extension__ __PRETTY_FUNCTION__))
371           "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\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 371, __extension__ __PRETTY_FUNCTION__));
372    Payloads.push_back(std::move(Payload1));
373    Payloads.push_back(std::move(Payload2));
374  }
375 
376  static Error join(Error E1, Error E2) {
377    if (!E1)
378      return E2;
379    if (!E2)
380      return E1;
381    if (E1.isA<ErrorList>()) {
382      auto &E1List = static_cast<ErrorList &>(*E1.getPtr());
383      if (E2.isA<ErrorList>()) {
384        auto E2Payload = E2.takePayload();
385        auto &E2List = static_cast<ErrorList &>(*E2Payload);
386        for (auto &Payload : E2List.Payloads)
387          E1List.Payloads.push_back(std::move(Payload));
388      } else
389        E1List.Payloads.push_back(E2.takePayload());
390 
391      return E1;
392    }
393    if (E2.isA<ErrorList>()) {
394      auto &E2List = static_cast<ErrorList &>(*E2.getPtr());
395      E2List.Payloads.insert(E2List.Payloads.begin(), E1.takePayload());
396      return E2;
397    }
398    return Error(std::unique_ptr<ErrorList>(
399        new ErrorList(E1.takePayload(), E2.takePayload())));
400  }
401 
402  std::vector<std::unique_ptr<ErrorInfoBase>> Payloads;
403};
404 
405/// Concatenate errors. The resulting Error is unchecked, and contains the
406/// ErrorInfo(s), if any, contained in E1, followed by the
407/// ErrorInfo(s), if any, contained in E2.
408inline Error joinErrors(Error E1, Error E2) {
409  return ErrorList::join(std::move(E1), std::move(E2));
410}
411 
412/// Tagged union holding either a T or a Error.
413///
414/// This class parallels ErrorOr, but replaces error_code with Error. Since
415/// Error cannot be copied, this class replaces getError() with
416/// takeError(). It also adds an bool errorIsA<ErrT>() method for testing the
417/// error class type.
418template <class T> class LLVM_NODISCARD[[clang::warn_unused_result]] Expected {
419  template <class T1> friend class ExpectedAsOutParameter;
420  template <class OtherT> friend class Expected;
421 
422  static const bool isRef = std::is_reference<T>::value;
423 
424  using wrap = ReferenceStorage<typename std::remove_reference<T>::type>;
425 
426  using error_type = std::unique_ptr<ErrorInfoBase>;
427 
428public:
429  using storage_type = typename std::conditional<isRef, wrap, T>::type;
430  using value_type = T;
431 
432private:
433  using reference = typename std::remove_reference<T>::type &;
434  using const_reference = const typename std::remove_reference<T>::type &;
435  using pointer = typename std::remove_reference<T>::type *;
436  using const_pointer = const typename std::remove_reference<T>::type *;
437 
438public:
439  /// Create an Expected<T> error value from the given Error.
440  Expected(Error Err)
441      : HasError(true)
442#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
443        // Expected is unchecked upon construction in Debug builds.
444        , Unchecked(true)
445#endif
446  {
447    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.\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 447, __extension__ __PRETTY_FUNCTION__));
448    new (getErrorStorage()) error_type(Err.takePayload());
449  }
450 
451  /// Forbid to convert from Error::success() implicitly, this avoids having
452  /// Expected<T> foo() { return Error::success(); } which compiles otherwise
453  /// but triggers the assertion above.
454  Expected(ErrorSuccess) = delete;
455 
456  /// Create an Expected<T> success value from the given OtherT value, which
457  /// must be convertible to T.
458  template <typename OtherT>
459  Expected(OtherT &&Val,
460           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
461               * = nullptr)
462      : HasError(false)
463#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
464        // Expected is unchecked upon construction in Debug builds.
465        , Unchecked(true)
466#endif
467  {
468    new (getStorage()) storage_type(std::forward<OtherT>(Val));
469  }
470 
471  /// Move construct an Expected<T> value.
472  Expected(Expected &&Other) { moveConstruct(std::move(Other)); }
473 
474  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
475  /// must be convertible to T.
476  template <class OtherT>
477  Expected(Expected<OtherT> &&Other,
478           typename std::enable_if<std::is_convertible<OtherT, T>::value>::type
479               * = nullptr) {
480    moveConstruct(std::move(Other));
481  }
482 
483  /// Move construct an Expected<T> value from an Expected<OtherT>, where OtherT
484  /// isn't convertible to T.
485  template <class OtherT>
486  explicit Expected(
487      Expected<OtherT> &&Other,
488      typename std::enable_if<!std::is_convertible<OtherT, T>::value>::type * =
489          nullptr) {
490    moveConstruct(std::move(Other));
491  }
492 
493  /// Move-assign from another Expected<T>.
494  Expected &operator=(Expected &&Other) {
495    moveAssign(std::move(Other));
496    return *this;
497  }
498 
499  /// Destroy an Expected<T>.
500  ~Expected() {
501    assertIsChecked();
502    if (!HasError)
503      getStorage()->~storage_type();
504    else
505      getErrorStorage()->~error_type();
506  }
507 
508  /// \brief Return false if there is an error.
509  explicit operator bool() {
510#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
511    Unchecked = HasError;
512#endif
513    return !HasError;
514  }
515 
516  /// \brief Returns a reference to the stored T value.
517  reference get() {
518    assertIsChecked();
519    return *getStorage();
520  }
521 
522  /// \brief Returns a const reference to the stored T value.
523  const_reference get() const {
524    assertIsChecked();
525    return const_cast<Expected<T> *>(this)->get();
526  }
527 
528  /// \brief Check that this Expected<T> is an error of type ErrT.
529  template <typename ErrT> bool errorIsA() const {
530    return HasError && (*getErrorStorage())->template isA<ErrT>();
531  }
532 
533  /// \brief Take ownership of the stored error.
534  /// After calling this the Expected<T> is in an indeterminate state that can
535  /// only be safely destructed. No further calls (beside the destructor) should
536  /// be made on the Expected<T> vaule.
537  Error takeError() {
538#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
539    Unchecked = false;
540#endif
541    return HasError ? Error(std::move(*getErrorStorage())) : Error::success();
542  }
543 
544  /// \brief Returns a pointer to the stored T value.
545  pointer operator->() {
546    assertIsChecked();
547    return toPointer(getStorage());
548  }
549 
550  /// \brief Returns a const pointer to the stored T value.
551  const_pointer operator->() const {
552    assertIsChecked();
553    return toPointer(getStorage());
554  }
555 
556  /// \brief Returns a reference to the stored T value.
557  reference operator*() {
558    assertIsChecked();
559    return *getStorage();
560  }
561 
562  /// \brief Returns a const reference to the stored T value.
563  const_reference operator*() const {
564    assertIsChecked();
565    return *getStorage();
566  }
567 
568private:
569  template <class T1>
570  static bool compareThisIfSameType(const T1 &a, const T1 &b) {
571    return &a == &b;
572  }
573 
574  template <class T1, class T2>
575  static bool compareThisIfSameType(const T1 &a, const T2 &b) {
576    return false;
577  }
578 
579  template <class OtherT> void moveConstruct(Expected<OtherT> &&Other) {
580    HasError = Other.HasError;
581#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
582    Unchecked = true;
583    Other.Unchecked = false;
584#endif
585 
586    if (!HasError)
587      new (getStorage()) storage_type(std::move(*Other.getStorage()));
588    else
589      new (getErrorStorage()) error_type(std::move(*Other.getErrorStorage()));
590  }
591 
592  template <class OtherT> void moveAssign(Expected<OtherT> &&Other) {
593    assertIsChecked();
594 
595    if (compareThisIfSameType(*this, Other))
596      return;
597 
598    this->~Expected();
599    new (this) Expected(std::move(Other));
600  }
601 
602  pointer toPointer(pointer Val) { return Val; }
603 
604  const_pointer toPointer(const_pointer Val) const { return Val; }
605 
606  pointer toPointer(wrap *Val) { return &Val->get(); }
607 
608  const_pointer toPointer(const wrap *Val) const { return &Val->get(); }
609 
610  storage_type *getStorage() {
611    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!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 611, __extension__ __PRETTY_FUNCTION__));
612    return reinterpret_cast<storage_type *>(TStorage.buffer);
613  }
614 
615  const storage_type *getStorage() const {
616    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!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 616, __extension__ __PRETTY_FUNCTION__));
617    return reinterpret_cast<const storage_type *>(TStorage.buffer);
618  }
619 
620  error_type *getErrorStorage() {
621    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!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 621, __extension__ __PRETTY_FUNCTION__));
622    return reinterpret_cast<error_type *>(ErrorStorage.buffer);
623  }
624 
625  const error_type *getErrorStorage() const {
626    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!\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 626, __extension__ __PRETTY_FUNCTION__));
627    return reinterpret_cast<const error_type *>(ErrorStorage.buffer);
628  }
629 
630  // Used by ExpectedAsOutParameter to reset the checked flag.
631  void setUnchecked() {
632#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
633    Unchecked = true;
634#endif
635  }
636 
637#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
638  LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn))
639  LLVM_ATTRIBUTE_NOINLINE__attribute__((noinline))
640  void fatalUncheckedExpected() const {
641    dbgs() << "Expected<T> must be checked before access or destruction.\n";
642    if (HasError) {
643      dbgs() << "Unchecked Expected<T> contained error:\n";
644      (*getErrorStorage())->log(dbgs());
645    } else
646      dbgs() << "Expected<T> value was in success state. (Note: Expected<T> "
647                "values in success mode must still be checked prior to being "
648                "destroyed).\n";
649    abort();
650  }
651#endif
652 
653  void assertIsChecked() {
654#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
655    if (LLVM_UNLIKELY(Unchecked)__builtin_expect((bool)(Unchecked), false))
656      fatalUncheckedExpected();
657#endif
658  }
659 
660  union {
661    AlignedCharArrayUnion<storage_type> TStorage;
662    AlignedCharArrayUnion<error_type> ErrorStorage;
663  };
664  bool HasError : 1;
665#if LLVM_ENABLE_ABI_BREAKING_CHECKS1
666  bool Unchecked : 1;
667#endif
668};
669 
670/// Report a serious error, calling any installed error handler. See
671/// ErrorHandling.h.
672LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void report_fatal_error(Error Err,
673                                                bool gen_crash_diag = true);
674 
675/// Report a fatal error if Err is a failure value.
676///
677/// This function can be used to wrap calls to fallible functions ONLY when it
678/// is known that the Error will always be a success value. E.g.
679///
680///   @code{.cpp}
681///   // foo only attempts the fallible operation if DoFallibleOperation is
682///   // true. If DoFallibleOperation is false then foo always returns
683///   // Error::success().
684///   Error foo(bool DoFallibleOperation);
685///
686///   cantFail(foo(false));
687///   @endcode
688inline void cantFail(Error Err, const char *Msg = nullptr) {
689  if (Err) {
690    if (!Msg)
691      Msg = "Failure value returned from cantFail wrapped call";
692    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 692);
693  }
694}
695 
696/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
697/// returns the contained value.
698///
699/// This function can be used to wrap calls to fallible functions ONLY when it
700/// is known that the Error will always be a success value. E.g.
701///
702///   @code{.cpp}
703///   // foo only attempts the fallible operation if DoFallibleOperation is
704///   // true. If DoFallibleOperation is false then foo always returns an int.
705///   Expected<int> foo(bool DoFallibleOperation);
706///
707///   int X = cantFail(foo(false));
708///   @endcode
709template <typename T>
710T cantFail(Expected<T> ValOrErr, const char *Msg = nullptr) {
711  if (ValOrErr)
712    return std::move(*ValOrErr);
713  else {
714    if (!Msg)
715      Msg = "Failure value returned from cantFail wrapped call";
716    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 716);
717  }
718}
719 
720/// Report a fatal error if ValOrErr is a failure value, otherwise unwraps and
721/// returns the contained reference.
722///
723/// This function can be used to wrap calls to fallible functions ONLY when it
724/// is known that the Error will always be a success value. E.g.
725///
726///   @code{.cpp}
727///   // foo only attempts the fallible operation if DoFallibleOperation is
728///   // true. If DoFallibleOperation is false then foo always returns a Bar&.
729///   Expected<Bar&> foo(bool DoFallibleOperation);
730///
731///   Bar &X = cantFail(foo(false));
732///   @endcode
733template <typename T>
734T& cantFail(Expected<T&> ValOrErr, const char *Msg = nullptr) {
735  if (ValOrErr)
736    return *ValOrErr;
737  else {
738    if (!Msg)
739      Msg = "Failure value returned from cantFail wrapped call";
740    llvm_unreachable(Msg)::llvm::llvm_unreachable_internal(Msg, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 740);
741  }
742}
743 
744/// Helper for testing applicability of, and applying, handlers for
745/// ErrorInfo types.
746template <typename HandlerT>
747class ErrorHandlerTraits
748    : public ErrorHandlerTraits<decltype(
749          &std::remove_reference<HandlerT>::type::operator())> {};
750 
751// Specialization functions of the form 'Error (const ErrT&)'.
752template <typename ErrT> class ErrorHandlerTraits<Error (&)(ErrT &)> {
753public:
754  static bool appliesTo(const ErrorInfoBase &E) {
755    return E.template isA<ErrT>();
756  }
757 
758  template <typename HandlerT>
759  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
760    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 760, __extension__ __PRETTY_FUNCTION__));
761    return H(static_cast<ErrT &>(*E));
762  }
763};
764 
765// Specialization functions of the form 'void (const ErrT&)'.
766template <typename ErrT> class ErrorHandlerTraits<void (&)(ErrT &)> {
767public:
768  static bool appliesTo(const ErrorInfoBase &E) {
769    return E.template isA<ErrT>();
770  }
771 
772  template <typename HandlerT>
773  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
774    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 774, __extension__ __PRETTY_FUNCTION__));
775    H(static_cast<ErrT &>(*E));
776    return Error::success();
777  }
778};
779 
780/// Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)'.
781template <typename ErrT>
782class ErrorHandlerTraits<Error (&)(std::unique_ptr<ErrT>)> {
783public:
784  static bool appliesTo(const ErrorInfoBase &E) {
785    return E.template isA<ErrT>();
786  }
787 
788  template <typename HandlerT>
789  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
790    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 790, __extension__ __PRETTY_FUNCTION__));
791    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
792    return H(std::move(SubE));
793  }
794};
795 
796/// Specialization for functions of the form 'void (std::unique_ptr<ErrT>)'.
797template <typename ErrT>
798class ErrorHandlerTraits<void (&)(std::unique_ptr<ErrT>)> {
799public:
800  static bool appliesTo(const ErrorInfoBase &E) {
801    return E.template isA<ErrT>();
802  }
803 
804  template <typename HandlerT>
805  static Error apply(HandlerT &&H, std::unique_ptr<ErrorInfoBase> E) {
806    assert(appliesTo(*E) && "Applying incorrect handler")(static_cast <bool> (appliesTo(*E) && "Applying incorrect handler"
) ? void (0) : __assert_fail ("appliesTo(*E) && \"Applying incorrect handler\""
, "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Error.h"
, 806, __extension__ __PRETTY_FUNCTION__));
807    std::unique_ptr<ErrT> SubE(static_cast<ErrT *>(E.release()));
808    H(std::move(SubE));
809    return Error::success();
810  }
811};
812 
813// Specialization for member functions of the form 'RetT (const ErrT&)'.
814template <typename C, typename RetT, typename ErrT>
815class ErrorHandlerTraits<RetT (C::*)(ErrT &)>
816    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
817 
818// Specialization for member functions of the form 'RetT (const ErrT&) const'.
819template <typename C, typename RetT, typename ErrT>
820class ErrorHandlerTraits<RetT (C::*)(ErrT &) const>
821    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
822 
823// Specialization for member functions of the form 'RetT (const ErrT&)'.
824template <typename C, typename RetT, typename ErrT>
825class ErrorHandlerTraits<RetT (C::*)(const ErrT &)>
826    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
827 
828// Specialization for member functions of the form 'RetT (const ErrT&) const'.
829template <typename C, typename RetT, typename ErrT>
830class ErrorHandlerTraits<RetT (C::*)(const ErrT &) const>
831    : public ErrorHandlerTraits<RetT (&)(ErrT &)> {};
832 
833/// Specialization for member functions of the form
834/// 'RetT (std::unique_ptr<ErrT>)'.
835template <typename C, typename RetT, typename ErrT>
836class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>)>
837    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
838 
839/// Specialization for member functions of the form
840/// 'RetT (std::unique_ptr<ErrT>) const'.
841template <typename C, typename RetT, typename ErrT>
842class ErrorHandlerTraits<RetT (C::*)(std::unique_ptr<ErrT>) const>
843    : public ErrorHandlerTraits<RetT (&)(std::unique_ptr<ErrT>)> {};
844 
845inline Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload) {
846  return Error(std::move(Payload));
847}
848 
849template <typename HandlerT, typename... HandlerTs>
850Error handleErrorImpl(std::unique_ptr<ErrorInfoBase> Payload,
851                      HandlerT &&Handler, HandlerTs &&... Handlers) {
852  if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
853    return ErrorHandlerTraits<HandlerT>::apply(std::forward<HandlerT>(Handler),
854                                               std::move(Payload));
855  return handleErrorImpl(std::move(Payload),
856                         std::forward<HandlerTs>(Handlers)...);
857}
858 
859/// Pass the ErrorInfo(s) contained in E to their respective handlers. Any
860/// unhandled errors (or Errors returned by handlers) are re-concatenated and
861/// returned.
862/// Because this function returns an error, its result must also be checked
863/// or returned. If you intend to handle all errors use handleAllErrors
864/// (which returns void, and will abort() on unhandled errors) instead.
865template <typename... HandlerTs>
866Error handleErrors(Error E, HandlerTs &&... Hs) {
867  if (!E)
868    return Error::success();
869 
870  std::unique_ptr<ErrorInfoBase> Payload = E.takePayload();
871 
872  if (Payload->isA<ErrorList>()) {
873    ErrorList &List = static_cast<ErrorList &>(*Payload);
874    Error R;
875    for (auto &P : List.Payloads)
876      R = ErrorList::join(
877          std::move(R),
878          handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
879    return R;
880  }
881 
882  return handleErrorImpl(std::move(Payload), std::forward<HandlerTs>(Hs)...);
883}
884 
885/// Behaves the same as handleErrors, except that it requires that all
886/// errors be handled by the given handlers. If any unhandled error remains
887/// after the handlers have run, report_fatal_error() will be called.
888template <typename... HandlerTs>
889void handleAllErrors(Error E, HandlerTs &&... Handlers) {
890  cantFail(handleErrors(std::move(E), std::forward<HandlerTs>(Handlers)...));
891}
892 
893/// Check that E is a non-error, then drop it.
894/// If E is an error report_fatal_error will be called.
895inline void handleAllErrors(Error E) {
896  cantFail(std::move(E));
897}
898 
899/// Handle any errors (if present) in an Expected<T>, then try a recovery path.
900///
901/// If the incoming value is a success value it is returned unmodified. If it
902/// is a failure value then it the contained error is passed to handleErrors.
903/// If handleErrors is able to handle the error then the RecoveryPath functor
904/// is called to supply the final result. If handleErrors is not able to
905/// handle all errors then the unhandled errors are returned.
906///
907/// This utility enables the follow pattern:
908///
909///   @code{.cpp}
910///   enum FooStrategy { Aggressive, Conservative };
911///   Expected<Foo> foo(FooStrategy S);
912///
913///   auto ResultOrErr =
914///     handleExpected(
915///       foo(Aggressive),
916///       []() { return foo(Conservative); },
917///       [](AggressiveStrategyError&) {
918///         // Implicitly conusme this - we'll recover by using a conservative
919///         // strategy.
920///       });
921///
922///   @endcode
923template <typename T, typename RecoveryFtor, typename... HandlerTs>
924Expected<T> handleExpected(Expected<T> ValOrErr, RecoveryFtor &&RecoveryPath,
925                           HandlerTs &&... Handlers) {
926  if (ValOrErr)
927    return ValOrErr;
928 
929  if (auto Err = handleErrors(ValOrErr.takeError(),
930                              std::forward<HandlerTs>(Handlers)...))
931    return std::move(Err);
932 
933  return RecoveryPath();
934}
935 
936/// Log all errors (if any) in E to OS. If there are any errors, ErrorBanner
937/// will be printed before the first one is logged. A newline will be printed
938/// after each error.
939///
940/// This is useful in the base level of your program to allow clean termination
941/// (allowing clean deallocation of resources, etc.), while reporting error
942/// information to the user.
943void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner);
944 
945/// Write all error messages (if any) in E to a string. The newline character
946/// is used to separate error messages.
947inline std::string toString(Error E) {
948  SmallVector<std::string, 2> Errors;
949  handleAllErrors(std::move(E), [&Errors](const ErrorInfoBase &EI) {
950    Errors.push_back(EI.message());
951  });
952  return join(Errors.begin(), Errors.end(), "\n");
953}
954 
955/// Consume a Error without doing anything. This method should be used
956/// only where an error can be considered a reasonable and expected return
957/// value.
958///
959/// Uses of this method are potentially indicative of design problems: If it's
960/// legitimate to do nothing while processing an "error", the error-producer
961/// might be more clearly refactored to return an Optional<T>.
962inline void consumeError(Error Err) {
963  handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {});
964}
965 
966/// Helper for converting an Error to a bool.
967///
968/// This method returns true if Err is in an error state, or false if it is
969/// in a success state.  Puts Err in a checked state in both cases (unlike
970/// Error::operator bool(), which only does this for success states).
971inline bool errorToBool(Error Err) {
972  bool IsError = static_cast<bool>(Err);
973  if (IsError)
974    consumeError(std::move(Err));
975  return IsError;
976}
977 
978/// Helper for Errors used as out-parameters.
979///
980/// This helper is for use with the Error-as-out-parameter idiom, where an error
981/// is passed to a function or method by reference, rather than being returned.
982/// In such cases it is helpful to set the checked bit on entry to the function
983/// so that the error can be written to (unchecked Errors abort on assignment)
984/// and clear the checked bit on exit so that clients cannot accidentally forget
985/// to check the result. This helper performs these actions automatically using
986/// RAII:
987///
988///   @code{.cpp}
989///   Result foo(Error &Err) {
990///     ErrorAsOutParameter ErrAsOutParam(&Err); // 'Checked' flag set
991///     // <body of foo>
992///     // <- 'Checked' flag auto-cleared when ErrAsOutParam is destructed.
993///   }
994///   @endcode
995///
996/// ErrorAsOutParameter takes an Error* rather than Error& so that it can be
997/// used with optional Errors (Error pointers that are allowed to be null). If
998/// ErrorAsOutParameter took an Error reference, an instance would have to be
999/// created inside every condition that verified that Error was non-null. By
1000/// taking an Error pointer we can just create one instance at the top of the
1001/// function.
1002class ErrorAsOutParameter {
1003public:
1004  ErrorAsOutParameter(Error *Err) : Err(Err) {
1005    // Raise the checked bit if Err is success.
1006    if (Err)
1007      (void)!!*Err;
1008  }
1009 
1010  ~ErrorAsOutParameter() {
1011    // Clear the checked bit.
1012    if (Err && !*Err)
1013      *Err = Error::success();
1014  }
1015 
1016private:
1017  Error *Err;
1018};
1019 
1020/// Helper for Expected<T>s used as out-parameters.
1021///
1022/// See ErrorAsOutParameter.
1023template <typename T>
1024class ExpectedAsOutParameter {
1025public:
1026  ExpectedAsOutParameter(Expected<T> *ValOrErr)
1027    : ValOrErr(ValOrErr) {
1028    if (ValOrErr)
1029      (void)!!*ValOrErr;
1030  }
1031 
1032  ~ExpectedAsOutParameter() {
1033    if (ValOrErr)
1034      ValOrErr->setUnchecked();
1035  }
1036 
1037private:
1038  Expected<T> *ValOrErr;
1039};
1040 
1041/// This class wraps a std::error_code in a Error.
1042///
1043/// This is useful if you're writing an interface that returns a Error
1044/// (or Expected) and you want to call code that still returns
1045/// std::error_codes.
1046class ECError : public ErrorInfo<ECError> {
1047  friend Error errorCodeToError(std::error_code);
1048 
1049public:
1050  void setErrorCode(std::error_code EC) { this->EC = EC; }
1051  std::error_code convertToErrorCode() const override { return EC; }
1052  void log(raw_ostream &OS) const override { OS << EC.message(); }
1053 
1054  // Used by ErrorInfo::classID.
1055  static char ID;
1056 
1057protected:
1058  ECError() = default;
1059  ECError(std::error_code EC) : EC(EC) {}
1060 
1061  std::error_code EC;
1062};
1063 
1064/// The value returned by this function can be returned from convertToErrorCode
1065/// for Error values where no sensible translation to std::error_code exists.
1066/// It should only be used in this situation, and should never be used where a
1067/// sensible conversion to std::error_code is available, as attempts to convert
1068/// to/from this error will result in a fatal error. (i.e. it is a programmatic
1069///error to try to convert such a value).
1070std::error_code inconvertibleErrorCode();
1071 
1072/// Helper for converting an std::error_code to a Error.
1073Error errorCodeToError(std::error_code EC);
1074 
1075/// Helper for converting an ECError to a std::error_code.
1076///
1077/// This method requires that Err be Error() or an ECError, otherwise it
1078/// will trigger a call to abort().
1079std::error_code errorToErrorCode(Error Err);
1080 
1081/// Convert an ErrorOr<T> to an Expected<T>.
1082template <typename T> Expected<T> errorOrToExpected(ErrorOr<T> &&EO) {
1083  if (auto EC = EO.getError())
1084    return errorCodeToError(EC);
1085  return std::move(*EO);
1086}
1087 
1088/// Convert an Expected<T> to an ErrorOr<T>.
1089template <typename T> ErrorOr<T> expectedToErrorOr(Expected<T> &&E) {
1090  if (auto Err = E.takeError())
1091    return errorToErrorCode(std::move(Err));
1092  return std::move(*E);
1093}
1094 
1095/// This class wraps a string in an Error.
1096///
1097/// StringError is useful in cases where the client is not expected to be able
1098/// to consume the specific error message programmatically (for example, if the
1099/// error message is to be presented to the user).
1100class StringError : public ErrorInfo<StringError> {
1101public:
1102  static char ID;
1103 
1104  StringError(const Twine &S, std::error_code EC);
1105 
1106  void log(raw_ostream &OS) const override;
1107  std::error_code convertToErrorCode() const override;
1108 
1109  const std::string &getMessage() const { return Msg; }
1110 
1111private:
1112  std::string Msg;
1113  std::error_code EC;
1114};
1115 
1116/// Helper for check-and-exit error handling.
1117///
1118/// For tool use only. NOT FOR USE IN LIBRARY CODE.
1119///
1120class ExitOnError {
1121public:
1122  /// Create an error on exit helper.
1123  ExitOnError(std::string Banner = "", int DefaultErrorExitCode = 1)
1124      : Banner(std::move(Banner)),
1125        GetExitCode([=](const Error &) { return DefaultErrorExitCode; }) {}
1126 
1127  /// Set the banner string for any errors caught by operator().
1128  void setBanner(std::string Banner) { this->Banner = std::move(Banner); }
1129 
1130  /// Set the exit-code mapper function.
1131  void setExitCodeMapper(std::function<int(const Error &)> GetExitCode) {
1132    this->GetExitCode = std::move(GetExitCode);
1133  }
1134 
1135  /// Check Err. If it's in a failure state log the error(s) and exit.
1136  void operator()(Error Err) const { checkError(std::move(Err)); }
1137 
1138  /// Check E. If it's in a success state then return the contained value. If
1139  /// it's in a failure state log the error(s) and exit.
1140  template <typename T> T operator()(Expected<T> &&E) const {
1141    checkError(E.takeError());
1142    return std::move(*E);
1143  }
1144 
1145  /// Check E. If it's in a success state then return the contained reference. If
1146  /// it's in a failure state log the error(s) and exit.
1147  template <typename T> T& operator()(Expected<T&> &&E) const {
1148    checkError(E.takeError());
1149    return *E;
1150  }
1151 
1152private:
1153  void checkError(Error Err) const {
1154    if (Err) {
1155      int ExitCode = GetExitCode(Err);
1156      logAllUnhandledErrors(std::move(Err), errs(), Banner);
1157      exit(ExitCode);
1158    }
1159  }
1160 
1161  std::string Banner;
1162  std::function<int(const Error &)> GetExitCode;
1163};
1164 
1165} // end namespace llvm
1166 
1167#endif // LLVM_SUPPORT_ERROR_H

←

/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Endian.h

1//===- Endian.h - Utilities for IO with endian specific data ----*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file declares generic functions to read and write endian specific data.
11//
12//===----------------------------------------------------------------------===//
13 
14#ifndef LLVM_SUPPORT_ENDIAN_H
15#define LLVM_SUPPORT_ENDIAN_H
16 
17#include "llvm/Support/AlignOf.h"
18#include "llvm/Support/Compiler.h"
19#include "llvm/Support/Host.h"
20#include "llvm/Support/SwapByteOrder.h"
21#include <cassert>
22#include <cstddef>
23#include <cstdint>
24#include <cstring>
25#include <type_traits>
26 
27namespace llvm {
28namespace support {
29 
30enum endianness {big, little, native};
31 
32// These are named values for common alignments.
33enum {aligned = 0, unaligned = 1};
34 
35namespace detail {
36 
37/// \brief ::value is either alignment, or alignof(T) if alignment is 0.
38template<class T, int alignment>
39struct PickAlignment {
40 enum { value = alignment == 0 ? alignof(T) : alignment };
41};
42 
43} // end namespace detail
44 
45namespace endian {
46 
47constexpr endianness system_endianness() {
48  return sys::IsBigEndianHost ? big : little;
49}
50 
51template <typename value_type>
52inline value_type byte_swap(value_type value, endianness endian) {
53  if ((endian != native) && (endian != system_endianness()))
53
←
Assuming 'endian' is equal to native→
54    sys::swapByteOrder(value);
55  return value;
56}
57 
58/// Swap the bytes of value to match the given endianness.
59template<typename value_type, endianness endian>
60inline value_type byte_swap(value_type value) {
61  return byte_swap(value, endian);
62}
63 
64/// Read a value of a particular endianness from memory.
65template <typename value_type, std::size_t alignment>
66inline value_type read(const void *memory, endianness endian) {
67  value_type ret;
68 
69  memcpy(&ret,
70         LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
71             memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
72         sizeof(value_type));
73  return byte_swap<value_type>(ret, endian);
52
←
Calling 'byte_swap'→
54
←
Returning from 'byte_swap'→
74}
75 
76template<typename value_type,
77         endianness endian,
78         std::size_t alignment>
79inline value_type read(const void *memory) {
80  return read<value_type, alignment>(memory, endian);
81}
82 
83/// Read a value of a particular endianness from a buffer, and increment the
84/// buffer past that value.
85template <typename value_type, std::size_t alignment, typename CharT>
86inline value_type readNext(const CharT *&memory, endianness endian) {
87  value_type ret = read<value_type, alignment>(memory, endian);
88  memory += sizeof(value_type);
89  return ret;
90}
91 
92template<typename value_type, endianness endian, std::size_t alignment,
93         typename CharT>
94inline value_type readNext(const CharT *&memory) {
95  return readNext<value_type, alignment, CharT>(memory, endian);
96}
97 
98/// Write a value to memory with a particular endianness.
99template <typename value_type, std::size_t alignment>
100inline void write(void *memory, value_type value, endianness endian) {
101  value = byte_swap<value_type>(value, endian);
102  memcpy(LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
103             memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
104         &value, sizeof(value_type));
105}
106 
107template<typename value_type,
108         endianness endian,
109         std::size_t alignment>
110inline void write(void *memory, value_type value) {
111  write<value_type, alignment>(memory, value, endian);
112}
113 
114template <typename value_type>
115using make_unsigned_t = typename std::make_unsigned<value_type>::type;
116 
117/// Read a value of a particular endianness from memory, for a location
118/// that starts at the given bit offset within the first byte.
119template <typename value_type, endianness endian, std::size_t alignment>
120inline value_type readAtBitAlignment(const void *memory, uint64_t startBit) {
121  assert(startBit < 8)(static_cast <bool> (startBit < 8) ? void (0) : __assert_fail
 ("startBit < 8", "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Endian.h"
, 121, __extension__ __PRETTY_FUNCTION__));
122  if (startBit == 0)
123    return read<value_type, endian, alignment>(memory);
124  else {
125    // Read two values and compose the result from them.
126    value_type val[2];
127    memcpy(&val[0],
128           LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
129               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
130           sizeof(value_type) * 2);
131    val[0] = byte_swap<value_type, endian>(val[0]);
132    val[1] = byte_swap<value_type, endian>(val[1]);
133 
134    // Shift bits from the lower value into place.
135    make_unsigned_t<value_type> lowerVal = val[0] >> startBit;
136    // Mask off upper bits after right shift in case of signed type.
137    make_unsigned_t<value_type> numBitsFirstVal =
138        (sizeof(value_type) * 8) - startBit;
139    lowerVal &= ((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1;
140 
141    // Get the bits from the upper value.
142    make_unsigned_t<value_type> upperVal =
143        val[1] & (((make_unsigned_t<value_type>)1 << startBit) - 1);
144    // Shift them in to place.
145    upperVal <<= numBitsFirstVal;
146 
147    return lowerVal | upperVal;
148  }
149}
150 
151/// Write a value to memory with a particular endianness, for a location
152/// that starts at the given bit offset within the first byte.
153template <typename value_type, endianness endian, std::size_t alignment>
154inline void writeAtBitAlignment(void *memory, value_type value,
155                                uint64_t startBit) {
156  assert(startBit < 8)(static_cast <bool> (startBit < 8) ? void (0) : __assert_fail
 ("startBit < 8", "/build/llvm-toolchain-snapshot-7~svn326246/include/llvm/Support/Endian.h"
, 156, __extension__ __PRETTY_FUNCTION__));
157  if (startBit == 0)
158    write<value_type, endian, alignment>(memory, value);
159  else {
160    // Read two values and shift the result into them.
161    value_type val[2];
162    memcpy(&val[0],
163           LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
164               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
165           sizeof(value_type) * 2);
166    val[0] = byte_swap<value_type, endian>(val[0]);
167    val[1] = byte_swap<value_type, endian>(val[1]);
168 
169    // Mask off any existing bits in the upper part of the lower value that
170    // we want to replace.
171    val[0] &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
172    make_unsigned_t<value_type> numBitsFirstVal =
173        (sizeof(value_type) * 8) - startBit;
174    make_unsigned_t<value_type> lowerVal = value;
175    if (startBit > 0) {
176      // Mask off the upper bits in the new value that are not going to go into
177      // the lower value. This avoids a left shift of a negative value, which
178      // is undefined behavior.
179      lowerVal &= (((make_unsigned_t<value_type>)1 << numBitsFirstVal) - 1);
180      // Now shift the new bits into place
181      lowerVal <<= startBit;
182    }
183    val[0] |= lowerVal;
184 
185    // Mask off any existing bits in the lower part of the upper value that
186    // we want to replace.
187    val[1] &= ~(((make_unsigned_t<value_type>)1 << startBit) - 1);
188    // Next shift the bits that go into the upper value into position.
189    make_unsigned_t<value_type> upperVal = value >> numBitsFirstVal;
190    // Mask off upper bits after right shift in case of signed type.
191    upperVal &= ((make_unsigned_t<value_type>)1 << startBit) - 1;
192    val[1] |= upperVal;
193 
194    // Finally, rewrite values.
195    val[0] = byte_swap<value_type, endian>(val[0]);
196    val[1] = byte_swap<value_type, endian>(val[1]);
197    memcpy(LLVM_ASSUME_ALIGNED(__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value))
198               memory, (detail::PickAlignment<value_type, alignment>::value))__builtin_assume_aligned(memory, (detail::PickAlignment<value_type
, alignment>::value)),
199           &val[0], sizeof(value_type) * 2);
200  }
201}
202 
203} // end namespace endian
204 
205namespace detail {
206 
207template<typename value_type,
208         endianness endian,
209         std::size_t alignment>
210struct packed_endian_specific_integral {
211  packed_endian_specific_integral() = default;
212 
213  explicit packed_endian_specific_integral(value_type val) { *this = val; }
214 
215  operator value_type() const {
216    return endian::read<value_type, endian, alignment>(
217      (const void*)Value.buffer);
218  }
219 
220  void operator=(value_type newValue) {
221    endian::write<value_type, endian, alignment>(
222      (void*)Value.buffer, newValue);
223  }
224 
225  packed_endian_specific_integral &operator+=(value_type newValue) {
226    *this = *this + newValue;
227    return *this;
228  }
229 
230  packed_endian_specific_integral &operator-=(value_type newValue) {
231    *this = *this - newValue;
232    return *this;
233  }
234 
235  packed_endian_specific_integral &operator|=(value_type newValue) {
236    *this = *this | newValue;
237    return *this;
238  }
239 
240  packed_endian_specific_integral &operator&=(value_type newValue) {
241    *this = *this & newValue;
242    return *this;
243  }
244 
245private:
246  AlignedCharArray<PickAlignment<value_type, alignment>::value,
247                   sizeof(value_type)> Value;
248 
249public:
250  struct ref {
251    explicit ref(void *Ptr) : Ptr(Ptr) {}
252 
253    operator value_type() const {
254      return endian::read<value_type, endian, alignment>(Ptr);
255    }
256 
257    void operator=(value_type NewValue) {
258      endian::write<value_type, endian, alignment>(Ptr, NewValue);
259    }
260 
261  private:
262    void *Ptr;
263  };
264};
265 
266} // end namespace detail
267 
268using ulittle16_t =
269    detail::packed_endian_specific_integral<uint16_t, little, unaligned>;
270using ulittle32_t =
271    detail::packed_endian_specific_integral<uint32_t, little, unaligned>;
272using ulittle64_t =
273    detail::packed_endian_specific_integral<uint64_t, little, unaligned>;
274 
275using little16_t =
276    detail::packed_endian_specific_integral<int16_t, little, unaligned>;
277using little32_t =
278    detail::packed_endian_specific_integral<int32_t, little, unaligned>;
279using little64_t =
280    detail::packed_endian_specific_integral<int64_t, little, unaligned>;
281 
282using aligned_ulittle16_t =
283    detail::packed_endian_specific_integral<uint16_t, little, aligned>;
284using aligned_ulittle32_t =
285    detail::packed_endian_specific_integral<uint32_t, little, aligned>;
286using aligned_ulittle64_t =
287    detail::packed_endian_specific_integral<uint64_t, little, aligned>;
288 
289using aligned_little16_t =
290    detail::packed_endian_specific_integral<int16_t, little, aligned>;
291using aligned_little32_t =
292    detail::packed_endian_specific_integral<int32_t, little, aligned>;
293using aligned_little64_t =
294    detail::packed_endian_specific_integral<int64_t, little, aligned>;
295 
296using ubig16_t =
297    detail::packed_endian_specific_integral<uint16_t, big, unaligned>;
298using ubig32_t =
299    detail::packed_endian_specific_integral<uint32_t, big, unaligned>;
300using ubig64_t =
301    detail::packed_endian_specific_integral<uint64_t, big, unaligned>;
302 
303using big16_t =
304    detail::packed_endian_specific_integral<int16_t, big, unaligned>;
305using big32_t =
306    detail::packed_endian_specific_integral<int32_t, big, unaligned>;
307using big64_t =
308    detail::packed_endian_specific_integral<int64_t, big, unaligned>;
309 
310using aligned_ubig16_t =
311    detail::packed_endian_specific_integral<uint16_t, big, aligned>;
312using aligned_ubig32_t =
313    detail::packed_endian_specific_integral<uint32_t, big, aligned>;
314using aligned_ubig64_t =
315    detail::packed_endian_specific_integral<uint64_t, big, aligned>;
316 
317using aligned_big16_t =
318    detail::packed_endian_specific_integral<int16_t, big, aligned>;
319using aligned_big32_t =
320    detail::packed_endian_specific_integral<int32_t, big, aligned>;
321using aligned_big64_t =
322    detail::packed_endian_specific_integral<int64_t, big, aligned>;
323 
324using unaligned_uint16_t =
325    detail::packed_endian_specific_integral<uint16_t, native, unaligned>;
326using unaligned_uint32_t =
327    detail::packed_endian_specific_integral<uint32_t, native, unaligned>;
328using unaligned_uint64_t =
329    detail::packed_endian_specific_integral<uint64_t, native, unaligned>;
330 
331using unaligned_int16_t =
332    detail::packed_endian_specific_integral<int16_t, native, unaligned>;
333using unaligned_int32_t =
334    detail::packed_endian_specific_integral<int32_t, native, unaligned>;
335using unaligned_int64_t =
336    detail::packed_endian_specific_integral<int64_t, native, unaligned>;
337 
338namespace endian {
339 
340template <typename T> inline T read(const void *P, endianness E) {
341  return read<T, unaligned>(P, E);
342}
343 
344template <typename T, endianness E> inline T read(const void *P) {
345  return *(const detail::packed_endian_specific_integral<T, E, unaligned> *)P;
346}
347 
348inline uint16_t read16(const void *P, endianness E) {
349  return read<uint16_t>(P, E);
350}
351inline uint32_t read32(const void *P, endianness E) {
352  return read<uint32_t>(P, E);
353}
354inline uint64_t read64(const void *P, endianness E) {
355  return read<uint64_t>(P, E);
356}
357 
358template <endianness E> inline uint16_t read16(const void *P) {
359  return read<uint16_t, E>(P);
360}
361template <endianness E> inline uint32_t read32(const void *P) {
362  return read<uint32_t, E>(P);
363}
364template <endianness E> inline uint64_t read64(const void *P) {
365  return read<uint64_t, E>(P);
366}
367 
368inline uint16_t read16le(const void *P) { return read16<little>(P); }
369inline uint32_t read32le(const void *P) { return read32<little>(P); }
370inline uint64_t read64le(const void *P) { return read64<little>(P); }
371inline uint16_t read16be(const void *P) { return read16<big>(P); }
372inline uint32_t read32be(const void *P) { return read32<big>(P); }
373inline uint64_t read64be(const void *P) { return read64<big>(P); }
374 
375template <typename T> inline void write(void *P, T V, endianness E) {
376  write<T, unaligned>(P, V, E);
377}
378 
379template <typename T, endianness E> inline void write(void *P, T V) {
380  *(detail::packed_endian_specific_integral<T, E, unaligned> *)P = V;
381}
382 
383inline void write16(void *P, uint16_t V, endianness E) {
384  write<uint16_t>(P, V, E);
385}
386inline void write32(void *P, uint32_t V, endianness E) {
387  write<uint32_t>(P, V, E);
388}
389inline void write64(void *P, uint64_t V, endianness E) {
390  write<uint64_t>(P, V, E);
391}
392 
393template <endianness E> inline void write16(void *P, uint16_t V) {
394  write<uint16_t, E>(P, V);
395}
396template <endianness E> inline void write32(void *P, uint32_t V) {
397  write<uint32_t, E>(P, V);
398}
399template <endianness E> inline void write64(void *P, uint64_t V) {
400  write<uint64_t, E>(P, V);
401}
402 
403inline void write16le(void *P, uint16_t V) { write16<little>(P, V); }
404inline void write32le(void *P, uint32_t V) { write32<little>(P, V); }
405inline void write64le(void *P, uint64_t V) { write64<little>(P, V); }
406inline void write16be(void *P, uint16_t V) { write16<big>(P, V); }
407inline void write32be(void *P, uint32_t V) { write32<big>(P, V); }
408inline void write64be(void *P, uint64_t V) { write64<big>(P, V); }
409 
410} // end namespace endian
411 
412} // end namespace support
413} // end namespace llvm
414 
415#endif // LLVM_SUPPORT_ENDIAN_H