contrib/llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp

   1 //===- llvm-pdbdump.cpp - Dump debug info from a PDB file -------*- 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 // Dumps debug information present in PDB files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm-pdbdump.h"
  15
  16 #include "Analyze.h"
  17 #include "Diff.h"
  18 #include "LLVMOutputStyle.h"
  19 #include "LinePrinter.h"
  20 #include "OutputStyle.h"
  21 #include "PrettyCompilandDumper.h"
  22 #include "PrettyExternalSymbolDumper.h"
  23 #include "PrettyFunctionDumper.h"
  24 #include "PrettyTypeDumper.h"
  25 #include "PrettyVariableDumper.h"
  26 #include "YAMLOutputStyle.h"
  27
  28 #include "llvm/ADT/ArrayRef.h"
  29 #include "llvm/ADT/BitVector.h"
  30 #include "llvm/ADT/DenseMap.h"
  31 #include "llvm/ADT/STLExtras.h"
  32 #include "llvm/ADT/StringExtras.h"
  33 #include "llvm/Config/config.h"
  34 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
  35 #include "llvm/DebugInfo/CodeView/ModuleDebugFileChecksumFragment.h"
  36 #include "llvm/DebugInfo/CodeView/ModuleDebugInlineeLinesFragment.h"
  37 #include "llvm/DebugInfo/CodeView/ModuleDebugLineFragment.h"
  38 #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
  39 #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
  40 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
  41 #include "llvm/DebugInfo/PDB/GenericError.h"
  42 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
  43 #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
  44 #include "llvm/DebugInfo/PDB/IPDBSession.h"
  45 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
  46 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
  47 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
  48 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
  49 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
  50 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
  51 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
  52 #include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
  53 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
  54 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
  55 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  56 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
  57 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
  58 #include "llvm/DebugInfo/PDB/PDB.h"
  59 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
  60 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
  61 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
  62 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
  63 #include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
  64 #include "llvm/Support/BinaryByteStream.h"
  65 #include "llvm/Support/COM.h"
  66 #include "llvm/Support/CommandLine.h"
  67 #include "llvm/Support/ConvertUTF.h"
  68 #include "llvm/Support/FileOutputBuffer.h"
  69 #include "llvm/Support/FileSystem.h"
  70 #include "llvm/Support/Format.h"
  71 #include "llvm/Support/ManagedStatic.h"
  72 #include "llvm/Support/MemoryBuffer.h"
  73 #include "llvm/Support/Path.h"
  74 #include "llvm/Support/PrettyStackTrace.h"
  75 #include "llvm/Support/Process.h"
  76 #include "llvm/Support/Regex.h"
  77 #include "llvm/Support/ScopedPrinter.h"
  78 #include "llvm/Support/Signals.h"
  79 #include "llvm/Support/raw_ostream.h"
  80
  81 using namespace llvm;
  82 using namespace llvm::codeview;
  83 using namespace llvm::msf;
  84 using namespace llvm::pdb;
  85
  86 namespace opts {
  87
  88 cl::SubCommand RawSubcommand("raw", "Dump raw structure of the PDB file");
  89 cl::SubCommand
  90     PrettySubcommand("pretty",
  91                      "Dump semantic information about types and symbols");
  92
  93 cl::SubCommand DiffSubcommand("diff", "Diff the contents of 2 PDB files");
  94
  95 cl::SubCommand
  96     YamlToPdbSubcommand("yaml2pdb",
  97                         "Generate a PDB file from a YAML description");
  98 cl::SubCommand
  99     PdbToYamlSubcommand("pdb2yaml",
 100                         "Generate a detailed YAML description of a PDB File");
 101
 102 cl::SubCommand
 103     AnalyzeSubcommand("analyze",
 104                       "Analyze various aspects of a PDB's structure");
 105
 106 cl::SubCommand MergeSubcommand("merge",
 107                                "Merge multiple PDBs into a single PDB");
 108
 109 cl::OptionCategory TypeCategory("Symbol Type Options");
 110 cl::OptionCategory FilterCategory("Filtering and Sorting Options");
 111 cl::OptionCategory OtherOptions("Other Options");
 112
 113 namespace pretty {
 114 cl::list<std::string> InputFilenames(cl::Positional,
 115                                      cl::desc("<input PDB files>"),
 116                                      cl::OneOrMore, cl::sub(PrettySubcommand));
 117
 118 cl::opt<bool> Compilands("compilands", cl::desc("Display compilands"),
 119                          cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 120 cl::opt<bool> Symbols("module-syms",
 121                       cl::desc("Display symbols for each compiland"),
 122                       cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 123 cl::opt<bool> Globals("globals", cl::desc("Dump global symbols"),
 124                       cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 125 cl::opt<bool> Externals("externals", cl::desc("Dump external symbols"),
 126                         cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 127 cl::list<SymLevel> SymTypes(
 128     "sym-types", cl::desc("Type of symbols to dump (default all)"),
 129     cl::cat(TypeCategory), cl::sub(PrettySubcommand), cl::ZeroOrMore,
 130     cl::values(
 131         clEnumValN(SymLevel::Thunks, "thunks", "Display thunk symbols"),
 132         clEnumValN(SymLevel::Data, "data", "Display data symbols"),
 133         clEnumValN(SymLevel::Functions, "funcs", "Display function symbols"),
 134         clEnumValN(SymLevel::All, "all", "Display all symbols (default)")));
 135
 136 cl::opt<bool>
 137     Types("types",
 138           cl::desc("Display all types (implies -classes, -enums, -typedefs)"),
 139           cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 140 cl::opt<bool> Classes("classes", cl::desc("Display class types"),
 141                       cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 142 cl::opt<bool> Enums("enums", cl::desc("Display enum types"),
 143                     cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 144 cl::opt<bool> Typedefs("typedefs", cl::desc("Display typedef types"),
 145                        cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 146 cl::opt<SymbolSortMode> SymbolOrder(
 147     "symbol-order", cl::desc("symbol sort order"),
 148     cl::init(SymbolSortMode::None),
 149     cl::values(clEnumValN(SymbolSortMode::None, "none",
 150                           "Undefined / no particular sort order"),
 151                clEnumValN(SymbolSortMode::Name, "name", "Sort symbols by name"),
 152                clEnumValN(SymbolSortMode::Size, "size",
 153                           "Sort symbols by size")),
 154     cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 155
 156 cl::opt<ClassSortMode> ClassOrder(
 157     "class-order", cl::desc("Class sort order"), cl::init(ClassSortMode::None),
 158     cl::values(
 159         clEnumValN(ClassSortMode::None, "none",
 160                    "Undefined / no particular sort order"),
 161         clEnumValN(ClassSortMode::Name, "name", "Sort classes by name"),
 162         clEnumValN(ClassSortMode::Size, "size", "Sort classes by size"),
 163         clEnumValN(ClassSortMode::Padding, "padding",
 164                    "Sort classes by amount of padding"),
 165         clEnumValN(ClassSortMode::PaddingPct, "padding-pct",
 166                    "Sort classes by percentage of space consumed by padding"),
 167         clEnumValN(ClassSortMode::PaddingImmediate, "padding-imm",
 168                    "Sort classes by amount of immediate padding"),
 169         clEnumValN(ClassSortMode::PaddingPctImmediate, "padding-pct-imm",
 170                    "Sort classes by percentage of space consumed by immediate "
 171                    "padding")),
 172     cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 173
 174 cl::opt<ClassDefinitionFormat> ClassFormat(
 175     "class-definitions", cl::desc("Class definition format"),
 176     cl::init(ClassDefinitionFormat::All),
 177     cl::values(
 178         clEnumValN(ClassDefinitionFormat::All, "all",
 179                    "Display all class members including data, constants, "
 180                    "typedefs, functions, etc"),
 181         clEnumValN(ClassDefinitionFormat::Layout, "layout",
 182                    "Only display members that contribute to class size."),
 183         clEnumValN(ClassDefinitionFormat::None, "none",
 184                    "Don't display class definitions")),
 185     cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 186 cl::opt<uint32_t> ClassRecursionDepth(
 187     "class-recurse-depth", cl::desc("Class recursion depth (0=no limit)"),
 188     cl::init(0), cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 189
 190 cl::opt<bool> Lines("lines", cl::desc("Line tables"), cl::cat(TypeCategory),
 191                     cl::sub(PrettySubcommand));
 192 cl::opt<bool>
 193     All("all", cl::desc("Implies all other options in 'Symbol Types' category"),
 194         cl::cat(TypeCategory), cl::sub(PrettySubcommand));
 195
 196 cl::opt<uint64_t> LoadAddress(
 197     "load-address",
 198     cl::desc("Assume the module is loaded at the specified address"),
 199     cl::cat(OtherOptions), cl::sub(PrettySubcommand));
 200 cl::opt<bool> Native("native", cl::desc("Use native PDB reader instead of DIA"),
 201                      cl::cat(OtherOptions), cl::sub(PrettySubcommand));
 202 cl::opt<cl::boolOrDefault>
 203     ColorOutput("color-output",
 204                 cl::desc("Override use of color (default = isatty)"),
 205                 cl::cat(OtherOptions), cl::sub(PrettySubcommand));
 206 cl::list<std::string> ExcludeTypes(
 207     "exclude-types", cl::desc("Exclude types by regular expression"),
 208     cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 209 cl::list<std::string> ExcludeSymbols(
 210     "exclude-symbols", cl::desc("Exclude symbols by regular expression"),
 211     cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 212 cl::list<std::string> ExcludeCompilands(
 213     "exclude-compilands", cl::desc("Exclude compilands by regular expression"),
 214     cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 215
 216 cl::list<std::string> IncludeTypes(
 217     "include-types",
 218     cl::desc("Include only types which match a regular expression"),
 219     cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 220 cl::list<std::string> IncludeSymbols(
 221     "include-symbols",
 222     cl::desc("Include only symbols which match a regular expression"),
 223     cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 224 cl::list<std::string> IncludeCompilands(
 225     "include-compilands",
 226     cl::desc("Include only compilands those which match a regular expression"),
 227     cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 228 cl::opt<uint32_t> SizeThreshold(
 229     "min-type-size", cl::desc("Displays only those types which are greater "
 230                               "than or equal to the specified size."),
 231     cl::init(0), cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 232 cl::opt<uint32_t> PaddingThreshold(
 233     "min-class-padding", cl::desc("Displays only those classes which have at "
 234                                   "least the specified amount of padding."),
 235     cl::init(0), cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 236 cl::opt<uint32_t> ImmediatePaddingThreshold(
 237     "min-class-padding-imm",
 238     cl::desc("Displays only those classes which have at least the specified "
 239              "amount of immediate padding, ignoring padding internal to bases "
 240              "and aggregates."),
 241     cl::init(0), cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 242
 243 cl::opt<bool> ExcludeCompilerGenerated(
 244     "no-compiler-generated",
 245     cl::desc("Don't show compiler generated types and symbols"),
 246     cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 247 cl::opt<bool>
 248     ExcludeSystemLibraries("no-system-libs",
 249                            cl::desc("Don't show symbols from system libraries"),
 250                            cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 251
 252 cl::opt<bool> NoEnumDefs("no-enum-definitions",
 253                          cl::desc("Don't display full enum definitions"),
 254                          cl::cat(FilterCategory), cl::sub(PrettySubcommand));
 255 }
 256
 257 namespace diff {
 258 cl::opt<bool> Pedantic("pedantic",
 259                        cl::desc("Finds all differences (even structural ones "
 260                                 "that produce otherwise identical PDBs)"),
 261                        cl::sub(DiffSubcommand));
 262
 263 cl::list<std::string> InputFilenames(cl::Positional,
 264                                      cl::desc("<first> <second>"),
 265                                      cl::OneOrMore, cl::sub(DiffSubcommand));
 266 }
 267
 268 namespace raw {
 269
 270 cl::OptionCategory MsfOptions("MSF Container Options");
 271 cl::OptionCategory TypeOptions("Type Record Options");
 272 cl::OptionCategory FileOptions("Module & File Options");
 273 cl::OptionCategory SymbolOptions("Symbol Options");
 274 cl::OptionCategory MiscOptions("Miscellaneous Options");
 275
 276 // MSF OPTIONS
 277 cl::opt<bool> DumpHeaders("headers", cl::desc("dump PDB headers"),
 278                           cl::cat(MsfOptions), cl::sub(RawSubcommand));
 279 cl::opt<bool> DumpStreamBlocks("stream-blocks",
 280                                cl::desc("dump PDB stream blocks"),
 281                                cl::cat(MsfOptions), cl::sub(RawSubcommand));
 282 cl::opt<bool> DumpStreamSummary("stream-summary",
 283                                 cl::desc("dump summary of the PDB streams"),
 284                                 cl::cat(MsfOptions), cl::sub(RawSubcommand));
 285 cl::opt<bool> DumpPageStats(
 286     "page-stats",
 287     cl::desc("dump allocation stats of the pages in the MSF file"),
 288     cl::cat(MsfOptions), cl::sub(RawSubcommand));
 289 cl::opt<std::string>
 290     DumpBlockRangeOpt("block-data", cl::value_desc("start[-end]"),
 291                       cl::desc("Dump binary data from specified range."),
 292                       cl::cat(MsfOptions), cl::sub(RawSubcommand));
 293 llvm::Optional<BlockRange> DumpBlockRange;
 294
 295 cl::list<std::string>
 296     DumpStreamData("stream-data", cl::CommaSeparated, cl::ZeroOrMore,
 297                    cl::desc("Dump binary data from specified streams.  Format "
 298                             "is SN[:Start][@Size]"),
 299                    cl::cat(MsfOptions), cl::sub(RawSubcommand));
 300
 301 // TYPE OPTIONS
 302 cl::opt<bool>
 303     CompactRecords("compact-records",
 304                    cl::desc("Dump type and symbol records with less detail"),
 305                    cl::cat(TypeOptions), cl::sub(RawSubcommand));
 306
 307 cl::opt<bool>
 308     DumpTpiRecords("tpi-records",
 309                    cl::desc("dump CodeView type records from TPI stream"),
 310                    cl::cat(TypeOptions), cl::sub(RawSubcommand));
 311 cl::opt<bool> DumpTpiRecordBytes(
 312     "tpi-record-bytes",
 313     cl::desc("dump CodeView type record raw bytes from TPI stream"),
 314     cl::cat(TypeOptions), cl::sub(RawSubcommand));
 315 cl::opt<bool> DumpTpiHash("tpi-hash", cl::desc("dump CodeView TPI hash stream"),
 316                           cl::cat(TypeOptions), cl::sub(RawSubcommand));
 317 cl::opt<bool>
 318     DumpIpiRecords("ipi-records",
 319                    cl::desc("dump CodeView type records from IPI stream"),
 320                    cl::cat(TypeOptions), cl::sub(RawSubcommand));
 321 cl::opt<bool> DumpIpiRecordBytes(
 322     "ipi-record-bytes",
 323     cl::desc("dump CodeView type record raw bytes from IPI stream"),
 324     cl::cat(TypeOptions), cl::sub(RawSubcommand));
 325
 326 // MODULE & FILE OPTIONS
 327 cl::opt<bool> DumpModules("modules", cl::desc("dump compiland information"),
 328                           cl::cat(FileOptions), cl::sub(RawSubcommand));
 329 cl::opt<bool> DumpModuleFiles("module-files", cl::desc("dump file information"),
 330                               cl::cat(FileOptions), cl::sub(RawSubcommand));
 331 cl::opt<bool> DumpLineInfo("line-info",
 332                            cl::desc("dump file and line information"),
 333                            cl::cat(FileOptions), cl::sub(RawSubcommand));
 334
 335 // SYMBOL OPTIONS
 336 cl::opt<bool> DumpGlobals("globals", cl::desc("dump globals stream data"),
 337                           cl::cat(SymbolOptions), cl::sub(RawSubcommand));
 338 cl::opt<bool> DumpModuleSyms("module-syms", cl::desc("dump module symbols"),
 339                              cl::cat(SymbolOptions), cl::sub(RawSubcommand));
 340 cl::opt<bool> DumpPublics("publics", cl::desc("dump Publics stream data"),
 341                           cl::cat(SymbolOptions), cl::sub(RawSubcommand));
 342 cl::opt<bool>
 343     DumpSymRecordBytes("sym-record-bytes",
 344                        cl::desc("dump CodeView symbol record raw bytes"),
 345                        cl::cat(SymbolOptions), cl::sub(RawSubcommand));
 346
 347 // MISCELLANEOUS OPTIONS
 348 cl::opt<bool> DumpStringTable("string-table", cl::desc("dump PDB String Table"),
 349                               cl::cat(MiscOptions), cl::sub(RawSubcommand));
 350
 351 cl::opt<bool> DumpSectionContribs("section-contribs",
 352                                   cl::desc("dump section contributions"),
 353                                   cl::cat(MiscOptions), cl::sub(RawSubcommand));
 354 cl::opt<bool> DumpSectionMap("section-map", cl::desc("dump section map"),
 355                              cl::cat(MiscOptions), cl::sub(RawSubcommand));
 356 cl::opt<bool> DumpSectionHeaders("section-headers",
 357                                  cl::desc("dump section headers"),
 358                                  cl::cat(MiscOptions), cl::sub(RawSubcommand));
 359 cl::opt<bool> DumpFpo("fpo", cl::desc("dump FPO records"), cl::cat(MiscOptions),
 360                       cl::sub(RawSubcommand));
 361
 362 cl::opt<bool> RawAll("all", cl::desc("Implies most other options."),
 363                      cl::cat(MiscOptions), cl::sub(RawSubcommand));
 364
 365 cl::list<std::string> InputFilenames(cl::Positional,
 366                                      cl::desc("<input PDB files>"),
 367                                      cl::OneOrMore, cl::sub(RawSubcommand));
 368 }
 369
 370 namespace yaml2pdb {
 371 cl::opt<std::string>
 372     YamlPdbOutputFile("pdb", cl::desc("the name of the PDB file to write"),
 373                       cl::sub(YamlToPdbSubcommand));
 374
 375 cl::opt<std::string> InputFilename(cl::Positional,
 376                                    cl::desc("<input YAML file>"), cl::Required,
 377                                    cl::sub(YamlToPdbSubcommand));
 378 }
 379
 380 namespace pdb2yaml {
 381 cl::opt<bool> All("all",
 382                   cl::desc("Dump everything we know how to dump."),
 383                   cl::sub(PdbToYamlSubcommand), cl::init(false));
 384 cl::opt<bool>
 385     NoFileHeaders("no-file-headers",
 386                   cl::desc("Do not dump MSF file headers (you will not be able "
 387                            "to generate a fresh PDB from the resulting YAML)"),
 388                   cl::sub(PdbToYamlSubcommand), cl::init(false));
 389 cl::opt<bool> Minimal("minimal",
 390                       cl::desc("Don't write fields with default values"),
 391                       cl::sub(PdbToYamlSubcommand), cl::init(false));
 392
 393 cl::opt<bool> StreamMetadata(
 394     "stream-metadata",
 395     cl::desc("Dump the number of streams and each stream's size"),
 396     cl::sub(PdbToYamlSubcommand), cl::init(false));
 397 cl::opt<bool> StreamDirectory(
 398     "stream-directory",
 399     cl::desc("Dump each stream's block map (implies -stream-metadata)"),
 400     cl::sub(PdbToYamlSubcommand), cl::init(false));
 401 cl::opt<bool> PdbStream("pdb-stream",
 402                         cl::desc("Dump the PDB Stream (Stream 1)"),
 403                         cl::sub(PdbToYamlSubcommand), cl::init(false));
 404
 405 cl::opt<bool> StringTable("string-table", cl::desc("Dump the PDB String Table"),
 406                           cl::sub(PdbToYamlSubcommand), cl::init(false));
 407
 408 cl::opt<bool> DbiStream("dbi-stream",
 409                         cl::desc("Dump the DBI Stream (Stream 2)"),
 410                         cl::sub(PdbToYamlSubcommand), cl::init(false));
 411 cl::opt<bool>
 412     DbiModuleInfo("dbi-module-info",
 413                   cl::desc("Dump DBI Module Information (implies -dbi-stream)"),
 414                   cl::sub(PdbToYamlSubcommand), cl::init(false));
 415
 416 cl::opt<bool> DbiModuleSyms(
 417     "dbi-module-syms",
 418     cl::desc("Dump DBI Module Information (implies -dbi-module-info)"),
 419     cl::sub(PdbToYamlSubcommand), cl::init(false));
 420
 421 cl::opt<bool> DbiModuleSourceFileInfo(
 422     "dbi-module-source-info",
 423     cl::desc(
 424         "Dump DBI Module Source File Information (implies -dbi-module-info)"),
 425     cl::sub(PdbToYamlSubcommand), cl::init(false));
 426
 427 cl::opt<bool>
 428     DbiModuleSourceLineInfo("dbi-module-lines",
 429                             cl::desc("Dump DBI Module Source Line Information "
 430                                      "(implies -dbi-module-source-info)"),
 431                             cl::sub(PdbToYamlSubcommand), cl::init(false));
 432
 433 cl::opt<bool> TpiStream("tpi-stream",
 434                         cl::desc("Dump the TPI Stream (Stream 3)"),
 435                         cl::sub(PdbToYamlSubcommand), cl::init(false));
 436
 437 cl::opt<bool> IpiStream("ipi-stream",
 438                         cl::desc("Dump the IPI Stream (Stream 5)"),
 439                         cl::sub(PdbToYamlSubcommand), cl::init(false));
 440
 441 cl::list<std::string> InputFilename(cl::Positional,
 442                                     cl::desc("<input PDB file>"), cl::Required,
 443                                     cl::sub(PdbToYamlSubcommand));
 444 }
 445
 446 namespace analyze {
 447 cl::opt<bool> StringTable("hash-collisions", cl::desc("Find hash collisions"),
 448                           cl::sub(AnalyzeSubcommand), cl::init(false));
 449 cl::list<std::string> InputFilename(cl::Positional,
 450                                     cl::desc("<input PDB file>"), cl::Required,
 451                                     cl::sub(AnalyzeSubcommand));
 452 }
 453
 454 namespace merge {
 455 cl::list<std::string> InputFilenames(cl::Positional,
 456                                      cl::desc("<input PDB files>"),
 457                                      cl::OneOrMore, cl::sub(MergeSubcommand));
 458 cl::opt<std::string>
 459     PdbOutputFile("pdb", cl::desc("the name of the PDB file to write"),
 460                   cl::sub(MergeSubcommand));
 461 }
 462 }
 463
 464 static ExitOnError ExitOnErr;
 465
 466 static void yamlToPdb(StringRef Path) {
 467   BumpPtrAllocator Allocator;
 468   ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
 469       MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
 470                                    /*RequiresNullTerminator=*/false);
 471
 472   if (ErrorOrBuffer.getError()) {
 473     ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path, Path));
 474   }
 475
 476   std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
 477
 478   llvm::yaml::Input In(Buffer->getBuffer());
 479   pdb::yaml::PdbObject YamlObj(Allocator);
 480   In >> YamlObj;
 481
 482   PDBFileBuilder Builder(Allocator);
 483
 484   uint32_t BlockSize = 4096;
 485   if (YamlObj.Headers.hasValue())
 486     BlockSize = YamlObj.Headers->SuperBlock.BlockSize;
 487   ExitOnErr(Builder.initialize(BlockSize));
 488   // Add each of the reserved streams.  We ignore stream metadata in the
 489   // yaml, because we will reconstruct our own view of the streams.  For
 490   // example, the YAML may say that there were 20 streams in the original
 491   // PDB, but maybe we only dump a subset of those 20 streams, so we will
 492   // have fewer, and the ones we do have may end up with different indices
 493   // than the ones in the original PDB.  So we just start with a clean slate.
 494   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)
 495     ExitOnErr(Builder.getMsfBuilder().addStream(0));
 496
 497   if (YamlObj.StringTable.hasValue()) {
 498     auto &Strings = Builder.getStringTableBuilder();
 499     for (auto S : *YamlObj.StringTable)
 500       Strings.insert(S);
 501   }
 502
 503   pdb::yaml::PdbInfoStream DefaultInfoStream;
 504   pdb::yaml::PdbDbiStream DefaultDbiStream;
 505   pdb::yaml::PdbTpiStream DefaultTpiStream;
 506   pdb::yaml::PdbTpiStream DefaultIpiStream;
 507
 508   const auto &Info = YamlObj.PdbStream.getValueOr(DefaultInfoStream);
 509
 510   auto &InfoBuilder = Builder.getInfoBuilder();
 511   InfoBuilder.setAge(Info.Age);
 512   InfoBuilder.setGuid(Info.Guid);
 513   InfoBuilder.setSignature(Info.Signature);
 514   InfoBuilder.setVersion(Info.Version);
 515   for (auto F : Info.Features)
 516     InfoBuilder.addFeature(F);
 517
 518   auto &Strings = Builder.getStringTableBuilder().getStrings();
 519
 520   const auto &Dbi = YamlObj.DbiStream.getValueOr(DefaultDbiStream);
 521   auto &DbiBuilder = Builder.getDbiBuilder();
 522   DbiBuilder.setAge(Dbi.Age);
 523   DbiBuilder.setBuildNumber(Dbi.BuildNumber);
 524   DbiBuilder.setFlags(Dbi.Flags);
 525   DbiBuilder.setMachineType(Dbi.MachineType);
 526   DbiBuilder.setPdbDllRbld(Dbi.PdbDllRbld);
 527   DbiBuilder.setPdbDllVersion(Dbi.PdbDllVersion);
 528   DbiBuilder.setVersionHeader(Dbi.VerHeader);
 529   for (const auto &MI : Dbi.ModInfos) {
 530     auto &ModiBuilder = ExitOnErr(DbiBuilder.addModuleInfo(MI.Mod));
 531     ModiBuilder.setObjFileName(MI.Obj);
 532
 533     for (auto S : MI.SourceFiles)
 534       ExitOnErr(DbiBuilder.addModuleSourceFile(MI.Mod, S));
 535     if (MI.Modi.hasValue()) {
 536       const auto &ModiStream = *MI.Modi;
 537       for (auto Symbol : ModiStream.Symbols)
 538         ModiBuilder.addSymbol(Symbol.Record);
 539     }
 540     if (MI.FileLineInfo.hasValue()) {
 541       const auto &FLI = *MI.FileLineInfo;
 542
 543       // File Checksums must be emitted before line information, because line
 544       // info records use offsets into the checksum buffer to reference a file's
 545       // source file name.
 546       auto Checksums =
 547           llvm::make_unique<ModuleDebugFileChecksumFragment>(Strings);
 548       auto &ChecksumRef = *Checksums;
 549       if (!FLI.FileChecksums.empty()) {
 550         for (auto &FC : FLI.FileChecksums)
 551           Checksums->addChecksum(FC.FileName, FC.Kind, FC.ChecksumBytes.Bytes);
 552       }
 553       ModiBuilder.setC13FileChecksums(std::move(Checksums));
 554
 555       for (const auto &Fragment : FLI.LineFragments) {
 556         auto Lines =
 557             llvm::make_unique<ModuleDebugLineFragment>(ChecksumRef, Strings);
 558         Lines->setCodeSize(Fragment.CodeSize);
 559         Lines->setRelocationAddress(Fragment.RelocSegment,
 560                                     Fragment.RelocOffset);
 561         Lines->setFlags(Fragment.Flags);
 562         for (const auto &LC : Fragment.Blocks) {
 563           Lines->createBlock(LC.FileName);
 564           if (Lines->hasColumnInfo()) {
 565             for (const auto &Item : zip(LC.Lines, LC.Columns)) {
 566               auto &L = std::get<0>(Item);
 567               auto &C = std::get<1>(Item);
 568               uint32_t LE = L.LineStart + L.EndDelta;
 569               Lines->addLineAndColumnInfo(
 570                   L.Offset, LineInfo(L.LineStart, LE, L.IsStatement),
 571                   C.StartColumn, C.EndColumn);
 572             }
 573           } else {
 574             for (const auto &L : LC.Lines) {
 575               uint32_t LE = L.LineStart + L.EndDelta;
 576               Lines->addLineInfo(L.Offset,
 577                                  LineInfo(L.LineStart, LE, L.IsStatement));
 578             }
 579           }
 580         }
 581         ModiBuilder.addC13Fragment(std::move(Lines));
 582       }
 583
 584       for (const auto &Inlinee : FLI.Inlinees) {
 585         auto Inlinees = llvm::make_unique<ModuleDebugInlineeLineFragment>(
 586             ChecksumRef, Inlinee.HasExtraFiles);
 587         for (const auto &Site : Inlinee.Sites) {
 588           Inlinees->addInlineSite(Site.Inlinee, Site.FileName,
 589                                   Site.SourceLineNum);
 590           if (!Inlinee.HasExtraFiles)
 591             continue;
 592
 593           for (auto EF : Site.ExtraFiles) {
 594             Inlinees->addExtraFile(EF);
 595           }
 596         }
 597         ModiBuilder.addC13Fragment(std::move(Inlinees));
 598       }
 599     }
 600   }
 601
 602   auto &TpiBuilder = Builder.getTpiBuilder();
 603   const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);
 604   TpiBuilder.setVersionHeader(Tpi.Version);
 605   for (const auto &R : Tpi.Records)
 606     TpiBuilder.addTypeRecord(R.Record.data(), R.Record.Hash);
 607
 608   const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream);
 609   auto &IpiBuilder = Builder.getIpiBuilder();
 610   IpiBuilder.setVersionHeader(Ipi.Version);
 611   for (const auto &R : Ipi.Records)
 612     IpiBuilder.addTypeRecord(R.Record.data(), R.Record.Hash);
 613
 614   ExitOnErr(Builder.commit(opts::yaml2pdb::YamlPdbOutputFile));
 615 }
 616
 617 static PDBFile &loadPDB(StringRef Path, std::unique_ptr<IPDBSession> &Session) {
 618   ExitOnErr(loadDataForPDB(PDB_ReaderType::Native, Path, Session));
 619
 620   NativeSession *NS = static_cast<NativeSession *>(Session.get());
 621   return NS->getPDBFile();
 622 }
 623
 624 static void pdb2Yaml(StringRef Path) {
 625   std::unique_ptr<IPDBSession> Session;
 626   auto &File = loadPDB(Path, Session);
 627
 628   auto O = llvm::make_unique<YAMLOutputStyle>(File);
 629   O = llvm::make_unique<YAMLOutputStyle>(File);
 630
 631   ExitOnErr(O->dump());
 632 }
 633
 634 static void dumpRaw(StringRef Path) {
 635   std::unique_ptr<IPDBSession> Session;
 636   auto &File = loadPDB(Path, Session);
 637
 638   auto O = llvm::make_unique<LLVMOutputStyle>(File);
 639
 640   ExitOnErr(O->dump());
 641 }
 642
 643 static void dumpAnalysis(StringRef Path) {
 644   std::unique_ptr<IPDBSession> Session;
 645   auto &File = loadPDB(Path, Session);
 646   auto O = llvm::make_unique<AnalysisStyle>(File);
 647
 648   ExitOnErr(O->dump());
 649 }
 650
 651 static void diff(StringRef Path1, StringRef Path2) {
 652   std::unique_ptr<IPDBSession> Session1;
 653   std::unique_ptr<IPDBSession> Session2;
 654
 655   auto &File1 = loadPDB(Path1, Session1);
 656   auto &File2 = loadPDB(Path2, Session2);
 657
 658   auto O = llvm::make_unique<DiffStyle>(File1, File2);
 659
 660   ExitOnErr(O->dump());
 661 }
 662
 663 bool opts::pretty::shouldDumpSymLevel(SymLevel Search) {
 664   if (SymTypes.empty())
 665     return true;
 666   if (llvm::find(SymTypes, Search) != SymTypes.end())
 667     return true;
 668   if (llvm::find(SymTypes, SymLevel::All) != SymTypes.end())
 669     return true;
 670   return false;
 671 }
 672
 673 uint32_t llvm::pdb::getTypeLength(const PDBSymbolData &Symbol) {
 674   auto SymbolType = Symbol.getType();
 675   const IPDBRawSymbol &RawType = SymbolType->getRawSymbol();
 676
 677   return RawType.getLength();
 678 }
 679
 680 bool opts::pretty::compareFunctionSymbols(
 681     const std::unique_ptr<PDBSymbolFunc> &F1,
 682     const std::unique_ptr<PDBSymbolFunc> &F2) {
 683   assert(opts::pretty::SymbolOrder != opts::pretty::SymbolSortMode::None);
 684
 685   if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::Name)
 686     return F1->getName() < F2->getName();
 687
 688   // Note that we intentionally sort in descending order on length, since
 689   // long functions are more interesting than short functions.
 690   return F1->getLength() > F2->getLength();
 691 }
 692
 693 bool opts::pretty::compareDataSymbols(
 694     const std::unique_ptr<PDBSymbolData> &F1,
 695     const std::unique_ptr<PDBSymbolData> &F2) {
 696   assert(opts::pretty::SymbolOrder != opts::pretty::SymbolSortMode::None);
 697
 698   if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::Name)
 699     return F1->getName() < F2->getName();
 700
 701   // Note that we intentionally sort in descending order on length, since
 702   // large types are more interesting than short ones.
 703   return getTypeLength(*F1) > getTypeLength(*F2);
 704 }
 705
 706 static void dumpPretty(StringRef Path) {
 707   std::unique_ptr<IPDBSession> Session;
 708
 709   const auto ReaderType =
 710       opts::pretty::Native ? PDB_ReaderType::Native : PDB_ReaderType::DIA;
 711   ExitOnErr(loadDataForPDB(ReaderType, Path, Session));
 712
 713   if (opts::pretty::LoadAddress)
 714     Session->setLoadAddress(opts::pretty::LoadAddress);
 715
 716   auto &Stream = outs();
 717   const bool UseColor = opts::pretty::ColorOutput == cl::BOU_UNSET
 718                             ? Stream.has_colors()
 719                             : opts::pretty::ColorOutput == cl::BOU_TRUE;
 720   LinePrinter Printer(2, UseColor, Stream);
 721
 722   auto GlobalScope(Session->getGlobalScope());
 723   std::string FileName(GlobalScope->getSymbolsFileName());
 724
 725   WithColor(Printer, PDB_ColorItem::None).get() << "Summary for ";
 726   WithColor(Printer, PDB_ColorItem::Path).get() << FileName;
 727   Printer.Indent();
 728   uint64_t FileSize = 0;
 729
 730   Printer.NewLine();
 731   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Size";
 732   if (!sys::fs::file_size(FileName, FileSize)) {
 733     Printer << ": " << FileSize << " bytes";
 734   } else {
 735     Printer << ": (Unable to obtain file size)";
 736   }
 737
 738   Printer.NewLine();
 739   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Guid";
 740   Printer << ": " << GlobalScope->getGuid();
 741
 742   Printer.NewLine();
 743   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Age";
 744   Printer << ": " << GlobalScope->getAge();
 745
 746   Printer.NewLine();
 747   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Attributes";
 748   Printer << ": ";
 749   if (GlobalScope->hasCTypes())
 750     outs() << "HasCTypes ";
 751   if (GlobalScope->hasPrivateSymbols())
 752     outs() << "HasPrivateSymbols ";
 753   Printer.Unindent();
 754
 755   if (opts::pretty::Compilands) {
 756     Printer.NewLine();
 757     WithColor(Printer, PDB_ColorItem::SectionHeader).get()
 758         << "---COMPILANDS---";
 759     Printer.Indent();
 760     auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
 761     CompilandDumper Dumper(Printer);
 762     CompilandDumpFlags options = CompilandDumper::Flags::None;
 763     if (opts::pretty::Lines)
 764       options = options | CompilandDumper::Flags::Lines;
 765     while (auto Compiland = Compilands->getNext())
 766       Dumper.start(*Compiland, options);
 767     Printer.Unindent();
 768   }
 769
 770   if (opts::pretty::Classes || opts::pretty::Enums || opts::pretty::Typedefs) {
 771     Printer.NewLine();
 772     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---TYPES---";
 773     Printer.Indent();
 774     TypeDumper Dumper(Printer);
 775     Dumper.start(*GlobalScope);
 776     Printer.Unindent();
 777   }
 778
 779   if (opts::pretty::Symbols) {
 780     Printer.NewLine();
 781     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---SYMBOLS---";
 782     Printer.Indent();
 783     auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
 784     CompilandDumper Dumper(Printer);
 785     while (auto Compiland = Compilands->getNext())
 786       Dumper.start(*Compiland, true);
 787     Printer.Unindent();
 788   }
 789
 790   if (opts::pretty::Globals) {
 791     Printer.NewLine();
 792     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---GLOBALS---";
 793     Printer.Indent();
 794     if (shouldDumpSymLevel(opts::pretty::SymLevel::Functions)) {
 795       FunctionDumper Dumper(Printer);
 796       auto Functions = GlobalScope->findAllChildren<PDBSymbolFunc>();
 797       if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
 798         while (auto Function = Functions->getNext()) {
 799           Printer.NewLine();
 800           Dumper.start(*Function, FunctionDumper::PointerType::None);
 801         }
 802       } else {
 803         std::vector<std::unique_ptr<PDBSymbolFunc>> Funcs;
 804         while (auto Func = Functions->getNext())
 805           Funcs.push_back(std::move(Func));
 806         std::sort(Funcs.begin(), Funcs.end(),
 807                   opts::pretty::compareFunctionSymbols);
 808         for (const auto &Func : Funcs) {
 809           Printer.NewLine();
 810           Dumper.start(*Func, FunctionDumper::PointerType::None);
 811         }
 812       }
 813     }
 814     if (shouldDumpSymLevel(opts::pretty::SymLevel::Data)) {
 815       auto Vars = GlobalScope->findAllChildren<PDBSymbolData>();
 816       VariableDumper Dumper(Printer);
 817       if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
 818         while (auto Var = Vars->getNext())
 819           Dumper.start(*Var);
 820       } else {
 821         std::vector<std::unique_ptr<PDBSymbolData>> Datas;
 822         while (auto Var = Vars->getNext())
 823           Datas.push_back(std::move(Var));
 824         std::sort(Datas.begin(), Datas.end(), opts::pretty::compareDataSymbols);
 825         for (const auto &Var : Datas)
 826           Dumper.start(*Var);
 827       }
 828     }
 829     if (shouldDumpSymLevel(opts::pretty::SymLevel::Thunks)) {
 830       auto Thunks = GlobalScope->findAllChildren<PDBSymbolThunk>();
 831       CompilandDumper Dumper(Printer);
 832       while (auto Thunk = Thunks->getNext())
 833         Dumper.dump(*Thunk);
 834     }
 835     Printer.Unindent();
 836   }
 837   if (opts::pretty::Externals) {
 838     Printer.NewLine();
 839     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---EXTERNALS---";
 840     Printer.Indent();
 841     ExternalSymbolDumper Dumper(Printer);
 842     Dumper.start(*GlobalScope);
 843   }
 844   if (opts::pretty::Lines) {
 845     Printer.NewLine();
 846   }
 847   outs().flush();
 848 }
 849
 850 static void mergePdbs() {
 851   BumpPtrAllocator Allocator;
 852   TypeTableBuilder MergedTpi(Allocator);
 853   TypeTableBuilder MergedIpi(Allocator);
 854
 855   // Create a Tpi and Ipi type table with all types from all input files.
 856   for (const auto &Path : opts::merge::InputFilenames) {
 857     std::unique_ptr<IPDBSession> Session;
 858     auto &File = loadPDB(Path, Session);
 859     SmallVector<TypeIndex, 128> TypeMap;
 860     SmallVector<TypeIndex, 128> IdMap;
 861     if (File.hasPDBTpiStream()) {
 862       auto &Tpi = ExitOnErr(File.getPDBTpiStream());
 863       ExitOnErr(codeview::mergeTypeRecords(MergedTpi, TypeMap, nullptr,
 864                                            Tpi.typeArray()));
 865     }
 866     if (File.hasPDBIpiStream()) {
 867       auto &Ipi = ExitOnErr(File.getPDBIpiStream());
 868       ExitOnErr(codeview::mergeIdRecords(MergedIpi, TypeMap, IdMap,
 869                                          Ipi.typeArray()));
 870     }
 871   }
 872
 873   // Then write the PDB.
 874   PDBFileBuilder Builder(Allocator);
 875   ExitOnErr(Builder.initialize(4096));
 876   // Add each of the reserved streams.  We might not put any data in them,
 877   // but at least they have to be present.
 878   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)
 879     ExitOnErr(Builder.getMsfBuilder().addStream(0));
 880
 881   auto &DestTpi = Builder.getTpiBuilder();
 882   auto &DestIpi = Builder.getIpiBuilder();
 883   MergedTpi.ForEachRecord([&DestTpi](TypeIndex TI, ArrayRef<uint8_t> Data) {
 884     DestTpi.addTypeRecord(Data, None);
 885   });
 886   MergedIpi.ForEachRecord([&DestIpi](TypeIndex TI, ArrayRef<uint8_t> Data) {
 887     DestIpi.addTypeRecord(Data, None);
 888   });
 889
 890   SmallString<64> OutFile(opts::merge::PdbOutputFile);
 891   if (OutFile.empty()) {
 892     OutFile = opts::merge::InputFilenames[0];
 893     llvm::sys::path::replace_extension(OutFile, "merged.pdb");
 894   }
 895   ExitOnErr(Builder.commit(OutFile));
 896 }
 897
 898 int main(int argc_, const char *argv_[]) {
 899   // Print a stack trace if we signal out.
 900   sys::PrintStackTraceOnErrorSignal(argv_[0]);
 901   PrettyStackTraceProgram X(argc_, argv_);
 902
 903   ExitOnErr.setBanner("llvm-pdbdump: ");
 904
 905   SmallVector<const char *, 256> argv;
 906   SpecificBumpPtrAllocator<char> ArgAllocator;
 907   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
 908       argv, makeArrayRef(argv_, argc_), ArgAllocator)));
 909
 910   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 911
 912   cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
 913   if (!opts::raw::DumpBlockRangeOpt.empty()) {
 914     llvm::Regex R("^([0-9]+)(-([0-9]+))?$");
 915     llvm::SmallVector<llvm::StringRef, 2> Matches;
 916     if (!R.match(opts::raw::DumpBlockRangeOpt, &Matches)) {
 917       errs() << "Argument '" << opts::raw::DumpBlockRangeOpt
 918              << "' invalid format.\n";
 919       errs().flush();
 920       exit(1);
 921     }
 922     opts::raw::DumpBlockRange.emplace();
 923     Matches[1].getAsInteger(10, opts::raw::DumpBlockRange->Min);
 924     if (!Matches[3].empty()) {
 925       opts::raw::DumpBlockRange->Max.emplace();
 926       Matches[3].getAsInteger(10, *opts::raw::DumpBlockRange->Max);
 927     }
 928   }
 929
 930   if (opts::RawSubcommand) {
 931     if (opts::raw::RawAll) {
 932       opts::raw::DumpHeaders = true;
 933       opts::raw::DumpModules = true;
 934       opts::raw::DumpModuleFiles = true;
 935       opts::raw::DumpModuleSyms = true;
 936       opts::raw::DumpGlobals = true;
 937       opts::raw::DumpPublics = true;
 938       opts::raw::DumpSectionHeaders = true;
 939       opts::raw::DumpStreamSummary = true;
 940       opts::raw::DumpPageStats = true;
 941       opts::raw::DumpStreamBlocks = true;
 942       opts::raw::DumpTpiRecords = true;
 943       opts::raw::DumpTpiHash = true;
 944       opts::raw::DumpIpiRecords = true;
 945       opts::raw::DumpSectionMap = true;
 946       opts::raw::DumpSectionContribs = true;
 947       opts::raw::DumpLineInfo = true;
 948       opts::raw::DumpFpo = true;
 949       opts::raw::DumpStringTable = true;
 950     }
 951
 952     if (opts::raw::CompactRecords &&
 953         (opts::raw::DumpTpiRecordBytes || opts::raw::DumpIpiRecordBytes)) {
 954       errs() << "-compact-records is incompatible with -tpi-record-bytes and "
 955                 "-ipi-record-bytes.\n";
 956       exit(1);
 957     }
 958   }
 959
 960   llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
 961
 962   if (opts::PdbToYamlSubcommand) {
 963     pdb2Yaml(opts::pdb2yaml::InputFilename.front());
 964   } else if (opts::YamlToPdbSubcommand) {
 965     if (opts::yaml2pdb::YamlPdbOutputFile.empty()) {
 966       SmallString<16> OutputFilename(opts::yaml2pdb::InputFilename.getValue());
 967       sys::path::replace_extension(OutputFilename, ".pdb");
 968       opts::yaml2pdb::YamlPdbOutputFile = OutputFilename.str();
 969     }
 970     yamlToPdb(opts::yaml2pdb::InputFilename);
 971   } else if (opts::AnalyzeSubcommand) {
 972     dumpAnalysis(opts::analyze::InputFilename.front());
 973   } else if (opts::PrettySubcommand) {
 974     if (opts::pretty::Lines)
 975       opts::pretty::Compilands = true;
 976
 977     if (opts::pretty::All) {
 978       opts::pretty::Compilands = true;
 979       opts::pretty::Symbols = true;
 980       opts::pretty::Globals = true;
 981       opts::pretty::Types = true;
 982       opts::pretty::Externals = true;
 983       opts::pretty::Lines = true;
 984     }
 985
 986     if (opts::pretty::Types) {
 987       opts::pretty::Classes = true;
 988       opts::pretty::Typedefs = true;
 989       opts::pretty::Enums = true;
 990     }
 991
 992     // When adding filters for excluded compilands and types, we need to
 993     // remember that these are regexes.  So special characters such as * and \
 994     // need to be escaped in the regex.  In the case of a literal \, this means
 995     // it needs to be escaped again in the C++.  So matching a single \ in the
 996     // input requires 4 \es in the C++.
 997     if (opts::pretty::ExcludeCompilerGenerated) {
 998       opts::pretty::ExcludeTypes.push_back("__vc_attributes");
 999       opts::pretty::ExcludeCompilands.push_back("\\* Linker \\*");
1000     }
1001     if (opts::pretty::ExcludeSystemLibraries) {
1002       opts::pretty::ExcludeCompilands.push_back(
1003           "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
1004       opts::pretty::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
1005       opts::pretty::ExcludeCompilands.push_back(
1006           "d:\\\\th.obj.x86fre\\\\minkernel");
1007     }
1008     std::for_each(opts::pretty::InputFilenames.begin(),
1009                   opts::pretty::InputFilenames.end(), dumpPretty);
1010   } else if (opts::RawSubcommand) {
1011     std::for_each(opts::raw::InputFilenames.begin(),
1012                   opts::raw::InputFilenames.end(), dumpRaw);
1013   } else if (opts::DiffSubcommand) {
1014     if (opts::diff::InputFilenames.size() != 2) {
1015       errs() << "diff subcommand expects exactly 2 arguments.\n";
1016       exit(1);
1017     }
1018     diff(opts::diff::InputFilenames[0], opts::diff::InputFilenames[1]);
1019   } else if (opts::MergeSubcommand) {
1020     if (opts::merge::InputFilenames.size() < 2) {
1021       errs() << "merge subcommand requires at least 2 input files.\n";
1022       exit(1);
1023     }
1024     mergePdbs();
1025   }
1026
1027   outs().flush();
1028   return 0;
1029 }