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/DebugChecksumsSubsection.h"
  35 #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
  36 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
  37 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.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 = llvm::make_unique<DebugChecksumsSubsection>(Strings);
 547       auto &ChecksumRef = *Checksums;
 548       if (!FLI.FileChecksums.empty()) {
 549         for (auto &FC : FLI.FileChecksums)
 550           Checksums->addChecksum(FC.FileName, FC.Kind, FC.ChecksumBytes.Bytes);
 551       }
 552       ModiBuilder.setC13FileChecksums(std::move(Checksums));
 553
 554       for (const auto &Fragment : FLI.LineFragments) {
 555         auto Lines =
 556             llvm::make_unique<DebugLinesSubsection>(ChecksumRef, Strings);
 557         Lines->setCodeSize(Fragment.CodeSize);
 558         Lines->setRelocationAddress(Fragment.RelocSegment,
 559                                     Fragment.RelocOffset);
 560         Lines->setFlags(Fragment.Flags);
 561         for (const auto &LC : Fragment.Blocks) {
 562           Lines->createBlock(LC.FileName);
 563           if (Lines->hasColumnInfo()) {
 564             for (const auto &Item : zip(LC.Lines, LC.Columns)) {
 565               auto &L = std::get<0>(Item);
 566               auto &C = std::get<1>(Item);
 567               uint32_t LE = L.LineStart + L.EndDelta;
 568               Lines->addLineAndColumnInfo(
 569                   L.Offset, LineInfo(L.LineStart, LE, L.IsStatement),
 570                   C.StartColumn, C.EndColumn);
 571             }
 572           } else {
 573             for (const auto &L : LC.Lines) {
 574               uint32_t LE = L.LineStart + L.EndDelta;
 575               Lines->addLineInfo(L.Offset,
 576                                  LineInfo(L.LineStart, LE, L.IsStatement));
 577             }
 578           }
 579         }
 580         ModiBuilder.addC13Fragment(std::move(Lines));
 581       }
 582
 583       for (const auto &Inlinee : FLI.Inlinees) {
 584         auto Inlinees = llvm::make_unique<DebugInlineeLinesSubsection>(
 585             ChecksumRef, Inlinee.HasExtraFiles);
 586         for (const auto &Site : Inlinee.Sites) {
 587           Inlinees->addInlineSite(Site.Inlinee, Site.FileName,
 588                                   Site.SourceLineNum);
 589           if (!Inlinee.HasExtraFiles)
 590             continue;
 591
 592           for (auto EF : Site.ExtraFiles) {
 593             Inlinees->addExtraFile(EF);
 594           }
 595         }
 596         ModiBuilder.addC13Fragment(std::move(Inlinees));
 597       }
 598     }
 599   }
 600
 601   auto &TpiBuilder = Builder.getTpiBuilder();
 602   const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);
 603   TpiBuilder.setVersionHeader(Tpi.Version);
 604   for (const auto &R : Tpi.Records)
 605     TpiBuilder.addTypeRecord(R.Record.data(), R.Record.Hash);
 606
 607   const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream);
 608   auto &IpiBuilder = Builder.getIpiBuilder();
 609   IpiBuilder.setVersionHeader(Ipi.Version);
 610   for (const auto &R : Ipi.Records)
 611     IpiBuilder.addTypeRecord(R.Record.data(), R.Record.Hash);
 612
 613   ExitOnErr(Builder.commit(opts::yaml2pdb::YamlPdbOutputFile));
 614 }
 615
 616 static PDBFile &loadPDB(StringRef Path, std::unique_ptr<IPDBSession> &Session) {
 617   ExitOnErr(loadDataForPDB(PDB_ReaderType::Native, Path, Session));
 618
 619   NativeSession *NS = static_cast<NativeSession *>(Session.get());
 620   return NS->getPDBFile();
 621 }
 622
 623 static void pdb2Yaml(StringRef Path) {
 624   std::unique_ptr<IPDBSession> Session;
 625   auto &File = loadPDB(Path, Session);
 626
 627   auto O = llvm::make_unique<YAMLOutputStyle>(File);
 628   O = llvm::make_unique<YAMLOutputStyle>(File);
 629
 630   ExitOnErr(O->dump());
 631 }
 632
 633 static void dumpRaw(StringRef Path) {
 634   std::unique_ptr<IPDBSession> Session;
 635   auto &File = loadPDB(Path, Session);
 636
 637   auto O = llvm::make_unique<LLVMOutputStyle>(File);
 638
 639   ExitOnErr(O->dump());
 640 }
 641
 642 static void dumpAnalysis(StringRef Path) {
 643   std::unique_ptr<IPDBSession> Session;
 644   auto &File = loadPDB(Path, Session);
 645   auto O = llvm::make_unique<AnalysisStyle>(File);
 646
 647   ExitOnErr(O->dump());
 648 }
 649
 650 static void diff(StringRef Path1, StringRef Path2) {
 651   std::unique_ptr<IPDBSession> Session1;
 652   std::unique_ptr<IPDBSession> Session2;
 653
 654   auto &File1 = loadPDB(Path1, Session1);
 655   auto &File2 = loadPDB(Path2, Session2);
 656
 657   auto O = llvm::make_unique<DiffStyle>(File1, File2);
 658
 659   ExitOnErr(O->dump());
 660 }
 661
 662 bool opts::pretty::shouldDumpSymLevel(SymLevel Search) {
 663   if (SymTypes.empty())
 664     return true;
 665   if (llvm::find(SymTypes, Search) != SymTypes.end())
 666     return true;
 667   if (llvm::find(SymTypes, SymLevel::All) != SymTypes.end())
 668     return true;
 669   return false;
 670 }
 671
 672 uint32_t llvm::pdb::getTypeLength(const PDBSymbolData &Symbol) {
 673   auto SymbolType = Symbol.getType();
 674   const IPDBRawSymbol &RawType = SymbolType->getRawSymbol();
 675
 676   return RawType.getLength();
 677 }
 678
 679 bool opts::pretty::compareFunctionSymbols(
 680     const std::unique_ptr<PDBSymbolFunc> &F1,
 681     const std::unique_ptr<PDBSymbolFunc> &F2) {
 682   assert(opts::pretty::SymbolOrder != opts::pretty::SymbolSortMode::None);
 683
 684   if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::Name)
 685     return F1->getName() < F2->getName();
 686
 687   // Note that we intentionally sort in descending order on length, since
 688   // long functions are more interesting than short functions.
 689   return F1->getLength() > F2->getLength();
 690 }
 691
 692 bool opts::pretty::compareDataSymbols(
 693     const std::unique_ptr<PDBSymbolData> &F1,
 694     const std::unique_ptr<PDBSymbolData> &F2) {
 695   assert(opts::pretty::SymbolOrder != opts::pretty::SymbolSortMode::None);
 696
 697   if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::Name)
 698     return F1->getName() < F2->getName();
 699
 700   // Note that we intentionally sort in descending order on length, since
 701   // large types are more interesting than short ones.
 702   return getTypeLength(*F1) > getTypeLength(*F2);
 703 }
 704
 705 static void dumpPretty(StringRef Path) {
 706   std::unique_ptr<IPDBSession> Session;
 707
 708   const auto ReaderType =
 709       opts::pretty::Native ? PDB_ReaderType::Native : PDB_ReaderType::DIA;
 710   ExitOnErr(loadDataForPDB(ReaderType, Path, Session));
 711
 712   if (opts::pretty::LoadAddress)
 713     Session->setLoadAddress(opts::pretty::LoadAddress);
 714
 715   auto &Stream = outs();
 716   const bool UseColor = opts::pretty::ColorOutput == cl::BOU_UNSET
 717                             ? Stream.has_colors()
 718                             : opts::pretty::ColorOutput == cl::BOU_TRUE;
 719   LinePrinter Printer(2, UseColor, Stream);
 720
 721   auto GlobalScope(Session->getGlobalScope());
 722   std::string FileName(GlobalScope->getSymbolsFileName());
 723
 724   WithColor(Printer, PDB_ColorItem::None).get() << "Summary for ";
 725   WithColor(Printer, PDB_ColorItem::Path).get() << FileName;
 726   Printer.Indent();
 727   uint64_t FileSize = 0;
 728
 729   Printer.NewLine();
 730   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Size";
 731   if (!sys::fs::file_size(FileName, FileSize)) {
 732     Printer << ": " << FileSize << " bytes";
 733   } else {
 734     Printer << ": (Unable to obtain file size)";
 735   }
 736
 737   Printer.NewLine();
 738   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Guid";
 739   Printer << ": " << GlobalScope->getGuid();
 740
 741   Printer.NewLine();
 742   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Age";
 743   Printer << ": " << GlobalScope->getAge();
 744
 745   Printer.NewLine();
 746   WithColor(Printer, PDB_ColorItem::Identifier).get() << "Attributes";
 747   Printer << ": ";
 748   if (GlobalScope->hasCTypes())
 749     outs() << "HasCTypes ";
 750   if (GlobalScope->hasPrivateSymbols())
 751     outs() << "HasPrivateSymbols ";
 752   Printer.Unindent();
 753
 754   if (opts::pretty::Compilands) {
 755     Printer.NewLine();
 756     WithColor(Printer, PDB_ColorItem::SectionHeader).get()
 757         << "---COMPILANDS---";
 758     Printer.Indent();
 759     auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
 760     CompilandDumper Dumper(Printer);
 761     CompilandDumpFlags options = CompilandDumper::Flags::None;
 762     if (opts::pretty::Lines)
 763       options = options | CompilandDumper::Flags::Lines;
 764     while (auto Compiland = Compilands->getNext())
 765       Dumper.start(*Compiland, options);
 766     Printer.Unindent();
 767   }
 768
 769   if (opts::pretty::Classes || opts::pretty::Enums || opts::pretty::Typedefs) {
 770     Printer.NewLine();
 771     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---TYPES---";
 772     Printer.Indent();
 773     TypeDumper Dumper(Printer);
 774     Dumper.start(*GlobalScope);
 775     Printer.Unindent();
 776   }
 777
 778   if (opts::pretty::Symbols) {
 779     Printer.NewLine();
 780     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---SYMBOLS---";
 781     Printer.Indent();
 782     auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
 783     CompilandDumper Dumper(Printer);
 784     while (auto Compiland = Compilands->getNext())
 785       Dumper.start(*Compiland, true);
 786     Printer.Unindent();
 787   }
 788
 789   if (opts::pretty::Globals) {
 790     Printer.NewLine();
 791     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---GLOBALS---";
 792     Printer.Indent();
 793     if (shouldDumpSymLevel(opts::pretty::SymLevel::Functions)) {
 794       FunctionDumper Dumper(Printer);
 795       auto Functions = GlobalScope->findAllChildren<PDBSymbolFunc>();
 796       if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
 797         while (auto Function = Functions->getNext()) {
 798           Printer.NewLine();
 799           Dumper.start(*Function, FunctionDumper::PointerType::None);
 800         }
 801       } else {
 802         std::vector<std::unique_ptr<PDBSymbolFunc>> Funcs;
 803         while (auto Func = Functions->getNext())
 804           Funcs.push_back(std::move(Func));
 805         std::sort(Funcs.begin(), Funcs.end(),
 806                   opts::pretty::compareFunctionSymbols);
 807         for (const auto &Func : Funcs) {
 808           Printer.NewLine();
 809           Dumper.start(*Func, FunctionDumper::PointerType::None);
 810         }
 811       }
 812     }
 813     if (shouldDumpSymLevel(opts::pretty::SymLevel::Data)) {
 814       auto Vars = GlobalScope->findAllChildren<PDBSymbolData>();
 815       VariableDumper Dumper(Printer);
 816       if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
 817         while (auto Var = Vars->getNext())
 818           Dumper.start(*Var);
 819       } else {
 820         std::vector<std::unique_ptr<PDBSymbolData>> Datas;
 821         while (auto Var = Vars->getNext())
 822           Datas.push_back(std::move(Var));
 823         std::sort(Datas.begin(), Datas.end(), opts::pretty::compareDataSymbols);
 824         for (const auto &Var : Datas)
 825           Dumper.start(*Var);
 826       }
 827     }
 828     if (shouldDumpSymLevel(opts::pretty::SymLevel::Thunks)) {
 829       auto Thunks = GlobalScope->findAllChildren<PDBSymbolThunk>();
 830       CompilandDumper Dumper(Printer);
 831       while (auto Thunk = Thunks->getNext())
 832         Dumper.dump(*Thunk);
 833     }
 834     Printer.Unindent();
 835   }
 836   if (opts::pretty::Externals) {
 837     Printer.NewLine();
 838     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---EXTERNALS---";
 839     Printer.Indent();
 840     ExternalSymbolDumper Dumper(Printer);
 841     Dumper.start(*GlobalScope);
 842   }
 843   if (opts::pretty::Lines) {
 844     Printer.NewLine();
 845   }
 846   outs().flush();
 847 }
 848
 849 static void mergePdbs() {
 850   BumpPtrAllocator Allocator;
 851   TypeTableBuilder MergedTpi(Allocator);
 852   TypeTableBuilder MergedIpi(Allocator);
 853
 854   // Create a Tpi and Ipi type table with all types from all input files.
 855   for (const auto &Path : opts::merge::InputFilenames) {
 856     std::unique_ptr<IPDBSession> Session;
 857     auto &File = loadPDB(Path, Session);
 858     SmallVector<TypeIndex, 128> TypeMap;
 859     SmallVector<TypeIndex, 128> IdMap;
 860     if (File.hasPDBTpiStream()) {
 861       auto &Tpi = ExitOnErr(File.getPDBTpiStream());
 862       ExitOnErr(codeview::mergeTypeRecords(MergedTpi, TypeMap, nullptr,
 863                                            Tpi.typeArray()));
 864     }
 865     if (File.hasPDBIpiStream()) {
 866       auto &Ipi = ExitOnErr(File.getPDBIpiStream());
 867       ExitOnErr(codeview::mergeIdRecords(MergedIpi, TypeMap, IdMap,
 868                                          Ipi.typeArray()));
 869     }
 870   }
 871
 872   // Then write the PDB.
 873   PDBFileBuilder Builder(Allocator);
 874   ExitOnErr(Builder.initialize(4096));
 875   // Add each of the reserved streams.  We might not put any data in them,
 876   // but at least they have to be present.
 877   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)
 878     ExitOnErr(Builder.getMsfBuilder().addStream(0));
 879
 880   auto &DestTpi = Builder.getTpiBuilder();
 881   auto &DestIpi = Builder.getIpiBuilder();
 882   MergedTpi.ForEachRecord([&DestTpi](TypeIndex TI, ArrayRef<uint8_t> Data) {
 883     DestTpi.addTypeRecord(Data, None);
 884   });
 885   MergedIpi.ForEachRecord([&DestIpi](TypeIndex TI, ArrayRef<uint8_t> Data) {
 886     DestIpi.addTypeRecord(Data, None);
 887   });
 888
 889   SmallString<64> OutFile(opts::merge::PdbOutputFile);
 890   if (OutFile.empty()) {
 891     OutFile = opts::merge::InputFilenames[0];
 892     llvm::sys::path::replace_extension(OutFile, "merged.pdb");
 893   }
 894   ExitOnErr(Builder.commit(OutFile));
 895 }
 896
 897 int main(int argc_, const char *argv_[]) {
 898   // Print a stack trace if we signal out.
 899   sys::PrintStackTraceOnErrorSignal(argv_[0]);
 900   PrettyStackTraceProgram X(argc_, argv_);
 901
 902   ExitOnErr.setBanner("llvm-pdbdump: ");
 903
 904   SmallVector<const char *, 256> argv;
 905   SpecificBumpPtrAllocator<char> ArgAllocator;
 906   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
 907       argv, makeArrayRef(argv_, argc_), ArgAllocator)));
 908
 909   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 910
 911   cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
 912   if (!opts::raw::DumpBlockRangeOpt.empty()) {
 913     llvm::Regex R("^([0-9]+)(-([0-9]+))?$");
 914     llvm::SmallVector<llvm::StringRef, 2> Matches;
 915     if (!R.match(opts::raw::DumpBlockRangeOpt, &Matches)) {
 916       errs() << "Argument '" << opts::raw::DumpBlockRangeOpt
 917              << "' invalid format.\n";
 918       errs().flush();
 919       exit(1);
 920     }
 921     opts::raw::DumpBlockRange.emplace();
 922     Matches[1].getAsInteger(10, opts::raw::DumpBlockRange->Min);
 923     if (!Matches[3].empty()) {
 924       opts::raw::DumpBlockRange->Max.emplace();
 925       Matches[3].getAsInteger(10, *opts::raw::DumpBlockRange->Max);
 926     }
 927   }
 928
 929   if (opts::RawSubcommand) {
 930     if (opts::raw::RawAll) {
 931       opts::raw::DumpHeaders = true;
 932       opts::raw::DumpModules = true;
 933       opts::raw::DumpModuleFiles = true;
 934       opts::raw::DumpModuleSyms = true;
 935       opts::raw::DumpGlobals = true;
 936       opts::raw::DumpPublics = true;
 937       opts::raw::DumpSectionHeaders = true;
 938       opts::raw::DumpStreamSummary = true;
 939       opts::raw::DumpPageStats = true;
 940       opts::raw::DumpStreamBlocks = true;
 941       opts::raw::DumpTpiRecords = true;
 942       opts::raw::DumpTpiHash = true;
 943       opts::raw::DumpIpiRecords = true;
 944       opts::raw::DumpSectionMap = true;
 945       opts::raw::DumpSectionContribs = true;
 946       opts::raw::DumpLineInfo = true;
 947       opts::raw::DumpFpo = true;
 948       opts::raw::DumpStringTable = true;
 949     }
 950
 951     if (opts::raw::CompactRecords &&
 952         (opts::raw::DumpTpiRecordBytes || opts::raw::DumpIpiRecordBytes)) {
 953       errs() << "-compact-records is incompatible with -tpi-record-bytes and "
 954                 "-ipi-record-bytes.\n";
 955       exit(1);
 956     }
 957   }
 958
 959   llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
 960
 961   if (opts::PdbToYamlSubcommand) {
 962     pdb2Yaml(opts::pdb2yaml::InputFilename.front());
 963   } else if (opts::YamlToPdbSubcommand) {
 964     if (opts::yaml2pdb::YamlPdbOutputFile.empty()) {
 965       SmallString<16> OutputFilename(opts::yaml2pdb::InputFilename.getValue());
 966       sys::path::replace_extension(OutputFilename, ".pdb");
 967       opts::yaml2pdb::YamlPdbOutputFile = OutputFilename.str();
 968     }
 969     yamlToPdb(opts::yaml2pdb::InputFilename);
 970   } else if (opts::AnalyzeSubcommand) {
 971     dumpAnalysis(opts::analyze::InputFilename.front());
 972   } else if (opts::PrettySubcommand) {
 973     if (opts::pretty::Lines)
 974       opts::pretty::Compilands = true;
 975
 976     if (opts::pretty::All) {
 977       opts::pretty::Compilands = true;
 978       opts::pretty::Symbols = true;
 979       opts::pretty::Globals = true;
 980       opts::pretty::Types = true;
 981       opts::pretty::Externals = true;
 982       opts::pretty::Lines = true;
 983     }
 984
 985     if (opts::pretty::Types) {
 986       opts::pretty::Classes = true;
 987       opts::pretty::Typedefs = true;
 988       opts::pretty::Enums = true;
 989     }
 990
 991     // When adding filters for excluded compilands and types, we need to
 992     // remember that these are regexes.  So special characters such as * and \
 993     // need to be escaped in the regex.  In the case of a literal \, this means
 994     // it needs to be escaped again in the C++.  So matching a single \ in the
 995     // input requires 4 \es in the C++.
 996     if (opts::pretty::ExcludeCompilerGenerated) {
 997       opts::pretty::ExcludeTypes.push_back("__vc_attributes");
 998       opts::pretty::ExcludeCompilands.push_back("\\* Linker \\*");
 999     }
1000     if (opts::pretty::ExcludeSystemLibraries) {
1001       opts::pretty::ExcludeCompilands.push_back(
1002           "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
1003       opts::pretty::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
1004       opts::pretty::ExcludeCompilands.push_back(
1005           "d:\\\\th.obj.x86fre\\\\minkernel");
1006     }
1007     std::for_each(opts::pretty::InputFilenames.begin(),
1008                   opts::pretty::InputFilenames.end(), dumpPretty);
1009   } else if (opts::RawSubcommand) {
1010     std::for_each(opts::raw::InputFilenames.begin(),
1011                   opts::raw::InputFilenames.end(), dumpRaw);
1012   } else if (opts::DiffSubcommand) {
1013     if (opts::diff::InputFilenames.size() != 2) {
1014       errs() << "diff subcommand expects exactly 2 arguments.\n";
1015       exit(1);
1016     }
1017     diff(opts::diff::InputFilenames[0], opts::diff::InputFilenames[1]);
1018   } else if (opts::MergeSubcommand) {
1019     if (opts::merge::InputFilenames.size() < 2) {
1020       errs() << "merge subcommand requires at least 2 input files.\n";
1021       exit(1);
1022     }
1023     mergePdbs();
1024   }
1025
1026   outs().flush();
1027   return 0;
1028 }