[llvm-pdbutil] Move InputFile/FormatUtil/LinePrinter to the PDB library.

[CarlosAlbertoEnciso]

Summary

[llvm-pdbutil] Move InputFile/FormatUtil/LinePrinter to the PDB library.

At Sony we are developing llvm-dva

https://lists.llvm.org/pipermail/llvm-dev/2020-August/144174.html

For its PDB support, it requires functionality already present in llvm-pdbutil.

We intend to move that functionaly into the PDB library to be shared by both tools. That change will be done in 2 steps, that
will be submitted as 2 patches:

(1) Replace 'ExitOnError' with explicit error handling.
(2) Move the intended shared code to the PDB library.

Patch for step (1): https://reviews.llvm.org/D121801

This patch is for step (2).

Move InputFile.cpp[h], FormatUtil.cpp[h] and LinePrinter.cpp[h] files to the debug PDB library.

It exposes the following functionality that can be used by tools:

• Open a PDB file.
• Get module debug stream.
• Traverse module sections.
• Traverse module subsections.

Most of the needed functionality is in InputFile, but there are dependencies from LinePrinter and FormatUtil.

Some other functionality is in the following functions in DumpOutputStyle.cpp file:

• iterateModuleSubsections
• getModuleDebugStream
• iterateOneModule
• iterateSymbolGroups
• iterateModuleSubsections

Only these specific functions from DumpOutputStyle are moved to the PDB library.

[CarlosAlbertoEnciso]

I am preparing some numbers about sizes before and after this patch.

[CarlosAlbertoEnciso]

Updated patch fixing some clang-format issues.

[CarlosAlbertoEnciso]

The following modules are directly affected by this patch:

llvm\lib\DebugInfo\DebugInfoPDB
llvm\lib\DebugInfo\Symbolize
llvm\tools\llvm-objdump
llvm\tools\llvm-pdbutil
llvm\tools\llvm-readobj
llvm\tools\llvm-symbolizer
llvm\tools\sancov

The following tables show the sizes before and after the patch, for static and shared libraries.

Static libraries

Module	Before	After
libLLVMDebugInfoPDB.a	2,646,354	2,931,710
libLLVMSymbolize.a	324,626	324,626
llvm-objdump	32,456,600	32,456,600
llvm-pdbutil	8,084,816	8,090,784
llvm-readobj	8,732,608	8,732,608
llvm-symbolizer	7,196,432	7,196,432
sancov	32,610,392	32,610,392

Shared libraries

Module	Before	After
libLLVMDebugInfoPDB.so	1,180,744	1,314,320
libLLVMSymbolize.so	232,464	232,464
llvm-objdump	912,696	912,696
llvm-pdbutil	1,293,792	1,215,952
llvm-readobj	2,168,016	2,168,016
llvm-symbolizer	76,920	76,920
sancov	158,432	158,432

[dblaikie]

In D122226#3402171, @CarlosAlbertoEnciso wrote:

The following modules are directly affected by this patch:

Which build configuration is that in & could you include % growth in the chart? (it'd be interesting to see if there's any growth in a build that uses -ffunction-sections -fdata-sections -Wl,-gc-sections)

[rnk]

lgtm

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

163

These callbacks look like they could actually be function_refs. Can you put a // TODO comment here to de-templatify them? I don't want to block on it.

[aganea]

There's a typo in the title:

[llmv-pdbutil] Move InputFile/FormatUtil/LinePrinter to PDB library.

llvm-pdbutil

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

33

Not a blocker, but I'm a bit allergic to global state, especially in a lib. I wonder how much work it would be to keep this Filters state inside the LinePrinter class and pass it by reference to the iterate* functions. That could be done in a later patch.

[CarlosAlbertoEnciso]

In D122226#3403269, @dblaikie wrote:

Which build configuration is that in & could you include % growth in the chart? (it'd be interesting to see if there's any growth in a build that uses -ffunction-sections -fdata-sections -Wl,-gc-sections)

It is a Release configuration. I have included new data for the requested options ( -ffunction-sections -fdata-sections -Wl,-gc-sections)

Static libraries

Module	Before	After	% growth
libLLVMDebugInfoPDB.a	2,646,354	2,931,710	10.78
libLLVMSymbolize.a	324,626	324,626	0.00
llvm-objdump	32,456,936	32,456,936	0.00
llvm-pdbutil	8,084,800	8,090,768	0.07
llvm-readobj	8,733,784	8,733,784	0.00
llvm-symbolizer	7,201,704	7,201,704	0.00
sancov	32,618,920	32,618,920	0.00

Shared libraries

Module	Before	After	% growth
libLLVMDebugInfoPDB.so	1,180,744	1,314,320	11.31
libLLVMSymbolize.so	232,464	232,464	0.00
llvm-objdump	912,696	912,696	0.00
llvm-pdbutil	1,293,792	1,215,952	-6.02
llvm-readobj	2,168,016	2,168,016	0.00
llvm-symbolizer	76,920	76,920	0.00
sancov	158,432	158,432	0.00

[CarlosAlbertoEnciso]

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

163

I have added a // TODO comment.

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

33

I have added a // TODO comment.
After pushing this patch I will look at creating another patch to move Filters.

[CarlosAlbertoEnciso]

Add couple of // TODO comments for:

• Move Filters inside the LinePrinter class.
• Change callbacks used by the symbol group traversal to function-refs (de-templatify them).

[CarlosAlbertoEnciso]

@aganea, @dblaikie, @rnk: Thanks for your reviews.

[zequanwu]

This causes llvm-pdbutil crashes when modi is neither 0 nor 1, e.g. llvm-pdbutil dump --symbols -modi=2 a.pdb

llvm-pdbutil: ../../llvm/include/llvm/DebugInfo/PDB/Native/InputFile.h:185: llvm::Error llvm::pdb::iterateSymbolGroups(llvm::pdb::InputFile &, const Optional<llvm::pdb::PrintScope> &, CallbackT) [CallbackT = (lambda at ../../llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp:1472:7)]: Assertion `llvm::pdb::Filters.DumpModi == 1' failed.

[CarlosAlbertoEnciso]

In D122226#3417917, @zequanwu wrote:

This causes llvm-pdbutil crashes when modi is neither 0 nor 1, e.g. llvm-pdbutil dump --symbols -modi=2 a.pdb

llvm-pdbutil: ../../llvm/include/llvm/DebugInfo/PDB/Native/InputFile.h:185: llvm::Error llvm::pdb::iterateSymbolGroups(llvm::pdb::InputFile &, const Optional<llvm::pdb::PrintScope> &, CallbackT) [CallbackT = (lambda at ../../llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp:1472:7)]: Assertion `llvm::pdb::Filters.DumpModi == 1' failed.

I am sorry for my late reply.
When InputFile.cpp[h] were moved to the PDB library, no logic related with modi was changed.
I will have a look at it and raise a bugzilla for that issue.

[CarlosAlbertoEnciso]

In D122226#3417917, @zequanwu wrote:

This causes llvm-pdbutil crashes when modi is neither 0 nor 1, e.g. llvm-pdbutil dump --symbols -modi=2 a.pdb

@zequanwu, these are my findings

Before this patch:

llvm-pdbutil dump --symbols -modi=2 a.pdb         --> OK
llvm-pdbutil dump --symbols -modi=2 -modi=1 a.pdb --> Assertion
llvm-pdbutil dump --symbols -modi=1 -modi=2 a.pdb --> Assertion

Assertion failed: opts::dump::DumpModi.getNumOccurrences() == 1, file X:\llvm-root\llvm-project\llvm\tools\llvm-pdbutil\DumpOutputStyle.cpp, line 456

It means that the -modi argument can't be specified more than once.

With this patch:

llvm-pdbutil dump --symbols -modi=2 a.pdb         --> Assertion
llvm-pdbutil dump --symbols -modi=2 -modi=1 a.pdb --> Assertion
llvm-pdbutil dump --symbols -modi=1 -modi=2 a.pdb --> Assertion

Assertion failed: Modi == 1, file X:\diva-root\llvm-project\llvm\include\llvm/DebugInfo/PDB/Native/InputFile.h, line 186

It means that the -modi argument can be '0' or '1', which is wrong.

I will upload a patch to fix the issue and move the assertion out of the library and put it in the driver.

Created https://reviews.llvm.org/D123483 with appropriated patch.

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

 //===- FormatUtil.h ------------------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TOOLS_LLVMPDBUTIL_FORMAT_UTIL_H
-#define LLVM_TOOLS_LLVMPDBUTIL_FORMAT_UTIL_H
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_FORMATUTIL_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_FORMATUTIL_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 

 
 template <typename T>
 detail::EndianAdapter<T>
 fmtle(support::detail::packed_endian_specific_integral<T, support::little,
                                                        support::unaligned>
           Value) {
   return detail::EndianAdapter<T>(std::move(Value));
 }
-}
+} // namespace pdb
 } // namespace llvm
 #endif

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

 //===- InputFile.h -------------------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TOOLS_LLVMPDBDUMP_INPUTFILE_H
-#define LLVM_TOOLS_LLVMPDBDUMP_INPUTFILE_H
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_INPUTFILE_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_INPUTFILE_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace codeview {
 class LazyRandomTypeCollection;
class InputFile {
   TypeCollectionPtr Types;
   TypeCollectionPtr Ids;
 
   enum TypeCollectionKind { kTypes, kIds };
   codeview::LazyRandomTypeCollection &
   getOrCreateTypeCollection(TypeCollectionKind Kind);
 
 public:
+  InputFile(PDBFile *Pdb) { PdbOrObj = Pdb; }
+  InputFile(object::COFFObjectFile *Obj) { PdbOrObj = Obj; }
+  InputFile(MemoryBuffer *Buffer) { PdbOrObj = Buffer; }
   ~InputFile();
   InputFile(InputFile &&Other) = default;
 
   static Expected<InputFile> open(StringRef Path,
                                   bool AllowUnknownFile = false);
 
   PDBFile &pdb();
   const PDBFile &pdb() const;

 
 class SymbolGroup {
   friend class SymbolGroupIterator;
 
 public:
   explicit SymbolGroup(InputFile *File, uint32_t GroupIndex = 0);
 
   Expected<StringRef> getNameFromStringTable(uint32_t Offset) const;
+  Expected<StringRef> getNameFromChecksums(uint32_t Offset) const;
 
   void formatFromFileName(LinePrinter &Printer, StringRef File,
                           bool Append = false) const;
 
   void formatFromChecksumsOffset(LinePrinter &Printer, uint32_t Offset,
                                  bool Append = false) const;
 
   StringRef name() const;
private:
   void scanToNextDebugS();
   bool isEnd() const;
 
   uint32_t Index = 0;
   Optional<object::section_iterator> SectionIter;
   SymbolGroup Value;
 };
 
+Expected<ModuleDebugStreamRef>
+getModuleDebugStream(PDBFile &File, StringRef &ModuleName, uint32_t Index);
+Expected<ModuleDebugStreamRef> getModuleDebugStream(PDBFile &File,
+                                                    uint32_t Index);
+
+bool shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group);
+
+// TODO: Change these callbacks to be function_refs (de-templatify them).
+template <typename CallbackT>
+Error iterateOneModule(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);
+  return Callback(Modi, SG);
+}
+
+template <typename CallbackT>
+Error iterateSymbolGroups(InputFile &Input,
+                          const Optional<PrintScope> &HeaderScope,
+                          CallbackT Callback) {
+  AutoIndent Indent(HeaderScope);
+
+  if (llvm::pdb::Filters.DumpModi > 0) {
+    assert(llvm::pdb::Filters.DumpModi == 1);
+    uint32_t Modi = llvm::pdb::Filters.DumpModi;
+    SymbolGroup SG(&Input, Modi);
+    return iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(Modi)),
+                            SG, Modi, Callback);
+  }
+
+  uint32_t I = 0;
+
+  for (const auto &SG : Input.symbol_groups()) {
+    if (shouldDumpSymbolGroup(I, SG))
+      if (auto Err =
+              iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(I)),
+                               SG, I, Callback))
+        return Err;
+
+    ++I;
+  }
+  return Error::success();
+}
+
+template <typename SubsectionT>
+Error iterateModuleSubsections(
+    InputFile &File, const Optional<PrintScope> &HeaderScope,
+    llvm::function_ref<Error(uint32_t, const SymbolGroup &, SubsectionT &)>
+        Callback) {
+
+  return iterateSymbolGroups(
+      File, HeaderScope, [&](uint32_t Modi, const SymbolGroup &SG) -> Error {
+        for (const auto &SS : SG.getDebugSubsections()) {
+          SubsectionT Subsection;
+
+          if (SS.kind() != Subsection.kind())
+            continue;
+
+          BinaryStreamReader Reader(SS.getRecordData());
+          if (auto Err = Subsection.initialize(Reader))
+            continue;
+          if (auto Err = Callback(Modi, SG, Subsection))
+            return Err;
+        }
+        return Error::success();
+      });
+}
+
 } // namespace pdb
 } // namespace llvm
 
 #endif

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

 //===- LinePrinter.h ------------------------------------------ *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_TOOLS_LLVMPDBDUMP_LINEPRINTER_H
-#define LLVM_TOOLS_LLVMPDBDUMP_LINEPRINTER_H
+#ifndef LLVM_DEBUGINFO_PDB_NATIVE_LINEPRINTER_H
+#define LLVM_DEBUGINFO_PDB_NATIVE_LINEPRINTER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
 #include "llvm/Support/BinaryStreamRef.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <list>
 
+// Container for filter options to control which elements will be printed.
+struct FilterOptions {
+  std::list<std::string> ExcludeTypes;
+  std::list<std::string> ExcludeSymbols;
+  std::list<std::string> ExcludeCompilands;
+  std::list<std::string> IncludeTypes;
+  std::list<std::string> IncludeSymbols;
+  std::list<std::string> IncludeCompilands;
+  uint32_t PaddingThreshold;
+  uint32_t SizeThreshold;
+  uint32_t DumpModi;
+  bool JustMyCode;
+};
+
 namespace llvm {
 namespace msf {
 class MSFStreamLayout;
 } // namespace msf
 namespace pdb {
 
+extern FilterOptions Filters;
+
 class ClassLayout;
 class PDBFile;
 
 class LinePrinter {
   friend class WithColor;
 
 public:
-  LinePrinter(int Indent, bool UseColor, raw_ostream &Stream);
+  LinePrinter(int Indent, bool UseColor, raw_ostream &Stream,
+              FilterOptions &Filters);
 
   void Indent(uint32_t Amount = 0);
   void Unindent(uint32_t Amount = 0);
   void NewLine();
 
   void printLine(const Twine &T);
   void print(const Twine &T);
-  template <typename... Ts> void formatLine(const char *Fmt, Ts &&... Items) {
+  template <typename... Ts> void formatLine(const char *Fmt, Ts &&...Items) {
     printLine(formatv(Fmt, std::forward<Ts>(Items)...));
   }
-  template <typename... Ts> void format(const char *Fmt, Ts &&... Items) {
+  template <typename... Ts> void format(const char *Fmt, Ts &&...Items) {
     print(formatv(Fmt, std::forward<Ts>(Items)...));
   }
 
   void formatBinary(StringRef Label, ArrayRef<uint8_t> Data,
                     uint64_t StartOffset);
   void formatBinary(StringRef Label, ArrayRef<uint8_t> Data, uint64_t BaseAddr,
                     uint64_t StartOffset);
 
public:
 
   raw_ostream &get() { return OS; }
 
 private:
   void applyColor(PDB_ColorItem C);
   raw_ostream &OS;
   bool UseColor;
 };
-}
-}
+} // namespace pdb
+} // namespace llvm
 
 #endif

llvm/lib/DebugInfo/PDB/CMakeLists.txt

 
 add_pdb_impl_folder(Native
   Native/DbiModuleDescriptor.cpp
   Native/DbiModuleDescriptorBuilder.cpp
   Native/DbiModuleList.cpp
   Native/DbiStream.cpp
   Native/DbiStreamBuilder.cpp
   Native/EnumTables.cpp
+  Native/FormatUtil.cpp
   Native/GlobalsStream.cpp
   Native/Hash.cpp
   Native/HashTable.cpp
   Native/InfoStream.cpp
   Native/InfoStreamBuilder.cpp
   Native/InjectedSourceStream.cpp
+  Native/InputFile.cpp
+  Native/LinePrinter.cpp
   Native/ModuleDebugStream.cpp
   Native/NativeCompilandSymbol.cpp
   Native/NativeEnumGlobals.cpp
   Native/NativeEnumInjectedSources.cpp
   Native/NativeEnumLineNumbers.cpp
   Native/NativeEnumModules.cpp
   Native/NativeEnumTypes.cpp
   Native/NativeEnumSymbols.cpp

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

 //===- FormatUtil.cpp ----------------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "FormatUtil.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
+
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace llvm;

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

 //===- InputFile.cpp ------------------------------------------ *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "InputFile.h"
-
-#include "FormatUtil.h"
-#include "LinePrinter.h"
+#include "llvm/DebugInfo/PDB/Native/InputFile.h"
 
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/PDBStringTable.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::object;
 using namespace llvm::pdb;
 
 InputFile::InputFile() {}
 InputFile::~InputFile() {}
 
-static Expected<ModuleDebugStreamRef>
-getModuleDebugStream(PDBFile &File, StringRef &ModuleName, uint32_t Index) {
+Expected<ModuleDebugStreamRef>
+llvm::pdb::getModuleDebugStream(PDBFile &File, StringRef &ModuleName,
+                                uint32_t Index) {
   Expected<DbiStream &> DbiOrErr = File.getPDBDbiStream();
   if (!DbiOrErr)
     return DbiOrErr.takeError();
   DbiStream &Dbi = *DbiOrErr;
   const auto &Modules = Dbi.modules();
   if (Index >= Modules.getModuleCount())
     return make_error<RawError>(raw_error_code::index_out_of_bounds,
                                 "Invalid module index");
llvm::pdb::getModuleDebugStream(PDBFile &File, StringRef &ModuleName,
   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);
 }
 
+Expected<ModuleDebugStreamRef> llvm::pdb::getModuleDebugStream(PDBFile &File,
+                                                               uint32_t Index) {
+  Expected<DbiStream &> DbiOrErr = File.getPDBDbiStream();
+  if (!DbiOrErr)
+    return DbiOrErr.takeError();
+  DbiStream &Dbi = *DbiOrErr;
+  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 (Error Err = ModS.reload())
+    return make_error<RawError>(raw_error_code::corrupt_file,
+                                "Invalid module stream");
+
+  return std::move(ModS);
+}
+
 static inline bool isCodeViewDebugSubsection(object::SectionRef Section,
                                              StringRef Name,
                                              BinaryStreamReader &Reader) {
   if (Expected<StringRef> NameOrErr = Section.getName()) {
     if (*NameOrErr != Name)
       return false;
   } else {
     consumeError(NameOrErr.takeError());
switch (Kind) {
     RETURN_CASE(FileChecksumKind, MD5, "MD5");
     RETURN_CASE(FileChecksumKind, SHA1, "SHA-1");
     RETURN_CASE(FileChecksumKind, SHA256, "SHA-256");
   }
   return formatUnknownEnum(Kind);
 }
 
 template <typename... Args>
-static void formatInternal(LinePrinter &Printer, bool Append, Args &&... args) {
+static void formatInternal(LinePrinter &Printer, bool Append, Args &&...args) {
   if (Append)
     Printer.format(std::forward<Args>(args)...);
   else
     Printer.formatLine(std::forward<Args>(args)...);
 }
 
 SymbolGroup::SymbolGroup(InputFile *File, uint32_t GroupIndex) : File(File) {
   if (!File)
const ModuleDebugStreamRef &SymbolGroup::getPdbModuleStream() const {
   assert(File && File->isPdb() && DebugStream);
   return *DebugStream;
 }
 
 Expected<StringRef> SymbolGroup::getNameFromStringTable(uint32_t Offset) const {
   return SC.strings().getString(Offset);
 }
 
+Expected<StringRef> SymbolGroup::getNameFromChecksums(uint32_t Offset) const {
+  StringRef Name;
+  if (!SC.hasChecksums()) {
+    return std::move(Name);
+  }
+
+  auto Iter = SC.checksums().getArray().at(Offset);
+  if (Iter == SC.checksums().getArray().end()) {
+    return std::move(Name);
+  }
+
+  uint32_t FO = Iter->FileNameOffset;
+  auto ExpectedFile = getNameFromStringTable(FO);
+  if (!ExpectedFile) {
+    return std::move(Name);
+  }
+
+  return *ExpectedFile;
+}
+
 void SymbolGroup::formatFromFileName(LinePrinter &Printer, StringRef File,
                                      bool Append) const {
   auto FC = ChecksumsByFile.find(File);
   if (FC == ChecksumsByFile.end()) {
     formatInternal(Printer, Append, "- (no checksum) {0}", File);
     return;
   }
 
if (Value.File->isPdb()) {
     uint32_t Count = Dbi.modules().getModuleCount();
     assert(Index <= Count);
     return Index == Count;
   }
 
   assert(SectionIter.hasValue());
   return *SectionIter == Value.File->obj().section_end();
 }
+
+static bool isMyCode(const SymbolGroup &Group) {
+  if (Group.getFile().isObj())
+    return true;
+
+  StringRef Name = Group.name();
+  if (Name.startswith("Import:"))
+    return false;
+  if (Name.endswith_insensitive(".dll"))
+    return false;
+  if (Name.equals_insensitive("* linker *"))
+    return false;
+  if (Name.startswith_insensitive("f:\\binaries\\Intermediate\\vctools"))
+    return false;
+  if (Name.startswith_insensitive("f:\\dd\\vctools\\crt"))
+    return false;
+  return true;
+}
+
+bool llvm::pdb::shouldDumpSymbolGroup(uint32_t Idx, const SymbolGroup &Group) {
+  if (llvm::pdb::Filters.JustMyCode && !isMyCode(Group))
+    return false;
+
+  // If the arg was not specified on the command line, always dump all modules.
+  if (llvm::pdb::Filters.DumpModi == 0)
+    return true;
+
+  // Otherwise, only dump if this is the same module specified.
+  return (llvm::pdb::Filters.DumpModi == Idx);
+}

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

 //===- LinePrinter.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "LinePrinter.h"
-
-#include "llvm-pdbutil.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/MSF/MSFCommon.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
+#include "llvm/DebugInfo/PDB/Native/InputFile.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/UDTLayout.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Regex.h"
 
 #include <algorithm>
 
 using namespace llvm;
 using namespace llvm::msf;
 using namespace llvm::pdb;
 
+// TODO: Move this Filters state inside the LinePrinter class and pass it by
+// reference to the iterate* functions.
+FilterOptions llvm::pdb::Filters;
+
 namespace {
 bool IsItemExcluded(llvm::StringRef Item,
                     std::list<llvm::Regex> &IncludeFilters,
                     std::list<llvm::Regex> &ExcludeFilters) {
   if (Item.empty())
     return false;
 
   auto match_pred = [Item](llvm::Regex &R) { return R.match(Item); };
 
   // Include takes priority over exclude.  If the user specified include
   // filters, and none of them include this item, them item is gone.
   if (!IncludeFilters.empty() && !any_of(IncludeFilters, match_pred))
     return true;
 
   if (any_of(ExcludeFilters, match_pred))
     return true;
 
   return false;
 }
-}
+} // namespace
 
 using namespace llvm;
 
-LinePrinter::LinePrinter(int Indent, bool UseColor, llvm::raw_ostream &Stream)
+LinePrinter::LinePrinter(int Indent, bool UseColor, llvm::raw_ostream &Stream,
+                         FilterOptions &Filters)
     : OS(Stream), IndentSpaces(Indent), CurrentIndent(0), UseColor(UseColor) {
-  SetFilters(ExcludeTypeFilters, opts::pretty::ExcludeTypes.begin(),
-             opts::pretty::ExcludeTypes.end());
-  SetFilters(ExcludeSymbolFilters, opts::pretty::ExcludeSymbols.begin(),
-             opts::pretty::ExcludeSymbols.end());
-  SetFilters(ExcludeCompilandFilters, opts::pretty::ExcludeCompilands.begin(),
-             opts::pretty::ExcludeCompilands.end());
-
-  SetFilters(IncludeTypeFilters, opts::pretty::IncludeTypes.begin(),
-             opts::pretty::IncludeTypes.end());
-  SetFilters(IncludeSymbolFilters, opts::pretty::IncludeSymbols.begin(),
-             opts::pretty::IncludeSymbols.end());
-  SetFilters(IncludeCompilandFilters, opts::pretty::IncludeCompilands.begin(),
-             opts::pretty::IncludeCompilands.end());
+  llvm::pdb::Filters = Filters;
+  SetFilters(ExcludeTypeFilters, Filters.ExcludeTypes.begin(),
+             Filters.ExcludeTypes.end());
+  SetFilters(ExcludeSymbolFilters, Filters.ExcludeSymbols.begin(),
+             Filters.ExcludeSymbols.end());
+  SetFilters(ExcludeCompilandFilters, Filters.ExcludeCompilands.begin(),
+             Filters.ExcludeCompilands.end());
+
+  SetFilters(IncludeTypeFilters, Filters.IncludeTypes.begin(),
+             Filters.IncludeTypes.end());
+  SetFilters(IncludeSymbolFilters, Filters.IncludeSymbols.begin(),
+             Filters.IncludeSymbols.end());
+  SetFilters(IncludeCompilandFilters, Filters.IncludeCompilands.begin(),
+             Filters.IncludeCompilands.end());
 }
 
 void LinePrinter::Indent(uint32_t Amount) {
   if (Amount == 0)
     Amount = IndentSpaces;
   CurrentIndent += Amount;
 }
 

 void LinePrinter::printLine(const Twine &T) {
   NewLine();
   OS << T;
 }
 
 bool LinePrinter::IsClassExcluded(const ClassLayout &Class) {
   if (IsTypeExcluded(Class.getName(), Class.getSize()))
     return true;
-  if (Class.deepPaddingSize() < opts::pretty::PaddingThreshold)
+  if (Class.deepPaddingSize() < Filters.PaddingThreshold)
     return true;
   return false;
 }
 
 void LinePrinter::formatBinary(StringRef Label, ArrayRef<uint8_t> Data,
                                uint64_t StartOffset) {
   NewLine();
   OS << Label << " (";
while (L > 0) {
     L -= UsedBytes;
     Blocks = Blocks.drop_front();
   }
 }
 
 bool LinePrinter::IsTypeExcluded(llvm::StringRef TypeName, uint64_t Size) {
   if (IsItemExcluded(TypeName, IncludeTypeFilters, ExcludeTypeFilters))
     return true;
-  if (Size < opts::pretty::SizeThreshold)
+  if (Size < Filters.SizeThreshold)
     return true;
   return false;
 }
 
 bool LinePrinter::IsSymbolExcluded(llvm::StringRef SymbolName) {
   return IsItemExcluded(SymbolName, IncludeSymbolFilters, ExcludeSymbolFilters);
 }
 

llvm/tools/llvm-pdbutil/BytesOutputStyle.h

 //===- BytesOutputStyle.h ------------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVMPDBDUMP_BYTESOUTPUTSTYLE_H
 #define LLVM_TOOLS_LLVMPDBDUMP_BYTESOUTPUTSTYLE_H
 
-#include "LinePrinter.h"
 #include "OutputStyle.h"
 #include "StreamUtil.h"
 
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 
 namespace codeview {
 class LazyRandomTypeCollection;
 }
 

llvm/tools/llvm-pdbutil/BytesOutputStyle.cpp

 //===- BytesOutputStyle.cpp ----------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "BytesOutputStyle.h"
 
-#include "FormatUtil.h"
 #include "StreamUtil.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/DebugInfo/CodeView/Formatters.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/MSF/MSFCommon.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"

 
 static void printHeader(LinePrinter &P, const Twine &S) {
   P.NewLine();
   P.formatLine("{0,=60}", S);
   P.formatLine("{0}", fmt_repeat('=', 60));
 }
 
 BytesOutputStyle::BytesOutputStyle(PDBFile &File)
-    : File(File), P(2, false, outs()) {}
+    : File(File), P(2, false, outs(), opts::Filters) {}
 
 Error BytesOutputStyle::dump() {
 
   if (opts::bytes::DumpBlockRange.hasValue()) {
     auto &R = *opts::bytes::DumpBlockRange;
     uint32_t Max = R.Max.getValueOr(R.Min);
 
     if (Max < R.Min)

llvm/tools/llvm-pdbutil/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
   DebugInfoCodeView
   DebugInfoMSF
   DebugInfoPDB
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_tool(llvm-pdbutil
   BytesOutputStyle.cpp
   DumpOutputStyle.cpp
   ExplainOutputStyle.cpp
-  InputFile.cpp
   llvm-pdbutil.cpp
-  FormatUtil.cpp
-  LinePrinter.cpp
   MinimalSymbolDumper.cpp
   MinimalTypeDumper.cpp
   PdbYaml.cpp
   PrettyBuiltinDumper.cpp
   PrettyClassDefinitionDumper.cpp
   PrettyClassLayoutGraphicalDumper.cpp
   PrettyCompilandDumper.cpp
   PrettyEnumDumper.cpp

llvm/tools/llvm-pdbutil/DumpOutputStyle.h

 //===- DumpOutputStyle.h -------------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVMPDBDUMP_DUMPOUTPUTSTYLE_H
 #define LLVM_TOOLS_LLVMPDBDUMP_DUMPOUTPUTSTYLE_H
 
-#include "LinePrinter.h"
 #include "OutputStyle.h"
 #include "StreamUtil.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 
 #include <string>
 
 namespace llvm {
 namespace object {
 class COFFObjectFile;
 }

llvm/tools/llvm-pdbutil/DumpOutputStyle.cpp

 //===- DumpOutputStyle.cpp ------------------------------------ *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DumpOutputStyle.h"
 
-#include "FormatUtil.h"
-#include "InputFile.h"
 #include "MinimalSymbolDumper.h"
 #include "MinimalTypeDumper.h"
 #include "StreamUtil.h"
 #include "TypeReferenceTracker.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"

 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
 #include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
 #include "llvm/DebugInfo/CodeView/TypeHashing.h"
 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
 #include "llvm/DebugInfo/PDB/Native/ISectionContribVisitor.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
+#include "llvm/DebugInfo/PDB/Native/InputFile.h"
 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/PublicsStream.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/FormatVariadic.h"
 
 #include <cctype>
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::msf;
 using namespace llvm::pdb;
 
 DumpOutputStyle::DumpOutputStyle(InputFile &File)
-    : File(File), P(2, false, outs()) {
+    : File(File), P(2, false, outs(), opts::Filters) {
   if (opts::dump::DumpTypeRefStats)
     RefTracker.reset(new TypeReferenceTracker(File));
 }
 
 DumpOutputStyle::~DumpOutputStyle() {}
 
 PDBFile &DumpOutputStyle::getPdb() { return File.pdb(); }
 object::COFFObjectFile &DumpOutputStyle::getObj() { return File.obj(); }
static void printModuleDetailStats(LinePrinter &P, StringRef Label,
 
   for (const auto &K : Stats.getStatsSortedBySize()) {
     std::string KindName = formatModuleDetailKind(Kind(K.first));
     P.formatLine("{0,40}: {1,7} entries ({2,12:N} bytes)", KindName,
                  K.second.Count, K.second.Size);
   }
 }
 
-static bool isMyCode(const SymbolGroup &Group) {
-  if (Group.getFile().isObj())
-    return true;
-
-  StringRef Name = Group.name();
-  if (Name.startswith("Import:"))
-    return false;
-  if (Name.endswith_insensitive(".dll"))
-    return false;
-  if (Name.equals_insensitive("* linker *"))
-    return false;
-  if (Name.startswith_insensitive("f:\\binaries\\Intermediate\\vctools"))
-    return false;
-  if (Name.startswith_insensitive("f:\\dd\\vctools\\crt"))
-    return false;
-  return true;
-}
-
-static 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);
-}
-
 Error DumpOutputStyle::dumpStreamSummary() {
   printHeader(P, "Streams");
 
   if (File.isObj()) {
     printStreamNotValidForObj();
     return Error::success();
   }
 
if (opts::dump::DumpStreamBlocks) {
                    fmt_repeat(' ', NumDigits(StreamCount)),
                    make_range(BV.begin(), BV.end()));
     }
   }
 
   return Error::success();
 }
 
-static Expected<ModuleDebugStreamRef> getModuleDebugStream(PDBFile &File,
-                                                           uint32_t Index) {
-  Expected<DbiStream &> DbiOrErr = File.getPDBDbiStream();
-  if (!DbiOrErr)
-    return DbiOrErr.takeError();
-  DbiStream &Dbi = *DbiOrErr;
-  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);
-}
-
-template <typename CallbackT>
-static Error
-iterateOneModule(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);
-  return Callback(Modi, SG);
-}
-
-template <typename CallbackT>
-static Error iterateSymbolGroups(InputFile &Input,
-                                 const Optional<PrintScope> &HeaderScope,
-                                 CallbackT Callback) {
-  AutoIndent Indent(HeaderScope);
-
-  if (opts::dump::DumpModi.getNumOccurrences() > 0) {
-    assert(opts::dump::DumpModi.getNumOccurrences() == 1);
-    uint32_t Modi = opts::dump::DumpModi;
-    SymbolGroup SG(&Input, Modi);
-    return iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(Modi)),
-                            SG, Modi, Callback);
-  }
-
-  uint32_t I = 0;
-
-  for (const auto &SG : Input.symbol_groups()) {
-    if (shouldDumpSymbolGroup(I, SG))
-      if (auto Err =
-              iterateOneModule(Input, withLabelWidth(HeaderScope, NumDigits(I)),
-                               SG, I, Callback))
-        return Err;
-
-    ++I;
-  }
-  return Error::success();
-}
-
-template <typename SubsectionT>
-static Error iterateModuleSubsections(
-    InputFile &File, const Optional<PrintScope> &HeaderScope,
-    llvm::function_ref<Error(uint32_t, const SymbolGroup &, SubsectionT &)>
-        Callback) {
-
-  return iterateSymbolGroups(
-      File, HeaderScope, [&](uint32_t Modi, const SymbolGroup &SG) -> Error {
-        for (const auto &SS : SG.getDebugSubsections()) {
-          SubsectionT Subsection;
-
-          if (SS.kind() != Subsection.kind())
-            continue;
-
-          BinaryStreamReader Reader(SS.getRecordData());
-          if (auto Err = Subsection.initialize(Reader))
-            continue;
-          if (auto Err = Callback(Modi, SG, Subsection))
-            return Err;
-        }
-        return Error::success();
-      });
-}
-
 static Expected<std::pair<std::unique_ptr<MappedBlockStream>,
                           ArrayRef<llvm::object::coff_section>>>
 loadSectionHeaders(PDBFile &File, DbgHeaderType Type) {
   if (!File.hasPDBDbiStream())
     return make_error<StringError>(
         "Section headers require a DBI Stream, which could not be loaded",
         inconvertibleErrorCode());
 

llvm/tools/llvm-pdbutil/ExplainOutputStyle.h

 //===- ExplainOutputStyle.h ----------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVMPDBDUMP_EXPLAINOUTPUTSTYLE_H
 #define LLVM_TOOLS_LLVMPDBDUMP_EXPLAINOUTPUTSTYLE_H
 
-#include "LinePrinter.h"
 #include "OutputStyle.h"
 
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
+
 #include <string>
 
 namespace llvm {
 
 namespace pdb {
 
 class DbiStream;
 class InfoStream;

llvm/tools/llvm-pdbutil/ExplainOutputStyle.cpp

 //===- ExplainOutputStyle.cpp --------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ExplainOutputStyle.h"
 
-#include "FormatUtil.h"
-#include "InputFile.h"
 #include "StreamUtil.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/DebugInfo/CodeView/Formatters.h"
+#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
+#include "llvm/DebugInfo/PDB/Native/InputFile.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/RawTypes.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Support/BinaryByteStream.h"
 #include "llvm/Support/BinaryStreamArray.h"
 #include "llvm/Support/Error.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::msf;
 using namespace llvm::pdb;
 
 ExplainOutputStyle::ExplainOutputStyle(InputFile &File, uint64_t FileOffset)
-    : File(File), FileOffset(FileOffset), P(2, false, outs()) {}
+    : File(File), FileOffset(FileOffset), P(2, false, outs(), opts::Filters) {}
 
 Error ExplainOutputStyle::dump() {
   P.formatLine("Explaining file offset {0} of file '{1}'.", FileOffset,
                File.getFilePath());
 
   if (File.isPdb())
     return explainPdbFile();
 

llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp

 //===- MinimalSymbolDumper.cpp -------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MinimalSymbolDumper.h"
 
-#include "FormatUtil.h"
-#include "InputFile.h"
-#include "LinePrinter.h"
-
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/Formatters.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
+#include "llvm/DebugInfo/PDB/Native/InputFile.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/PDBStringTable.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 static std::string formatLocalSymFlags(uint32_t IndentLevel,
                                        LocalSymFlags Flags) {

llvm/tools/llvm-pdbutil/MinimalTypeDumper.cpp

 //===- MinimalTypeDumper.cpp ---------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MinimalTypeDumper.h"
 
-#include "FormatUtil.h"
-#include "LinePrinter.h"
 #include "TypeReferenceTracker.h"
 
 #include "llvm-pdbutil.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 #include "llvm/DebugInfo/CodeView/Formatters.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm;
 using namespace llvm::codeview;
 using namespace llvm::pdb;
 
 static std::string formatClassOptions(uint32_t IndentLevel,

llvm/tools/llvm-pdbutil/PrettyBuiltinDumper.cpp

 //===- PrettyBuiltinDumper.cpp ---------------------------------- *- C++ *-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyBuiltinDumper.h"
-#include "LinePrinter.h"
 
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 BuiltinDumper::BuiltinDumper(LinePrinter &P)
     : PDBSymDumper(false), Printer(P) {}
 

llvm/tools/llvm-pdbutil/PrettyClassDefinitionDumper.cpp

 //===- PrettyClassDefinitionDumper.cpp --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyClassDefinitionDumper.h"
 
-#include "LinePrinter.h"
 #include "PrettyClassLayoutGraphicalDumper.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"

llvm/tools/llvm-pdbutil/PrettyClassLayoutGraphicalDumper.cpp

 //===- PrettyClassLayoutGraphicalDumper.h -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyClassLayoutGraphicalDumper.h"
 
-#include "LinePrinter.h"
 #include "PrettyClassDefinitionDumper.h"
 #include "PrettyEnumDumper.h"
 #include "PrettyFunctionDumper.h"
 #include "PrettyTypedefDumper.h"
 #include "PrettyVariableDumper.h"
 #include "PrettyVariableDumper.h"
 #include "llvm-pdbutil.h"
 

llvm/tools/llvm-pdbutil/PrettyCompilandDumper.cpp

 //===- PrettyCompilandDumper.cpp - llvm-pdbutil compiland dumper -*- C++ *-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyCompilandDumper.h"
 
-#include "LinePrinter.h"
 #include "PrettyFunctionDumper.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
 #include "llvm/DebugInfo/PDB/PDBExtras.h"

llvm/tools/llvm-pdbutil/PrettyEnumDumper.cpp

 //===- PrettyEnumDumper.cpp -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyEnumDumper.h"
 
-#include "LinePrinter.h"
 #include "PrettyBuiltinDumper.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"

llvm/tools/llvm-pdbutil/PrettyExternalSymbolDumper.cpp

 //===- PrettyExternalSymbolDumper.cpp -------------------------- *- C++ *-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyExternalSymbolDumper.h"
-#include "LinePrinter.h"
 
 #include "llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
 #include "llvm/Support/Format.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 ExternalSymbolDumper::ExternalSymbolDumper(LinePrinter &P)

llvm/tools/llvm-pdbutil/PrettyFunctionDumper.cpp

 //===- PrettyFunctionDumper.cpp --------------------------------- *- C++ *-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyFunctionDumper.h"
-#include "LinePrinter.h"
 #include "PrettyBuiltinDumper.h"
 
 #include "llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/DebugInfo/PDB/PDBExtras.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"

llvm/tools/llvm-pdbutil/PrettyTypeDumper.cpp

 //===- PrettyTypeDumper.cpp - PDBSymDumper type dumper *------------ C++ *-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyTypeDumper.h"
 
-#include "LinePrinter.h"
 #include "PrettyBuiltinDumper.h"
 #include "PrettyClassDefinitionDumper.h"
 #include "PrettyEnumDumper.h"
 #include "PrettyFunctionDumper.h"
 #include "PrettyTypedefDumper.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/DebugInfo/PDB/ConcreteSymbolEnumerator.h"

llvm/tools/llvm-pdbutil/PrettyTypedefDumper.cpp

 //===- PrettyTypedefDumper.cpp - PDBSymDumper impl for typedefs -- * C++ *-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyTypedefDumper.h"
 
-#include "LinePrinter.h"
 #include "PrettyBuiltinDumper.h"
 #include "PrettyFunctionDumper.h"
 #include "PrettyTypeDumper.h"
 
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/DebugInfo/PDB/PDBExtras.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
 

llvm/tools/llvm-pdbutil/PrettyVariableDumper.cpp

 //===- PrettyVariableDumper.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "PrettyVariableDumper.h"
 
-#include "LinePrinter.h"
 #include "PrettyBuiltinDumper.h"
 #include "PrettyFunctionDumper.h"
 #include "llvm-pdbutil.h"
 
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"

llvm/tools/llvm-pdbutil/StreamUtil.cpp

 //===- StreamUtil.cpp - PDB stream utilities --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "StreamUtil.h"
-#include "FormatUtil.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleList.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Native/FormatUtil.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
 std::string StreamInfo::getLongName() const {

llvm/tools/llvm-pdbutil/TypeReferenceTracker.h

 //===- TypeReferenceTracker.h --------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVMPDBDUMP_TYPEREFERENCETRACKER_H
 #define LLVM_TOOLS_LLVMPDBDUMP_TYPEREFERENCETRACKER_H
 
-#include "InputFile.h"
-
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
+#include "llvm/DebugInfo/PDB/Native/InputFile.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace pdb {
 
 class TpiStream;
 
 /// Maintains bitvector to track whether a type was referenced by a symbol

llvm/tools/llvm-pdbutil/TypeReferenceTracker.cpp

 //===- TypeReferenceTracker.cpp ------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TypeReferenceTracker.h"
 
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
-#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
-#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
+#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
+#include "llvm/Object/COFF.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 using namespace llvm::codeview;
 
 // LazyRandomTypeCollection doesn't appear to expose the number of records, so
 // just iterate up front to find out.
 static uint32_t getNumRecordsInCollection(LazyRandomTypeCollection &Types) {

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

 //===- llvm-pdbutil.h ----------------------------------------- *- C++ --*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
 #define LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/DebugInfo/PDB/Native/LinePrinter.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <memory>
 #include <stdint.h>
 
 namespace llvm {
 namespace object {
enum class ModuleSubsection {
   CrossScopeExports,
   StringTable,
   Symbols,
   FrameData,
   CoffSymbolRVAs,
   All
 };
 
+extern FilterOptions Filters;
+
 namespace pretty {
 
 enum class ClassDefinitionFormat { None, Layout, All };
 enum class ClassSortMode {
   None,
   Name,
   Size,
   Padding,

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

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-pdbutil.h"
 
 #include "BytesOutputStyle.h"
 #include "DumpOutputStyle.h"
 #include "ExplainOutputStyle.h"
-#include "InputFile.h"
-#include "LinePrinter.h"
 #include "OutputStyle.h"
 #include "PrettyClassDefinitionDumper.h"
 #include "PrettyCompilandDumper.h"
 #include "PrettyEnumDumper.h"
 #include "PrettyExternalSymbolDumper.h"
 #include "PrettyFunctionDumper.h"
 #include "PrettyTypeDumper.h"
 #include "PrettyTypedefDumper.h"

 #include "llvm/DebugInfo/PDB/IPDBInjectedSource.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
 #include "llvm/DebugInfo/PDB/IPDBSession.h"
 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
+#include "llvm/DebugInfo/PDB/Native/InputFile.h"
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"

 static cl::opt<bool> Arrays("arrays", cl::desc("Dump array types"),
                             cl::sub(DiaDumpSubcommand));
 static cl::opt<bool> VTShapes("vtshapes", cl::desc("Dump virtual table shapes"),
                               cl::sub(DiaDumpSubcommand));
 static cl::opt<bool> Typedefs("typedefs", cl::desc("Dump typedefs"),
                               cl::sub(DiaDumpSubcommand));
 } // namespace diadump
 
+FilterOptions Filters;
+
 namespace pretty {
 cl::list<std::string> InputFilenames(cl::Positional,
                                      cl::desc("<input PDB files>"),
                                      cl::OneOrMore, cl::sub(PrettySubcommand));
 
 cl::opt<bool> InjectedSources("injected-sources",
                               cl::desc("Display injected sources"),
                               cl::cat(OtherOptions), cl::sub(PrettySubcommand));
static void dumpPretty(StringRef Path) {
 
   if (opts::pretty::LoadAddress)
     Session->setLoadAddress(opts::pretty::LoadAddress);
 
   auto &Stream = outs();
   const bool UseColor = opts::pretty::ColorOutput == cl::BOU_UNSET
                             ? Stream.has_colors()
                             : opts::pretty::ColorOutput == cl::BOU_TRUE;
-  LinePrinter Printer(2, UseColor, Stream);
+  LinePrinter Printer(2, UseColor, Stream, opts::Filters);
 
   auto GlobalScope(Session->getGlobalScope());
   if (!GlobalScope)
     return;
   std::string FileName(GlobalScope->getSymbolsFileName());
 
   WithColor(Printer, PDB_ColorItem::None).get() << "Summary for ";
   WithColor(Printer, PDB_ColorItem::Path).get() << FileName;
if (opts::pdb2yaml::DumpModuleSyms || opts::pdb2yaml::DumpModuleFiles)
       opts::pdb2yaml::DumpModules = true;
 
     if (opts::pdb2yaml::DumpModules)
       opts::pdb2yaml::DbiStream = true;
   }
 
   llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
 
+  // Initialize the filters for LinePrinter.
+  auto propagate = [&](auto &Target, auto &Reference) {
+    for (std::string &Option : Reference)
+      Target.push_back(Option);
+  };
+
+  propagate(opts::Filters.ExcludeTypes, opts::pretty::ExcludeTypes);
+  propagate(opts::Filters.ExcludeTypes, opts::pretty::ExcludeTypes);
+  propagate(opts::Filters.ExcludeSymbols, opts::pretty::ExcludeSymbols);
+  propagate(opts::Filters.ExcludeCompilands, opts::pretty::ExcludeCompilands);
+  propagate(opts::Filters.IncludeTypes, opts::pretty::IncludeTypes);
+  propagate(opts::Filters.IncludeSymbols, opts::pretty::IncludeSymbols);
+  propagate(opts::Filters.IncludeCompilands, opts::pretty::IncludeCompilands);
+  opts::Filters.PaddingThreshold = opts::pretty::PaddingThreshold;
+  opts::Filters.SizeThreshold = opts::pretty::SizeThreshold;
+  opts::Filters.JustMyCode = opts::dump::JustMyCode;
+  if (opts::dump::DumpModi.getNumOccurrences())
+    opts::Filters.DumpModi = opts::dump::DumpModi;
+
   if (opts::PdbToYamlSubcommand) {
     pdb2Yaml(opts::pdb2yaml::InputFilename.front());
   } else if (opts::YamlToPdbSubcommand) {
     if (opts::yaml2pdb::YamlPdbOutputFile.empty()) {
       SmallString<16> OutputFilename(opts::yaml2pdb::InputFilename.getValue());
       sys::path::replace_extension(OutputFilename, ".pdb");
       opts::yaml2pdb::YamlPdbOutputFile = std::string(OutputFilename.str());
     }
if (opts::PdbToYamlSubcommand) {
     }
 
     // When adding filters for excluded compilands and types, we need to
     // remember that these are regexes.  So special characters such as * and \
     // need to be escaped in the regex.  In the case of a literal \, this means
     // it needs to be escaped again in the C++.  So matching a single \ in the
     // input requires 4 \es in the C++.
     if (opts::pretty::ExcludeCompilerGenerated) {
-      opts::pretty::ExcludeTypes.push_back("__vc_attributes");
-      opts::pretty::ExcludeCompilands.push_back("\\* Linker \\*");
+      opts::Filters.ExcludeTypes.push_back("__vc_attributes");
+      opts::Filters.ExcludeCompilands.push_back("\\* Linker \\*");
     }
     if (opts::pretty::ExcludeSystemLibraries) {
-      opts::pretty::ExcludeCompilands.push_back(
+      opts::Filters.ExcludeCompilands.push_back(
           "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
-      opts::pretty::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
-      opts::pretty::ExcludeCompilands.push_back(
+      opts::Filters.ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
+      opts::Filters.ExcludeCompilands.push_back(
           "d:\\\\th.obj.x86fre\\\\minkernel");
     }
     llvm::for_each(opts::pretty::InputFilenames, dumpPretty);
   } else if (opts::DumpSubcommand) {
     llvm::for_each(opts::dump::InputFilenames, dumpRaw);
   } else if (opts::BytesSubcommand) {
     llvm::for_each(opts::bytes::InputFilenames, dumpBytes);
   } else if (opts::MergeSubcommand) {