[llvm-pdbutil] Print detailed S_UDT stats

[zturner]

Summary

This breaks down all S_UDT records in a PDB file by the leaf kind it points to and prints counts and size totals for each one.

Additionally, it breaks down the records by namespace. In the future I intend to add object file support so we can get this kind of output with individual object files as well, whish should help greatly in figuring out PDB size issues.

[inglorion]

Mostly lgtm; please take a look at the couple of inline comments before landing.

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

624

Underscores are good, too, right?

665

Consider changing the wording here so that we don't print "Error" but return success. Maybe "No S_UDT stats; globals stream not present"?

llvm/include/llvm/DebugInfo/PDB/Native/SymbolStream.h

public:
   SymbolStream(std::unique_ptr<msf::MappedBlockStream> Stream);
   ~SymbolStream();
   Error reload();
 
   const codeview::CVSymbolArray &getSymbolArray() const {
     return SymbolRecords;
   }
 
+  codeview::CVSymbol readRecord(uint32_t Offset) const;
+
   iterator_range<codeview::CVSymbolArray::Iterator>
   getSymbols(bool *HadError) const;
 
   Error commit();
 
 private:
   codeview::CVSymbolArray SymbolRecords;
   std::unique_ptr<msf::MappedBlockStream> Stream;
 };
 }
 }
 
 #endif

llvm/lib/DebugInfo/PDB/Native/SymbolStream.cpp

 //===- SymbolStream.cpp - PDB Symbol Stream Access ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
 
 #include "llvm/DebugInfo/CodeView/CodeView.h"
-#include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;

 }
 
 iterator_range<codeview::CVSymbolArray::Iterator>
 SymbolStream::getSymbols(bool *HadError) const {
   return llvm::make_range(SymbolRecords.begin(HadError), SymbolRecords.end());
 }
 
 Error SymbolStream::commit() { return Error::success(); }
+
+codeview::CVSymbol SymbolStream::readRecord(uint32_t Offset) const {
+  return *SymbolRecords.at(Offset);
+}

llvm/test/DebugInfo/PDB/module-stats.test

-; RUN: llvm-pdbutil dump -mod-stats %p/Inputs/empty.pdb | FileCheck --check-prefix=ALL %s
-; RUN: llvm-pdbutil dump -mod-stats -modi=1 %p/Inputs/empty.pdb | FileCheck --check-prefix=ONE %s
+; RUN: llvm-pdbutil dump -sym-stats %p/Inputs/empty.pdb | FileCheck --check-prefix=ALL %s
+; RUN: llvm-pdbutil dump -sym-stats -modi=1 %p/Inputs/empty.pdb | FileCheck --check-prefix=ONE %s
 
 ALL:        Mod 0000 | `d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.obj`:
 ALL-NEXT:     Stream 12, 308 bytes
 ALL:            Symbols
 ALL-NEXT:                                          Total:       6 entries (     204 bytes)
 ALL-NEXT:       --------------------------------------------------------------------------
 ALL-NEXT:                                      S_GPROC32:       1 entries (      44 bytes)
 ALL-NEXT:                                    S_FRAMEPROC:       1 entries (      32 bytes)

llvm/test/DebugInfo/PDB/udt-stats.test

+; RUN: llvm-pdbutil dump -udt-stats %p/Inputs/big-read.pdb | FileCheck %s
+
+CHECK:                      S_UDT Record Stats
+CHECK-NEXT: ============================================================
+CHECK:            Record Kind | Count   Size
+CHECK-NEXT:     -----------------------------
+CHECK-NEXT:           LF_ENUM |     3    188
+CHECK-NEXT:        LF_POINTER |    39    468
+CHECK-NEXT:          LF_UNION |     1     52
+CHECK-NEXT:     <simple type> |    43      0
+CHECK-NEXT:      LF_PROCEDURE |     1     16
+CHECK-NEXT:      LF_STRUCTURE |    27  1,788
+CHECK-NEXT:     -----------------------------
+CHECK-NEXT:     Total (S_UDT) |   114  2,604
+CHECK-NEXT:     -----------------------------

llvm/tools/llvm-pdbutil/DumpOutputStyle.h

public:
 
   Error dump() override;
 
 private:
   Expected<codeview::LazyRandomTypeCollection &> initializeTypes(uint32_t SN);
 
   Error dumpFileSummary();
   Error dumpStreamSummary();
-  Error dumpModuleStats();
+  Error dumpSymbolStats();
+  Error dumpUdtStats();
   Error dumpStringTable();
   Error dumpLines();
   Error dumpInlineeLines();
   Error dumpXmi();
   Error dumpXme();
   Error dumpTpiStream(uint32_t StreamIdx);
   Error dumpModules();
   Error dumpModuleFiles();

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/PDBExtras.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 
+#include <cctype>
 #include <unordered_map>
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::msf;
 using namespace llvm::pdb;
 
 DumpOutputStyle::DumpOutputStyle(PDBFile &File)
     : File(File), P(2, false, outs()) {}
 
 Error 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::DumpModuleStats.getNumOccurrences() > 0) {
-    if (auto EC = dumpModuleStats())
+  if (opts::dump::DumpSymbolStats.getNumOccurrences() > 0) {
+    if (auto EC = dumpSymbolStats())
+      return EC;
+    P.NewLine();
+  }
+
+  if (opts::dump::DumpUdtStats.getNumOccurrences() > 0) {
+    if (auto EC = dumpUdtStats())
       return EC;
     P.NewLine();
   }
 
   if (opts::dump::DumpStringTable) {
     if (auto EC = dumpStringTable())
       return EC;
     P.NewLine();
iterateModules(
         const DbiModuleList &Modules = Stream.modules();
         for (const auto &F : Modules.source_files(Modi)) {
           Strings.formatFromFileName(P, F);
         }
       });
   return Error::success();
 }
 
-Error DumpOutputStyle::dumpModuleStats() {
+Error DumpOutputStyle::dumpSymbolStats() {
   printHeader(P, "Module Stats");
 
   ExitOnError Err("Unexpected error processing modules: ");
 
   StatCollection SymStats;
   StatCollection ChunkStats;
   auto &Stream = Err(File.getPDBDbiStream());
 
Error DumpOutputStyle::dumpSymbolStats() {
   if (SymStats.Totals.Count > 0) {
     printModuleDetailStats<SymbolKind>(P, "Symbols", SymStats);
     printModuleDetailStats<DebugSubsectionKind>(P, "Chunks", ChunkStats);
   }
 
   return Error::success();
 }
 
+static 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); });
+}
+
+namespace {
+constexpr uint32_t kNoneUdtKind = 0;
+constexpr uint32_t kSimpleUdtKind = 1;
+constexpr uint32_t kUnknownUdtKind = 2;
+const StringRef NoneLabel("<none type>");
+const StringRef SimpleLabel("<simple type>");
+const StringRef UnknownLabel("<unknown type>");
+
+} // namespace
+
+static 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));
+}
+
+static 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);
+}
+
+Error DumpOutputStyle::dumpUdtStats() {
+  printHeader(P, "S_UDT Record Stats");
+
+  StatCollection UdtStats;
+  StatCollection UdtTargetStats;
+  if (!File.hasPDBGlobalsStream()) {
+    P.printLine("- Error: globals stream not present");
+    return Error::success();
+  }
+
+  AutoIndent Indent(P, 4);
+
+  auto &SymbolRecords = cantFail(File.getPDBSymbolStream());
+  auto &Globals = cantFail(File.getPDBGlobalsStream());
+  auto &TpiTypes = cantFail(initializeTypes(StreamTPI));
+
+  StringMap<StatCollection::Stat> NamespacedStats;
+
+  P.NewLine();
+
+  size_t LongestNamespace = 0;
+  for (uint32_t PubSymOff : Globals.getGlobalsTable()) {
+    CVSymbol Sym = SymbolRecords.readRecord(PubSymOff);
+    if (Sym.kind() != SymbolKind::S_UDT)
+      continue;
+    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.isSimple() ||
+        (UDT.Type.toArrayIndex() >= TpiTypes.capacity())) {
+      if (UDT.Type.isNoneType())
+        Kind = kNoneUdtKind;
+      else if (UDT.Type.isSimple())
+        Kind = kSimpleUdtKind;
+      else
+        Kind = kUnknownUdtKind;
+    } else {
+      CVType T = TpiTypes.getType(UDT.Type);
+      Kind = T.kind();
+      RecordSize = T.length();
+    }
+
+    UdtTargetStats.update(Kind, RecordSize);
+
+    size_t Pos = UDT.Name.find("::");
+    if (Pos == StringRef::npos)
+      continue;
+
+    StringRef Scope = UDT.Name.take_front(Pos);
+    if (Scope.empty() || !isValidNamespaceIdentifier(Scope))
+      continue;
+
+    LongestNamespace = std::max(LongestNamespace, Scope.size());
+    NamespacedStats[Scope].update(RecordSize);
+  }
+
+  LongestNamespace += StringRef(" namespace ''").size();
+  uint32_t LongestTypeLeafKind = getLongestTypeLeafName(UdtTargetStats);
+  uint32_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");
+  uint32_t CD = NumDigits(UdtStats.Totals.Count);
+  CD += (CD - 1) / 3;
+  CD = std::max(CD, CountHeader.size());
+
+  uint32_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();
+}
+
 static void typesetLinesAndColumns(PDBFile &File, 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.

llvm/tools/llvm-pdbutil/FormatUtil.h

std::string typesetItemList(ArrayRef<std::string> Opts, uint32_t IndentLevel,
                             uint32_t GroupSize, StringRef Sep);
 
 std::string typesetStringList(uint32_t IndentLevel,
                               ArrayRef<StringRef> Strings);
 
 std::string formatChunkKind(codeview::DebugSubsectionKind Kind,
                             bool Friendly = true);
 std::string formatSymbolKind(codeview::SymbolKind K);
+StringRef formatTypeLeafKind(codeview::TypeLeafKind K);
 
 /// Returns the number of digits in the given integer.
 inline int NumDigits(uint64_t N) {
   if (N < 10ULL)
     return 1;
   if (N < 100ULL)
     return 2;
   if (N < 1000ULL)

llvm/tools/llvm-pdbutil/FormatUtil.cpp

#define SYMBOL_RECORD(EnumName, value, name)                                   \
   case EnumName:                                                               \
     return #EnumName;
 #define CV_SYMBOL(EnumName, value) SYMBOL_RECORD(EnumName, value, EnumName)
 #include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
   }
   return formatUnknownEnum(K);
 }
 
+StringRef llvm::pdb::formatTypeLeafKind(TypeLeafKind K) {
+  switch (K) {
+#define TYPE_RECORD(EnumName, value, name)                                     \
+  case EnumName:                                                               \
+    return #EnumName;
+#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
+  default:
+    llvm_unreachable("Unknown type leaf kind!");
+  }
+  return "";
+}
+
 std::string llvm::pdb::formatSegmentOffset(uint16_t Segment, uint32_t Offset) {
   return formatv("{0:4}:{1:4}", Segment, Offset);
 }
 
 #define PUSH_CHARACTERISTIC_FLAG(Enum, TheOpt, Value, Style, Descriptive)      \
   PUSH_FLAG(Enum, TheOpt, Value,                                               \
             ((Style == CharacteristicStyle::HeaderDefinition) ? #TheOpt        \
                                                               : Descriptive))

llvm/tools/llvm-pdbutil/MinimalTypeDumper.cpp

 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
-static StringRef getLeafTypeName(TypeLeafKind K) {
-  switch (K) {
-#define TYPE_RECORD(EnumName, value, name)                                     \
-  case EnumName:                                                               \
-    return #EnumName;
-#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
-  default:
-    llvm_unreachable("Unknown type leaf kind!");
-  }
-  return "";
-}
-
 static std::string formatClassOptions(uint32_t IndentLevel,
                                       ClassOptions Options) {
   std::vector<std::string> Opts;
   PUSH_FLAG(ClassOptions, HasConstructorOrDestructor, Options,
             "has ctor / dtor");
   PUSH_FLAG(ClassOptions, ContainsNestedClass, Options,
             "contains nested class");
   PUSH_FLAG(ClassOptions, HasConversionOperator, Options,

 
 Error MinimalTypeDumpVisitor::visitTypeBegin(CVType &Record, TypeIndex Index) {
   // formatLine puts the newline at the beginning, so we use formatLine here
   // to start a new line, and then individual visit methods use format to
   // append to the existing line.
   if (!Hashes) {
     P.formatLine("{0} | {1} [size = {2}]",
                  fmt_align(Index, AlignStyle::Right, Width),
-                 getLeafTypeName(Record.Type), Record.length());
+                 formatTypeLeafKind(Record.Type), Record.length());
   } else {
     std::string H;
     if (Index.toArrayIndex() >= HashValues.size()) {
       H = "(not present)";
     } else {
       uint32_t Hash = HashValues[Index.toArrayIndex()];
       Expected<uint32_t> MaybeHash = hashTypeRecord(Record);
       if (!MaybeHash)
         return MaybeHash.takeError();
       uint32_t OurHash = *MaybeHash;
       OurHash %= NumHashBuckets;
       if (Hash == OurHash)
         H = "0x" + utohexstr(Hash);
       else
         H = "0x" + utohexstr(Hash) + ", our hash = 0x" + utohexstr(OurHash);
     }
     P.formatLine("{0} | {1} [size = {2}, hash = {3}]",
                  fmt_align(Index, AlignStyle::Right, Width),
-                 getLeafTypeName(Record.Type), Record.length(), H);
+                 formatTypeLeafKind(Record.Type), Record.length(), H);
   }
   P.Indent(Width + 3);
   return Error::success();
 }
 Error MinimalTypeDumpVisitor::visitTypeEnd(CVType &Record) {
   P.Unindent(Width + 3);
   if (RecordBytes) {
     AutoIndent Indent(P, 9);
     P.formatBinary("Bytes", Record.RecordData, 0);
   }
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitMemberBegin(CVMemberRecord &Record) {
-  P.formatLine("- {0}", getLeafTypeName(Record.Kind));
+  P.formatLine("- {0}", formatTypeLeafKind(Record.Kind));
   return Error::success();
 }
 
 Error MinimalTypeDumpVisitor::visitMemberEnd(CVMemberRecord &Record) {
   if (RecordBytes) {
     AutoIndent Indent(P, 2);
     P.formatBinary("Bytes", Record.Data, 0);
   }

llvm/tools/llvm-pdbutil/llvm-pdbutil.h

 extern llvm::cl::opt<bool> SplitChunks;
 } // namespace bytes
 
 namespace dump {
 
 extern llvm::cl::opt<bool> DumpSummary;
 extern llvm::cl::opt<bool> DumpFpm;
 extern llvm::cl::opt<bool> DumpStreams;
-extern llvm::cl::opt<bool> DumpModuleStats;
+extern llvm::cl::opt<bool> DumpSymbolStats;
+extern llvm::cl::opt<bool> DumpUdtStats;
 extern llvm::cl::opt<bool> DumpStreamBlocks;
 
 extern llvm::cl::opt<bool> DumpLines;
 extern llvm::cl::opt<bool> DumpInlineeLines;
 extern llvm::cl::opt<bool> DumpXmi;
 extern llvm::cl::opt<bool> DumpXme;
 extern llvm::cl::opt<bool> DumpStringTable;
 extern llvm::cl::opt<bool> DumpTypes;

llvm/tools/llvm-pdbutil/llvm-pdbutil.cpp

cl::opt<bool> DumpSummary("summary", cl::desc("dump file summary"),
                           cl::cat(MsfOptions), cl::sub(DumpSubcommand));
 cl::opt<bool> DumpStreams("streams",
                           cl::desc("dump summary of the PDB streams"),
                           cl::cat(MsfOptions), cl::sub(DumpSubcommand));
 cl::opt<bool> DumpStreamBlocks(
     "stream-blocks",
     cl::desc("Add block information to the output of -streams"),
     cl::cat(MsfOptions), cl::sub(DumpSubcommand));
-cl::opt<bool>
-    DumpModuleStats("mod-stats",
-                    cl::desc("Dump a detailed size breakdown for each module"),
-                    cl::cat(MsfOptions), cl::sub(DumpSubcommand));
+cl::opt<bool> DumpSymbolStats(
+    "sym-stats",
+    cl::desc("Dump a detailed breakdown of symbol usage/size for each module"),
+    cl::cat(MsfOptions), cl::sub(DumpSubcommand));
+
+cl::opt<bool> DumpUdtStats(
+    "udt-stats",
+    cl::desc("Dump a detailed breakdown of S_UDT record usage / stats"),
 
 // TYPE OPTIONS
 cl::opt<bool> DumpTypes("types",
                         cl::desc("dump CodeView type records from TPI stream"),
                         cl::cat(TypeOptions), cl::sub(DumpSubcommand));
 cl::opt<bool> DumpTypeData(
     "type-data",
     cl::desc("dump CodeView type record raw bytes from TPI stream"),
if (!parseRange(opts::bytes::DumpByteRangeOpt,
              << "' invalid format.\n";
       errs().flush();
       exit(1);
     }
   }
 
   if (opts::DumpSubcommand) {
     if (opts::dump::RawAll) {
-      opts::dump::DumpLines = true;
+      opts::dump::DumpGlobals = true;
       opts::dump::DumpInlineeLines = true;
-      opts::dump::DumpXme = true;
-      opts::dump::DumpXmi = true;
       opts::dump::DumpIds = true;
-      opts::dump::DumpGlobals = true;
+      opts::dump::DumpIdExtras = true;
+      opts::dump::DumpLines = true;
+      opts::dump::DumpModules = true;
+      opts::dump::DumpModuleFiles = true;
       opts::dump::DumpPublics = true;
       opts::dump::DumpSectionContribs = true;
+      opts::dump::DumpSectionHeaders = true;
       opts::dump::DumpSectionMap = true;
       opts::dump::DumpStreams = true;
       opts::dump::DumpStreamBlocks = true;
       opts::dump::DumpStringTable = true;
-      opts::dump::DumpSectionHeaders = true;
       opts::dump::DumpSummary = true;
       opts::dump::DumpSymbols = true;
-      opts::dump::DumpIds = true;
-      opts::dump::DumpIdExtras = true;
+      opts::dump::DumpSymbolStats = true;
       opts::dump::DumpTypes = true;
       opts::dump::DumpTypeExtras = true;
-      opts::dump::DumpModules = true;
-      opts::dump::DumpModuleFiles = true;
+      opts::dump::DumpUdtStats = true;
+      opts::dump::DumpXme = true;
+      opts::dump::DumpXmi = true;
     }
   }
   if (opts::PdbToYamlSubcommand) {
     if (opts::pdb2yaml::All) {
       opts::pdb2yaml::StreamMetadata = true;
       opts::pdb2yaml::StreamDirectory = true;
       opts::pdb2yaml::PdbStream = true;
       opts::pdb2yaml::StringTable = true;