blob: cb064c70f15af2878037cbe2fb9a4fc49374e3fb [file] [log] [blame]
Zachary Turnerbd336e42017-06-09 20:46:17 +00001//===- llvm-pdbutil.cpp - Dump debug info from a PDB file -------*- C++ -*-===//
Zachary Turnerfcb14ad2015-01-27 20:46:21 +00002//
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//
Zachary Turner6ac232c2017-03-13 23:28:25 +000010// Dumps debug information present in PDB files.
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000011//
12//===----------------------------------------------------------------------===//
13
Zachary Turnerbd336e42017-06-09 20:46:17 +000014#include "llvm-pdbutil.h"
Zachary Turnerd50c0132017-02-01 18:30:22 +000015
16#include "Analyze.h"
Zachary Turner99402032017-06-22 20:58:11 +000017#include "BytesOutputStyle.h"
Zachary Turner6ac232c2017-03-13 23:28:25 +000018#include "Diff.h"
Zachary Turner7df69952017-06-22 20:57:39 +000019#include "DumpOutputStyle.h"
Zachary Turner2d11c202015-02-27 09:15:59 +000020#include "LinePrinter.h"
Zachary Turnerd3117392016-06-03 19:28:33 +000021#include "OutputStyle.h"
Zachary Turnera9054dd2017-01-11 00:35:43 +000022#include "PrettyCompilandDumper.h"
23#include "PrettyExternalSymbolDumper.h"
24#include "PrettyFunctionDumper.h"
25#include "PrettyTypeDumper.h"
26#include "PrettyVariableDumper.h"
Zachary Turner7120a472016-06-06 20:37:05 +000027#include "YAMLOutputStyle.h"
Zachary Turner9a818ad2015-02-22 22:03:38 +000028
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000029#include "llvm/ADT/ArrayRef.h"
David Majnemer6e081262015-10-15 01:27:19 +000030#include "llvm/ADT/BitVector.h"
31#include "llvm/ADT/DenseMap.h"
Zachary Turner8a2ebfb2017-05-01 23:27:42 +000032#include "llvm/ADT/STLExtras.h"
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000033#include "llvm/ADT/StringExtras.h"
Zachary Turner8d7fa9b2015-02-10 22:47:14 +000034#include "llvm/Config/config.h"
Zachary Turner8c099fe2017-05-30 16:36:15 +000035#include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
36#include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h"
37#include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
Zachary Turner526f4f22017-05-19 19:26:58 +000038#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
Zachary Turnera8cfc292017-06-14 15:59:27 +000039#include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
Zachary Turner8fb441a2017-05-18 23:03:41 +000040#include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
Zachary Turnerb32ec022017-05-18 23:04:08 +000041#include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
Zachary Turnera3225b02016-07-29 20:56:36 +000042#include "llvm/DebugInfo/MSF/MSFBuilder.h"
Zachary Turner819e77d2016-05-06 20:51:57 +000043#include "llvm/DebugInfo/PDB/GenericError.h"
Zachary Turnera5549172015-02-10 22:43:25 +000044#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
Zachary Turnera5549172015-02-10 22:43:25 +000045#include "llvm/DebugInfo/PDB/IPDBRawSymbol.h"
Chandler Carruth71f308a2015-02-13 09:09:03 +000046#include "llvm/DebugInfo/PDB/IPDBSession.h"
Zachary Turner67c56012017-04-27 16:11:19 +000047#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
Adrian McCarthy6b6b8c42017-01-25 22:38:55 +000048#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
49#include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
50#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
51#include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
52#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
53#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
54#include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
Zachary Turnere204a6c2017-05-02 18:00:13 +000055#include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
Adrian McCarthy6b6b8c42017-01-25 22:38:55 +000056#include "llvm/DebugInfo/PDB/Native/RawConstants.h"
57#include "llvm/DebugInfo/PDB/Native/RawError.h"
Adrian McCarthy6b6b8c42017-01-25 22:38:55 +000058#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
59#include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
Chandler Carruth71f308a2015-02-13 09:09:03 +000060#include "llvm/DebugInfo/PDB/PDB.h"
Zachary Turnera5549172015-02-10 22:43:25 +000061#include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
Zachary Turnerdb18f5c2015-02-27 09:15:18 +000062#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
Chandler Carruth71f308a2015-02-13 09:09:03 +000063#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
Zachary Turnerdb18f5c2015-02-27 09:15:18 +000064#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
65#include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
Zachary Turnerd9dc2822017-03-02 20:52:51 +000066#include "llvm/Support/BinaryByteStream.h"
Zachary Turner93839cb2016-06-02 05:07:49 +000067#include "llvm/Support/COM.h"
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000068#include "llvm/Support/CommandLine.h"
69#include "llvm/Support/ConvertUTF.h"
Zachary Turner1dc9fd32016-06-14 20:48:36 +000070#include "llvm/Support/FileOutputBuffer.h"
Zachary Turner9a818ad2015-02-22 22:03:38 +000071#include "llvm/Support/FileSystem.h"
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000072#include "llvm/Support/Format.h"
73#include "llvm/Support/ManagedStatic.h"
David Majnemer6e081262015-10-15 01:27:19 +000074#include "llvm/Support/MemoryBuffer.h"
Bob Haarmande33a6372017-05-17 20:46:48 +000075#include "llvm/Support/Path.h"
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000076#include "llvm/Support/PrettyStackTrace.h"
Chandler Carruth71f308a2015-02-13 09:09:03 +000077#include "llvm/Support/Process.h"
Zachary Turner72c5b642016-09-09 18:17:52 +000078#include "llvm/Support/Regex.h"
Reid Klecknerb0345262016-05-04 16:09:04 +000079#include "llvm/Support/ScopedPrinter.h"
Daniel Sandersd41718e2016-04-22 12:04:42 +000080#include "llvm/Support/Signals.h"
Zachary Turner0a43efe2016-04-25 17:38:08 +000081#include "llvm/Support/raw_ostream.h"
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000082
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000083using namespace llvm;
Zachary Turnera96cce62016-06-03 03:25:59 +000084using namespace llvm::codeview;
Zachary Turnerbac69d32016-07-22 19:56:05 +000085using namespace llvm::msf;
Zachary Turner2f09b502016-04-29 17:28:47 +000086using namespace llvm::pdb;
Zachary Turnerfcb14ad2015-01-27 20:46:21 +000087
88namespace opts {
Zachary Turnerc0acf682015-02-15 20:27:53 +000089
Zachary Turner7df69952017-06-22 20:57:39 +000090cl::SubCommand DumpSubcommand("dump", "Dump MSF and CodeView debug info");
Zachary Turner99402032017-06-22 20:58:11 +000091cl::SubCommand BytesSubcommand("bytes", "Dump raw bytes from the PDB file");
92
Zachary Turnera30bd1a2016-06-30 17:42:48 +000093cl::SubCommand
94 PrettySubcommand("pretty",
95 "Dump semantic information about types and symbols");
Zachary Turner6ac232c2017-03-13 23:28:25 +000096
97cl::SubCommand DiffSubcommand("diff", "Diff the contents of 2 PDB files");
98
Zachary Turnerab58ae82016-06-30 17:43:00 +000099cl::SubCommand
100 YamlToPdbSubcommand("yaml2pdb",
101 "Generate a PDB file from a YAML description");
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000102cl::SubCommand
103 PdbToYamlSubcommand("pdb2yaml",
104 "Generate a detailed YAML description of a PDB File");
Zachary Turnerfcb14ad2015-01-27 20:46:21 +0000105
Zachary Turnerd50c0132017-02-01 18:30:22 +0000106cl::SubCommand
107 AnalyzeSubcommand("analyze",
108 "Analyze various aspects of a PDB's structure");
109
Zachary Turner8fb441a2017-05-18 23:03:41 +0000110cl::SubCommand MergeSubcommand("merge",
111 "Merge multiple PDBs into a single PDB");
112
Zachary Turner7797c722015-03-02 04:39:56 +0000113cl::OptionCategory TypeCategory("Symbol Type Options");
Zachary Turnerc883a8c2017-04-12 23:18:21 +0000114cl::OptionCategory FilterCategory("Filtering and Sorting Options");
Zachary Turnere5cb2692015-05-01 20:24:26 +0000115cl::OptionCategory OtherOptions("Other Options");
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000116
117namespace pretty {
118cl::list<std::string> InputFilenames(cl::Positional,
119 cl::desc("<input PDB files>"),
120 cl::OneOrMore, cl::sub(PrettySubcommand));
Zachary Turner7797c722015-03-02 04:39:56 +0000121
122cl::opt<bool> Compilands("compilands", cl::desc("Display compilands"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000123 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turner0683be22017-05-14 01:13:40 +0000124cl::opt<bool> Symbols("module-syms",
125 cl::desc("Display symbols for each compiland"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000126 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turner7797c722015-03-02 04:39:56 +0000127cl::opt<bool> Globals("globals", cl::desc("Dump global symbols"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000128 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turnere5cb2692015-05-01 20:24:26 +0000129cl::opt<bool> Externals("externals", cl::desc("Dump external symbols"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000130 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turner0683be22017-05-14 01:13:40 +0000131cl::list<SymLevel> SymTypes(
132 "sym-types", cl::desc("Type of symbols to dump (default all)"),
133 cl::cat(TypeCategory), cl::sub(PrettySubcommand), cl::ZeroOrMore,
134 cl::values(
135 clEnumValN(SymLevel::Thunks, "thunks", "Display thunk symbols"),
136 clEnumValN(SymLevel::Data, "data", "Display data symbols"),
137 clEnumValN(SymLevel::Functions, "funcs", "Display function symbols"),
138 clEnumValN(SymLevel::All, "all", "Display all symbols (default)")));
139
Zachary Turner63230a4e2017-04-06 23:43:12 +0000140cl::opt<bool>
141 Types("types",
142 cl::desc("Display all types (implies -classes, -enums, -typedefs)"),
143 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
144cl::opt<bool> Classes("classes", cl::desc("Display class types"),
145 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
146cl::opt<bool> Enums("enums", cl::desc("Display enum types"),
147 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
148cl::opt<bool> Typedefs("typedefs", cl::desc("Display typedef types"),
149 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turner0683be22017-05-14 01:13:40 +0000150cl::opt<SymbolSortMode> SymbolOrder(
151 "symbol-order", cl::desc("symbol sort order"),
152 cl::init(SymbolSortMode::None),
153 cl::values(clEnumValN(SymbolSortMode::None, "none",
154 "Undefined / no particular sort order"),
155 clEnumValN(SymbolSortMode::Name, "name", "Sort symbols by name"),
156 clEnumValN(SymbolSortMode::Size, "size",
157 "Sort symbols by size")),
158 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
159
Zachary Turner4dc4f012017-04-13 21:11:00 +0000160cl::opt<ClassSortMode> ClassOrder(
161 "class-order", cl::desc("Class sort order"), cl::init(ClassSortMode::None),
Zachary Turner16901642017-04-24 17:47:24 +0000162 cl::values(
163 clEnumValN(ClassSortMode::None, "none",
164 "Undefined / no particular sort order"),
165 clEnumValN(ClassSortMode::Name, "name", "Sort classes by name"),
166 clEnumValN(ClassSortMode::Size, "size", "Sort classes by size"),
167 clEnumValN(ClassSortMode::Padding, "padding",
168 "Sort classes by amount of padding"),
169 clEnumValN(ClassSortMode::PaddingPct, "padding-pct",
Zachary Turnerda307b62017-04-25 20:22:29 +0000170 "Sort classes by percentage of space consumed by padding"),
171 clEnumValN(ClassSortMode::PaddingImmediate, "padding-imm",
172 "Sort classes by amount of immediate padding"),
173 clEnumValN(ClassSortMode::PaddingPctImmediate, "padding-pct-imm",
174 "Sort classes by percentage of space consumed by immediate "
175 "padding")),
Zachary Turner4dc4f012017-04-13 21:11:00 +0000176 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
177
Zachary Turnerc883a8c2017-04-12 23:18:21 +0000178cl::opt<ClassDefinitionFormat> ClassFormat(
179 "class-definitions", cl::desc("Class definition format"),
Zachary Turnerda949c12017-04-24 17:47:52 +0000180 cl::init(ClassDefinitionFormat::All),
Zachary Turnerc883a8c2017-04-12 23:18:21 +0000181 cl::values(
Zachary Turnerda949c12017-04-24 17:47:52 +0000182 clEnumValN(ClassDefinitionFormat::All, "all",
Zachary Turner9e7dda32017-04-12 23:18:51 +0000183 "Display all class members including data, constants, "
Zachary Turner4dc4f012017-04-13 21:11:00 +0000184 "typedefs, functions, etc"),
Zachary Turnerda949c12017-04-24 17:47:52 +0000185 clEnumValN(ClassDefinitionFormat::Layout, "layout",
Zachary Turnerc883a8c2017-04-12 23:18:21 +0000186 "Only display members that contribute to class size."),
187 clEnumValN(ClassDefinitionFormat::None, "none",
188 "Don't display class definitions")),
189 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turnerda949c12017-04-24 17:47:52 +0000190cl::opt<uint32_t> ClassRecursionDepth(
191 "class-recurse-depth", cl::desc("Class recursion depth (0=no limit)"),
192 cl::init(0), cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turner63230a4e2017-04-06 23:43:12 +0000193
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000194cl::opt<bool> Lines("lines", cl::desc("Line tables"), cl::cat(TypeCategory),
195 cl::sub(PrettySubcommand));
Zachary Turner7797c722015-03-02 04:39:56 +0000196cl::opt<bool>
Zachary Turner7797c722015-03-02 04:39:56 +0000197 All("all", cl::desc("Implies all other options in 'Symbol Types' category"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000198 cl::cat(TypeCategory), cl::sub(PrettySubcommand));
Zachary Turnerf5abda22015-03-01 06:49:49 +0000199
Zachary Turnere5cb2692015-05-01 20:24:26 +0000200cl::opt<uint64_t> LoadAddress(
201 "load-address",
202 cl::desc("Assume the module is loaded at the specified address"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000203 cl::cat(OtherOptions), cl::sub(PrettySubcommand));
Adrian McCarthy65d26882017-03-15 20:17:58 +0000204cl::opt<bool> Native("native", cl::desc("Use native PDB reader instead of DIA"),
Adrian McCarthy1aa207d2017-03-23 15:28:15 +0000205 cl::cat(OtherOptions), cl::sub(PrettySubcommand));
206cl::opt<cl::boolOrDefault>
207 ColorOutput("color-output",
208 cl::desc("Override use of color (default = isatty)"),
209 cl::cat(OtherOptions), cl::sub(PrettySubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000210cl::list<std::string> ExcludeTypes(
211 "exclude-types", cl::desc("Exclude types by regular expression"),
212 cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
213cl::list<std::string> ExcludeSymbols(
214 "exclude-symbols", cl::desc("Exclude symbols by regular expression"),
215 cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
216cl::list<std::string> ExcludeCompilands(
217 "exclude-compilands", cl::desc("Exclude compilands by regular expression"),
218 cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turner4dddcc62015-09-29 19:49:06 +0000219
220cl::list<std::string> IncludeTypes(
221 "include-types",
222 cl::desc("Include only types which match a regular expression"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000223 cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turner4dddcc62015-09-29 19:49:06 +0000224cl::list<std::string> IncludeSymbols(
225 "include-symbols",
226 cl::desc("Include only symbols which match a regular expression"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000227 cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turner4dddcc62015-09-29 19:49:06 +0000228cl::list<std::string> IncludeCompilands(
229 "include-compilands",
230 cl::desc("Include only compilands those which match a regular expression"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000231 cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turner4dc4f012017-04-13 21:11:00 +0000232cl::opt<uint32_t> SizeThreshold(
233 "min-type-size", cl::desc("Displays only those types which are greater "
234 "than or equal to the specified size."),
235 cl::init(0), cl::cat(FilterCategory), cl::sub(PrettySubcommand));
236cl::opt<uint32_t> PaddingThreshold(
237 "min-class-padding", cl::desc("Displays only those classes which have at "
238 "least the specified amount of padding."),
239 cl::init(0), cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turnerda307b62017-04-25 20:22:29 +0000240cl::opt<uint32_t> ImmediatePaddingThreshold(
241 "min-class-padding-imm",
242 cl::desc("Displays only those classes which have at least the specified "
243 "amount of immediate padding, ignoring padding internal to bases "
244 "and aggregates."),
245 cl::init(0), cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turner4dddcc62015-09-29 19:49:06 +0000246
Zachary Turner7797c722015-03-02 04:39:56 +0000247cl::opt<bool> ExcludeCompilerGenerated(
248 "no-compiler-generated",
249 cl::desc("Don't show compiler generated types and symbols"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000250 cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turner7797c722015-03-02 04:39:56 +0000251cl::opt<bool>
252 ExcludeSystemLibraries("no-system-libs",
253 cl::desc("Don't show symbols from system libraries"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000254 cl::cat(FilterCategory), cl::sub(PrettySubcommand));
Zachary Turner10169b62017-04-06 23:43:39 +0000255
Zachary Turner65323652015-03-04 06:09:53 +0000256cl::opt<bool> NoEnumDefs("no-enum-definitions",
257 cl::desc("Don't display full enum definitions"),
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000258 cl::cat(FilterCategory), cl::sub(PrettySubcommand));
259}
260
Zachary Turner6ac232c2017-03-13 23:28:25 +0000261namespace diff {
Zachary Turner6ac232c2017-03-13 23:28:25 +0000262cl::list<std::string> InputFilenames(cl::Positional,
263 cl::desc("<first> <second>"),
264 cl::OneOrMore, cl::sub(DiffSubcommand));
265}
266
Zachary Turner63055452017-06-15 22:24:24 +0000267cl::OptionCategory FileOptions("Module & File Options");
268
Zachary Turner99402032017-06-22 20:58:11 +0000269namespace bytes {
Zachary Turnerdd739682017-06-23 21:11:54 +0000270cl::OptionCategory MsfBytes("MSF File Options");
271cl::OptionCategory DbiBytes("Dbi Stream Options");
272cl::OptionCategory PdbBytes("PDB Stream Options");
Zachary Turnerc2f5b4b2017-06-23 21:50:54 +0000273cl::OptionCategory Types("Type Options");
Zachary Turnerfa332822017-06-23 23:08:57 +0000274cl::OptionCategory ModuleCategory("Module Options");
Zachary Turnerdd739682017-06-23 21:11:54 +0000275
Zachary Turner6b124f22017-06-23 19:54:44 +0000276llvm::Optional<NumberRange> DumpBlockRange;
277llvm::Optional<NumberRange> DumpByteRange;
278
279cl::opt<std::string> DumpBlockRangeOpt(
280 "block-range", cl::value_desc("start[-end]"),
281 cl::desc("Dump binary data from specified range of blocks."),
Zachary Turnerdd739682017-06-23 21:11:54 +0000282 cl::sub(BytesSubcommand), cl::cat(MsfBytes));
Zachary Turner99402032017-06-22 20:58:11 +0000283
284cl::opt<std::string>
Zachary Turner6b124f22017-06-23 19:54:44 +0000285 DumpByteRangeOpt("byte-range", cl::value_desc("start[-end]"),
286 cl::desc("Dump binary data from specified range of bytes"),
Zachary Turnerdd739682017-06-23 21:11:54 +0000287 cl::sub(BytesSubcommand), cl::cat(MsfBytes));
Zachary Turner99402032017-06-22 20:58:11 +0000288
289cl::list<std::string>
290 DumpStreamData("stream-data", cl::CommaSeparated, cl::ZeroOrMore,
291 cl::desc("Dump binary data from specified streams. Format "
292 "is SN[:Start][@Size]"),
Zachary Turnerdd739682017-06-23 21:11:54 +0000293 cl::sub(BytesSubcommand), cl::cat(MsfBytes));
Zachary Turner99402032017-06-22 20:58:11 +0000294
Zachary Turner6c3e41b2017-06-23 20:18:38 +0000295cl::opt<bool> NameMap("name-map", cl::desc("Dump bytes of PDB Name Map"),
Zachary Turnerdd739682017-06-23 21:11:54 +0000296 cl::sub(BytesSubcommand), cl::cat(PdbBytes));
297
298cl::opt<bool> SectionContributions("sc", cl::desc("Dump section contributions"),
299 cl::sub(BytesSubcommand), cl::cat(DbiBytes));
300cl::opt<bool> SectionMap("sm", cl::desc("Dump section map"),
301 cl::sub(BytesSubcommand), cl::cat(DbiBytes));
302cl::opt<bool> ModuleInfos("modi", cl::desc("Dump module info"),
303 cl::sub(BytesSubcommand), cl::cat(DbiBytes));
304cl::opt<bool> FileInfo("files", cl::desc("Dump source file info"),
305 cl::sub(BytesSubcommand), cl::cat(DbiBytes));
306cl::opt<bool> TypeServerMap("type-server", cl::desc("Dump type server map"),
307 cl::sub(BytesSubcommand), cl::cat(DbiBytes));
308cl::opt<bool> ECData("ec", cl::desc("Dump edit and continue map"),
309 cl::sub(BytesSubcommand), cl::cat(DbiBytes));
Zachary Turner6c3e41b2017-06-23 20:18:38 +0000310
Zachary Turnerc2f5b4b2017-06-23 21:50:54 +0000311cl::list<uint32_t>
312 TypeIndex("type",
313 cl::desc("Dump the type record with the given type index"),
314 cl::ZeroOrMore, cl::CommaSeparated, cl::sub(BytesSubcommand),
315 cl::cat(TypeCategory));
316cl::list<uint32_t>
317 IdIndex("id", cl::desc("Dump the id record with the given type index"),
318 cl::ZeroOrMore, cl::CommaSeparated, cl::sub(BytesSubcommand),
319 cl::cat(TypeCategory));
320
Zachary Turnerfa332822017-06-23 23:08:57 +0000321cl::opt<uint32_t> ModuleIndex(
322 "mod",
323 cl::desc(
324 "Limit options in the Modules category to the specified module index"),
325 cl::Optional, cl::sub(BytesSubcommand), cl::cat(ModuleCategory));
326cl::opt<bool> ModuleSyms("syms", cl::desc("Dump symbol record substream"),
327 cl::sub(BytesSubcommand), cl::cat(ModuleCategory));
328cl::opt<bool> ModuleC11("c11-chunks", cl::Hidden,
329 cl::desc("Dump C11 CodeView debug chunks"),
330 cl::sub(BytesSubcommand), cl::cat(ModuleCategory));
331cl::opt<bool> ModuleC13("chunks", cl::desc("Dump C13 CodeView debug chunks"),
332 cl::sub(BytesSubcommand), cl::cat(ModuleCategory));
333
Zachary Turner99402032017-06-22 20:58:11 +0000334cl::list<std::string> InputFilenames(cl::Positional,
335 cl::desc("<input PDB files>"),
336 cl::OneOrMore, cl::sub(BytesSubcommand));
337
338} // namespace bytes
339
Zachary Turner7df69952017-06-22 20:57:39 +0000340namespace dump {
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000341
342cl::OptionCategory MsfOptions("MSF Container Options");
343cl::OptionCategory TypeOptions("Type Record Options");
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000344cl::OptionCategory SymbolOptions("Symbol Options");
345cl::OptionCategory MiscOptions("Miscellaneous Options");
346
347// MSF OPTIONS
Zachary Turner63055452017-06-15 22:24:24 +0000348cl::opt<bool> DumpSummary("summary", cl::desc("dump file summary"),
Zachary Turner7df69952017-06-22 20:57:39 +0000349 cl::cat(MsfOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000350cl::opt<bool> DumpStreams("streams",
351 cl::desc("dump summary of the PDB streams"),
Zachary Turner7df69952017-06-22 20:57:39 +0000352 cl::cat(MsfOptions), cl::sub(DumpSubcommand));
Zachary Turner5f098522017-06-23 20:28:14 +0000353cl::opt<bool> DumpStreamBlocks(
354 "stream-blocks",
355 cl::desc("Add block information to the output of -streams"),
356 cl::cat(MsfOptions), cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000357
358// TYPE OPTIONS
Zachary Turner63055452017-06-15 22:24:24 +0000359cl::opt<bool> DumpTypes("types",
360 cl::desc("dump CodeView type records from TPI stream"),
Zachary Turner7df69952017-06-22 20:57:39 +0000361 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000362cl::opt<bool> DumpTypeData(
363 "type-data",
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000364 cl::desc("dump CodeView type record raw bytes from TPI stream"),
Zachary Turner7df69952017-06-22 20:57:39 +0000365 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000366
Zachary Turnerf8a2e042017-06-15 23:04:42 +0000367cl::opt<bool> DumpTypeExtras("type-extras",
368 cl::desc("dump type hashes and index offsets"),
Zachary Turner7df69952017-06-22 20:57:39 +0000369 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000370
Zachary Turner59224cb2017-06-16 23:42:15 +0000371cl::list<uint32_t> DumpTypeIndex(
372 "type-index", cl::ZeroOrMore,
373 cl::desc("only dump types with the specified hexadecimal type index"),
Zachary Turner7df69952017-06-22 20:57:39 +0000374 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turner59224cb2017-06-16 23:42:15 +0000375
Zachary Turner63055452017-06-15 22:24:24 +0000376cl::opt<bool> DumpIds("ids",
377 cl::desc("dump CodeView type records from IPI stream"),
Zachary Turner7df69952017-06-22 20:57:39 +0000378 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000379cl::opt<bool>
Zachary Turner63055452017-06-15 22:24:24 +0000380 DumpIdData("id-data",
381 cl::desc("dump CodeView type record raw bytes from IPI stream"),
Zachary Turner7df69952017-06-22 20:57:39 +0000382 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000383
Zachary Turnerf8a2e042017-06-15 23:04:42 +0000384cl::opt<bool> DumpIdExtras("id-extras",
385 cl::desc("dump id hashes and index offsets"),
Zachary Turner7df69952017-06-22 20:57:39 +0000386 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turner59224cb2017-06-16 23:42:15 +0000387cl::list<uint32_t> DumpIdIndex(
388 "id-index", cl::ZeroOrMore,
389 cl::desc("only dump ids with the specified hexadecimal type index"),
Zachary Turner7df69952017-06-22 20:57:39 +0000390 cl::cat(TypeOptions), cl::sub(DumpSubcommand));
Zachary Turnerf8a2e042017-06-15 23:04:42 +0000391
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000392// SYMBOL OPTIONS
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000393cl::opt<bool> DumpPublics("publics", cl::desc("dump Publics stream data"),
Zachary Turner7df69952017-06-22 20:57:39 +0000394 cl::cat(SymbolOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000395cl::opt<bool> DumpSymbols("symbols", cl::desc("dump module symbols"),
Zachary Turner7df69952017-06-22 20:57:39 +0000396 cl::cat(SymbolOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000397
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000398cl::opt<bool>
Zachary Turner63055452017-06-15 22:24:24 +0000399 DumpSymRecordBytes("sym-data",
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000400 cl::desc("dump CodeView symbol record raw bytes"),
Zachary Turner7df69952017-06-22 20:57:39 +0000401 cl::cat(SymbolOptions), cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000402
Zachary Turner63055452017-06-15 22:24:24 +0000403// MODULE & FILE OPTIONS
404cl::opt<bool> DumpModules("modules", cl::desc("dump compiland information"),
Zachary Turner7df69952017-06-22 20:57:39 +0000405 cl::cat(FileOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000406cl::opt<bool> DumpModuleFiles(
407 "files",
Zachary Turner4e950642017-06-15 23:56:19 +0000408 cl::desc("Dump the source files that contribute to each module's."),
Zachary Turner7df69952017-06-22 20:57:39 +0000409 cl::cat(FileOptions), cl::sub(DumpSubcommand));
Zachary Turner4e950642017-06-15 23:56:19 +0000410cl::opt<bool> DumpLines(
411 "l",
412 cl::desc("dump source file/line information (DEBUG_S_LINES subsection)"),
Zachary Turner7df69952017-06-22 20:57:39 +0000413 cl::cat(FileOptions), cl::sub(DumpSubcommand));
Zachary Turner4e950642017-06-15 23:56:19 +0000414cl::opt<bool> DumpInlineeLines(
415 "il",
416 cl::desc("dump inlinee line information (DEBUG_S_INLINEELINES subsection)"),
Zachary Turner7df69952017-06-22 20:57:39 +0000417 cl::cat(FileOptions), cl::sub(DumpSubcommand));
Zachary Turner47d9a562017-06-16 00:04:24 +0000418cl::opt<bool> DumpXmi(
419 "xmi",
420 cl::desc(
421 "dump cross module imports (DEBUG_S_CROSSSCOPEIMPORTS subsection)"),
Zachary Turner7df69952017-06-22 20:57:39 +0000422 cl::cat(FileOptions), cl::sub(DumpSubcommand));
Zachary Turner47d9a562017-06-16 00:04:24 +0000423cl::opt<bool> DumpXme(
424 "xme",
425 cl::desc(
426 "dump cross module exports (DEBUG_S_CROSSSCOPEEXPORTS subsection)"),
Zachary Turner7df69952017-06-22 20:57:39 +0000427 cl::cat(FileOptions), cl::sub(DumpSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000428
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000429// MISCELLANEOUS OPTIONS
Zachary Turner760ad4d2017-01-20 22:42:09 +0000430cl::opt<bool> DumpStringTable("string-table", cl::desc("dump PDB String Table"),
Zachary Turner7df69952017-06-22 20:57:39 +0000431 cl::cat(MiscOptions), cl::sub(DumpSubcommand));
Zachary Turner760ad4d2017-01-20 22:42:09 +0000432
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000433cl::opt<bool> DumpSectionContribs("section-contribs",
434 cl::desc("dump section contributions"),
Zachary Turner7df69952017-06-22 20:57:39 +0000435 cl::cat(MiscOptions),
436 cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000437cl::opt<bool> DumpSectionMap("section-map", cl::desc("dump section map"),
Zachary Turner7df69952017-06-22 20:57:39 +0000438 cl::cat(MiscOptions), cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000439
Zachary Turnerab58ae82016-06-30 17:43:00 +0000440cl::opt<bool> RawAll("all", cl::desc("Implies most other options."),
Zachary Turner7df69952017-06-22 20:57:39 +0000441 cl::cat(MiscOptions), cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000442
443cl::list<std::string> InputFilenames(cl::Positional,
444 cl::desc("<input PDB files>"),
Zachary Turner7df69952017-06-22 20:57:39 +0000445 cl::OneOrMore, cl::sub(DumpSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000446}
447
448namespace yaml2pdb {
449cl::opt<std::string>
450 YamlPdbOutputFile("pdb", cl::desc("the name of the PDB file to write"),
451 cl::sub(YamlToPdbSubcommand));
452
Bob Haarmande33a6372017-05-17 20:46:48 +0000453cl::opt<std::string> InputFilename(cl::Positional,
454 cl::desc("<input YAML file>"), cl::Required,
455 cl::sub(YamlToPdbSubcommand));
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000456}
457
458namespace pdb2yaml {
Bob Haarman69fd2b72017-05-26 23:46:20 +0000459cl::opt<bool> All("all",
460 cl::desc("Dump everything we know how to dump."),
461 cl::sub(PdbToYamlSubcommand), cl::init(false));
Zachary Turner3eedd162017-06-08 23:39:33 +0000462cl::opt<bool> NoFileHeaders("no-file-headers",
463 cl::desc("Do not dump MSF file headers"),
464 cl::sub(PdbToYamlSubcommand), cl::init(false));
Zachary Turnerea4e6072017-03-15 22:18:53 +0000465cl::opt<bool> Minimal("minimal",
466 cl::desc("Don't write fields with default values"),
467 cl::sub(PdbToYamlSubcommand), cl::init(false));
Zachary Turnerf6b93822016-07-11 21:45:09 +0000468
Zachary Turnerab58ae82016-06-30 17:43:00 +0000469cl::opt<bool> StreamMetadata(
470 "stream-metadata",
471 cl::desc("Dump the number of streams and each stream's size"),
Zachary Turnerf6b93822016-07-11 21:45:09 +0000472 cl::sub(PdbToYamlSubcommand), cl::init(false));
Zachary Turnerab58ae82016-06-30 17:43:00 +0000473cl::opt<bool> StreamDirectory(
474 "stream-directory",
475 cl::desc("Dump each stream's block map (implies -stream-metadata)"),
Zachary Turnerf6b93822016-07-11 21:45:09 +0000476 cl::sub(PdbToYamlSubcommand), cl::init(false));
Zachary Turnerfaa554b2016-07-15 22:16:56 +0000477cl::opt<bool> PdbStream("pdb-stream",
478 cl::desc("Dump the PDB Stream (Stream 1)"),
479 cl::sub(PdbToYamlSubcommand), cl::init(false));
Zachary Turner760ad4d2017-01-20 22:42:09 +0000480
481cl::opt<bool> StringTable("string-table", cl::desc("Dump the PDB String Table"),
482 cl::sub(PdbToYamlSubcommand), cl::init(false));
483
Zachary Turnerfaa554b2016-07-15 22:16:56 +0000484cl::opt<bool> DbiStream("dbi-stream",
Zachary Turner3eedd162017-06-08 23:39:33 +0000485 cl::desc("Dump the DBI Stream Headers (Stream 2)"),
Zachary Turnerfaa554b2016-07-15 22:16:56 +0000486 cl::sub(PdbToYamlSubcommand), cl::init(false));
Zachary Turneree3b9c22017-04-25 20:22:02 +0000487
Zachary Turnerac5763e2016-08-18 16:49:29 +0000488cl::opt<bool> TpiStream("tpi-stream",
489 cl::desc("Dump the TPI Stream (Stream 3)"),
490 cl::sub(PdbToYamlSubcommand), cl::init(false));
491
Zachary Turnerde9ba152016-09-15 18:22:31 +0000492cl::opt<bool> IpiStream("ipi-stream",
493 cl::desc("Dump the IPI Stream (Stream 5)"),
494 cl::sub(PdbToYamlSubcommand), cl::init(false));
495
Zachary Turner3eedd162017-06-08 23:39:33 +0000496// MODULE & FILE OPTIONS
497cl::opt<bool> DumpModules("modules", cl::desc("dump compiland information"),
Zachary Turner63055452017-06-15 22:24:24 +0000498 cl::cat(FileOptions), cl::sub(PdbToYamlSubcommand));
Zachary Turner3eedd162017-06-08 23:39:33 +0000499cl::opt<bool> DumpModuleFiles("module-files", cl::desc("dump file information"),
Zachary Turner63055452017-06-15 22:24:24 +0000500 cl::cat(FileOptions),
Zachary Turner3eedd162017-06-08 23:39:33 +0000501 cl::sub(PdbToYamlSubcommand));
502cl::list<ModuleSubsection> DumpModuleSubsections(
503 "subsections", cl::ZeroOrMore, cl::CommaSeparated,
504 cl::desc("dump subsections from each module's debug stream"),
505 cl::values(
506 clEnumValN(
507 ModuleSubsection::CrossScopeExports, "cme",
508 "Cross module exports (DEBUG_S_CROSSSCOPEEXPORTS subsection)"),
509 clEnumValN(
510 ModuleSubsection::CrossScopeImports, "cmi",
511 "Cross module imports (DEBUG_S_CROSSSCOPEIMPORTS subsection)"),
512 clEnumValN(ModuleSubsection::FileChecksums, "fc",
513 "File checksums (DEBUG_S_CHECKSUMS subsection)"),
514 clEnumValN(ModuleSubsection::InlineeLines, "ilines",
515 "Inlinee lines (DEBUG_S_INLINEELINES subsection)"),
516 clEnumValN(ModuleSubsection::Lines, "lines",
517 "Lines (DEBUG_S_LINES subsection)"),
Zachary Turnerdeb39132017-06-09 00:28:08 +0000518 clEnumValN(ModuleSubsection::StringTable, "strings",
519 "String Table (DEBUG_S_STRINGTABLE subsection) (not "
520 "typically present in PDB file)"),
521 clEnumValN(ModuleSubsection::FrameData, "frames",
522 "Frame Data (DEBUG_S_FRAMEDATA subsection)"),
523 clEnumValN(ModuleSubsection::Symbols, "symbols",
524 "Symbols (DEBUG_S_SYMBOLS subsection) (not typically "
525 "present in PDB file)"),
Zachary Turner3226fe92017-06-09 20:46:52 +0000526 clEnumValN(ModuleSubsection::CoffSymbolRVAs, "rvas",
527 "COFF Symbol RVAs (DEBUG_S_COFF_SYMBOL_RVA subsection)"),
Zachary Turner28c22c82017-06-09 00:53:59 +0000528 clEnumValN(ModuleSubsection::Unknown, "unknown",
529 "Any subsection not covered by another option"),
Zachary Turner3eedd162017-06-08 23:39:33 +0000530 clEnumValN(ModuleSubsection::All, "all", "All known subsections")),
Zachary Turner63055452017-06-15 22:24:24 +0000531 cl::cat(FileOptions), cl::sub(PdbToYamlSubcommand));
Zachary Turner3eedd162017-06-08 23:39:33 +0000532cl::opt<bool> DumpModuleSyms("module-syms", cl::desc("dump module symbols"),
Zachary Turner63055452017-06-15 22:24:24 +0000533 cl::cat(FileOptions),
Zachary Turner3eedd162017-06-08 23:39:33 +0000534 cl::sub(PdbToYamlSubcommand));
Zachary Turner63055452017-06-15 22:24:24 +0000535
536cl::list<std::string> InputFilename(cl::Positional,
537 cl::desc("<input PDB file>"), cl::Required,
538 cl::sub(PdbToYamlSubcommand));
539} // namespace pdb2yaml
Zachary Turner3eedd162017-06-08 23:39:33 +0000540
Zachary Turnerd50c0132017-02-01 18:30:22 +0000541namespace analyze {
542cl::opt<bool> StringTable("hash-collisions", cl::desc("Find hash collisions"),
543 cl::sub(AnalyzeSubcommand), cl::init(false));
544cl::list<std::string> InputFilename(cl::Positional,
545 cl::desc("<input PDB file>"), cl::Required,
546 cl::sub(AnalyzeSubcommand));
547}
Zachary Turner8fb441a2017-05-18 23:03:41 +0000548
549namespace merge {
550cl::list<std::string> InputFilenames(cl::Positional,
551 cl::desc("<input PDB files>"),
552 cl::OneOrMore, cl::sub(MergeSubcommand));
553cl::opt<std::string>
554 PdbOutputFile("pdb", cl::desc("the name of the PDB file to write"),
555 cl::sub(MergeSubcommand));
556}
Zachary Turner49693b42015-01-28 01:22:33 +0000557}
558
David Majnemerc165c882016-05-28 18:25:15 +0000559static ExitOnError ExitOnErr;
560
Zachary Turner1dc9fd32016-06-14 20:48:36 +0000561static void yamlToPdb(StringRef Path) {
Zachary Turnere109dc62016-07-22 19:56:26 +0000562 BumpPtrAllocator Allocator;
Zachary Turner1dc9fd32016-06-14 20:48:36 +0000563 ErrorOr<std::unique_ptr<MemoryBuffer>> ErrorOrBuffer =
564 MemoryBuffer::getFileOrSTDIN(Path, /*FileSize=*/-1,
565 /*RequiresNullTerminator=*/false);
566
567 if (ErrorOrBuffer.getError()) {
568 ExitOnErr(make_error<GenericError>(generic_error_code::invalid_path, Path));
569 }
570
571 std::unique_ptr<MemoryBuffer> &Buffer = ErrorOrBuffer.get();
572
573 llvm::yaml::Input In(Buffer->getBuffer());
Zachary Turnerc6d54da2016-09-09 17:46:17 +0000574 pdb::yaml::PdbObject YamlObj(Allocator);
Zachary Turner1dc9fd32016-06-14 20:48:36 +0000575 In >> YamlObj;
576
Zachary Turnere109dc62016-07-22 19:56:26 +0000577 PDBFileBuilder Builder(Allocator);
Zachary Turnerdbeaea72016-07-11 21:45:26 +0000578
Zachary Turnerea4e6072017-03-15 22:18:53 +0000579 uint32_t BlockSize = 4096;
580 if (YamlObj.Headers.hasValue())
581 BlockSize = YamlObj.Headers->SuperBlock.BlockSize;
582 ExitOnErr(Builder.initialize(BlockSize));
Zachary Turner620961d2016-09-14 23:00:02 +0000583 // Add each of the reserved streams. We ignore stream metadata in the
584 // yaml, because we will reconstruct our own view of the streams. For
585 // example, the YAML may say that there were 20 streams in the original
586 // PDB, but maybe we only dump a subset of those 20 streams, so we will
587 // have fewer, and the ones we do have may end up with different indices
588 // than the ones in the original PDB. So we just start with a clean slate.
589 for (uint32_t I = 0; I < kSpecialStreamCount; ++I)
590 ExitOnErr(Builder.getMsfBuilder().addStream(0));
Zachary Turner8848a7a2016-07-06 18:05:57 +0000591
Zachary Turnera8cfc292017-06-14 15:59:27 +0000592 StringsAndChecksums Strings;
593 Strings.setStrings(std::make_shared<DebugStringTableSubsection>());
594
Zachary Turner760ad4d2017-01-20 22:42:09 +0000595 if (YamlObj.StringTable.hasValue()) {
Zachary Turner760ad4d2017-01-20 22:42:09 +0000596 for (auto S : *YamlObj.StringTable)
Zachary Turnera8cfc292017-06-14 15:59:27 +0000597 Strings.strings()->insert(S);
Zachary Turner760ad4d2017-01-20 22:42:09 +0000598 }
599
Zachary Turnerea4e6072017-03-15 22:18:53 +0000600 pdb::yaml::PdbInfoStream DefaultInfoStream;
601 pdb::yaml::PdbDbiStream DefaultDbiStream;
602 pdb::yaml::PdbTpiStream DefaultTpiStream;
Zachary Turnerd4136e92017-05-22 21:07:43 +0000603 pdb::yaml::PdbTpiStream DefaultIpiStream;
Zachary Turner1dc9fd32016-06-14 20:48:36 +0000604
Zachary Turnerea4e6072017-03-15 22:18:53 +0000605 const auto &Info = YamlObj.PdbStream.getValueOr(DefaultInfoStream);
606
607 auto &InfoBuilder = Builder.getInfoBuilder();
608 InfoBuilder.setAge(Info.Age);
609 InfoBuilder.setGuid(Info.Guid);
610 InfoBuilder.setSignature(Info.Signature);
611 InfoBuilder.setVersion(Info.Version);
Zachary Turner05d5e612017-03-16 20:19:11 +0000612 for (auto F : Info.Features)
613 InfoBuilder.addFeature(F);
Zachary Turnerea4e6072017-03-15 22:18:53 +0000614
615 const auto &Dbi = YamlObj.DbiStream.getValueOr(DefaultDbiStream);
616 auto &DbiBuilder = Builder.getDbiBuilder();
617 DbiBuilder.setAge(Dbi.Age);
618 DbiBuilder.setBuildNumber(Dbi.BuildNumber);
619 DbiBuilder.setFlags(Dbi.Flags);
620 DbiBuilder.setMachineType(Dbi.MachineType);
621 DbiBuilder.setPdbDllRbld(Dbi.PdbDllRbld);
622 DbiBuilder.setPdbDllVersion(Dbi.PdbDllVersion);
623 DbiBuilder.setVersionHeader(Dbi.VerHeader);
624 for (const auto &MI : Dbi.ModInfos) {
Zachary Turner05d5e612017-03-16 20:19:11 +0000625 auto &ModiBuilder = ExitOnErr(DbiBuilder.addModuleInfo(MI.Mod));
Bob Haarmanea91faf2017-05-25 18:04:17 +0000626 ModiBuilder.setObjFileName(MI.Obj);
Zachary Turnerea4e6072017-03-15 22:18:53 +0000627
628 for (auto S : MI.SourceFiles)
629 ExitOnErr(DbiBuilder.addModuleSourceFile(MI.Mod, S));
630 if (MI.Modi.hasValue()) {
631 const auto &ModiStream = *MI.Modi;
Zachary Turnerebd3ae82017-06-01 21:52:41 +0000632 for (auto Symbol : ModiStream.Symbols) {
633 ModiBuilder.addSymbol(
634 Symbol.toCodeViewSymbol(Allocator, CodeViewContainer::Pdb));
635 }
Zachary Turnerd218c262016-07-22 15:46:37 +0000636 }
Zachary Turner8a2ebfb2017-05-01 23:27:42 +0000637
Zachary Turnera8cfc292017-06-14 15:59:27 +0000638 // Each module has its own checksum subsection, so scan for it every time.
639 Strings.setChecksums(nullptr);
640 CodeViewYAML::initializeStringsAndChecksums(MI.Subsections, Strings);
641
Zachary Turnerdeb39132017-06-09 00:28:08 +0000642 auto CodeViewSubsections = ExitOnErr(CodeViewYAML::toCodeViewSubsectionList(
643 Allocator, MI.Subsections, Strings));
Zachary Turner92dcdda2017-06-02 19:49:14 +0000644 for (auto &SS : CodeViewSubsections) {
Zachary Turnera8cfc292017-06-14 15:59:27 +0000645 ModiBuilder.addDebugSubsection(SS);
Zachary Turner8a2ebfb2017-05-01 23:27:42 +0000646 }
Zachary Turnerdbeaea72016-07-11 21:45:26 +0000647 }
648
Zachary Turnerea4e6072017-03-15 22:18:53 +0000649 auto &TpiBuilder = Builder.getTpiBuilder();
650 const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);
651 TpiBuilder.setVersionHeader(Tpi.Version);
Zachary Turnerd4273832017-05-30 21:53:05 +0000652 for (const auto &R : Tpi.Records) {
653 CVType Type = R.toCodeViewRecord(Allocator);
654 TpiBuilder.addTypeRecord(Type.RecordData, None);
655 }
Zachary Turnerc6d54da2016-09-09 17:46:17 +0000656
Zachary Turnerd4136e92017-05-22 21:07:43 +0000657 const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream);
Zachary Turnerea4e6072017-03-15 22:18:53 +0000658 auto &IpiBuilder = Builder.getIpiBuilder();
659 IpiBuilder.setVersionHeader(Ipi.Version);
Zachary Turnerd4273832017-05-30 21:53:05 +0000660 for (const auto &R : Ipi.Records) {
661 CVType Type = R.toCodeViewRecord(Allocator);
662 IpiBuilder.addTypeRecord(Type.RecordData, None);
663 }
Zachary Turnerde9ba152016-09-15 18:22:31 +0000664
Zachary Turnera8cfc292017-06-14 15:59:27 +0000665 Builder.getStringTableBuilder().setStrings(*Strings.strings());
666
Rui Ueyamafc22cef2016-09-30 20:34:44 +0000667 ExitOnErr(Builder.commit(opts::yaml2pdb::YamlPdbOutputFile));
Zachary Turner1dc9fd32016-06-14 20:48:36 +0000668}
669
Zachary Turner6ac232c2017-03-13 23:28:25 +0000670static PDBFile &loadPDB(StringRef Path, std::unique_ptr<IPDBSession> &Session) {
Adrian McCarthy8f713192017-01-27 00:01:55 +0000671 ExitOnErr(loadDataForPDB(PDB_ReaderType::Native, Path, Session));
Zachary Turner8848a7a2016-07-06 18:05:57 +0000672
Zachary Turner6ac232c2017-03-13 23:28:25 +0000673 NativeSession *NS = static_cast<NativeSession *>(Session.get());
674 return NS->getPDBFile();
675}
676
677static void pdb2Yaml(StringRef Path) {
678 std::unique_ptr<IPDBSession> Session;
679 auto &File = loadPDB(Path, Session);
680
Zachary Turner8848a7a2016-07-06 18:05:57 +0000681 auto O = llvm::make_unique<YAMLOutputStyle>(File);
682 O = llvm::make_unique<YAMLOutputStyle>(File);
683
684 ExitOnErr(O->dump());
685}
686
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000687static void dumpRaw(StringRef Path) {
David Majnemer1573b242016-04-28 23:47:27 +0000688 std::unique_ptr<IPDBSession> Session;
Zachary Turner6ac232c2017-03-13 23:28:25 +0000689 auto &File = loadPDB(Path, Session);
David Majnemer1573b242016-04-28 23:47:27 +0000690
Zachary Turner7df69952017-06-22 20:57:39 +0000691 auto O = llvm::make_unique<DumpOutputStyle>(File);
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000692
693 ExitOnErr(O->dump());
694}
695
Zachary Turner99402032017-06-22 20:58:11 +0000696static void dumpBytes(StringRef Path) {
697 std::unique_ptr<IPDBSession> Session;
698 auto &File = loadPDB(Path, Session);
699
700 auto O = llvm::make_unique<BytesOutputStyle>(File);
701
702 ExitOnErr(O->dump());
703}
704
Zachary Turnerd50c0132017-02-01 18:30:22 +0000705static void dumpAnalysis(StringRef Path) {
706 std::unique_ptr<IPDBSession> Session;
Zachary Turner6ac232c2017-03-13 23:28:25 +0000707 auto &File = loadPDB(Path, Session);
Zachary Turnerd50c0132017-02-01 18:30:22 +0000708 auto O = llvm::make_unique<AnalysisStyle>(File);
709
710 ExitOnErr(O->dump());
711}
712
Zachary Turner6ac232c2017-03-13 23:28:25 +0000713static void diff(StringRef Path1, StringRef Path2) {
714 std::unique_ptr<IPDBSession> Session1;
715 std::unique_ptr<IPDBSession> Session2;
716
717 auto &File1 = loadPDB(Path1, Session1);
718 auto &File2 = loadPDB(Path2, Session2);
719
720 auto O = llvm::make_unique<DiffStyle>(File1, File2);
721
722 ExitOnErr(O->dump());
723}
724
Zachary Turner0683be22017-05-14 01:13:40 +0000725bool opts::pretty::shouldDumpSymLevel(SymLevel Search) {
726 if (SymTypes.empty())
727 return true;
728 if (llvm::find(SymTypes, Search) != SymTypes.end())
729 return true;
730 if (llvm::find(SymTypes, SymLevel::All) != SymTypes.end())
731 return true;
732 return false;
733}
734
735uint32_t llvm::pdb::getTypeLength(const PDBSymbolData &Symbol) {
736 auto SymbolType = Symbol.getType();
737 const IPDBRawSymbol &RawType = SymbolType->getRawSymbol();
738
739 return RawType.getLength();
740}
741
742bool opts::pretty::compareFunctionSymbols(
743 const std::unique_ptr<PDBSymbolFunc> &F1,
744 const std::unique_ptr<PDBSymbolFunc> &F2) {
745 assert(opts::pretty::SymbolOrder != opts::pretty::SymbolSortMode::None);
746
747 if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::Name)
748 return F1->getName() < F2->getName();
749
750 // Note that we intentionally sort in descending order on length, since
751 // long functions are more interesting than short functions.
752 return F1->getLength() > F2->getLength();
753}
754
755bool opts::pretty::compareDataSymbols(
756 const std::unique_ptr<PDBSymbolData> &F1,
757 const std::unique_ptr<PDBSymbolData> &F2) {
758 assert(opts::pretty::SymbolOrder != opts::pretty::SymbolSortMode::None);
759
760 if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::Name)
761 return F1->getName() < F2->getName();
762
763 // Note that we intentionally sort in descending order on length, since
764 // large types are more interesting than short ones.
765 return getTypeLength(*F1) > getTypeLength(*F2);
766}
767
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000768static void dumpPretty(StringRef Path) {
769 std::unique_ptr<IPDBSession> Session;
David Majnemer1573b242016-04-28 23:47:27 +0000770
Adrian McCarthy65d26882017-03-15 20:17:58 +0000771 const auto ReaderType =
772 opts::pretty::Native ? PDB_ReaderType::Native : PDB_ReaderType::DIA;
773 ExitOnErr(loadDataForPDB(ReaderType, Path, Session));
David Majnemer1573b242016-04-28 23:47:27 +0000774
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000775 if (opts::pretty::LoadAddress)
776 Session->setLoadAddress(opts::pretty::LoadAddress);
Zachary Turner7058dfc2015-01-27 22:40:14 +0000777
Adrian McCarthy1aa207d2017-03-23 15:28:15 +0000778 auto &Stream = outs();
779 const bool UseColor = opts::pretty::ColorOutput == cl::BOU_UNSET
780 ? Stream.has_colors()
781 : opts::pretty::ColorOutput == cl::BOU_TRUE;
782 LinePrinter Printer(2, UseColor, Stream);
Zachary Turner2d11c202015-02-27 09:15:59 +0000783
Zachary Turnera5549172015-02-10 22:43:25 +0000784 auto GlobalScope(Session->getGlobalScope());
Zachary Turner9a818ad2015-02-22 22:03:38 +0000785 std::string FileName(GlobalScope->getSymbolsFileName());
786
Zachary Turner2d11c202015-02-27 09:15:59 +0000787 WithColor(Printer, PDB_ColorItem::None).get() << "Summary for ";
788 WithColor(Printer, PDB_ColorItem::Path).get() << FileName;
789 Printer.Indent();
Zachary Turner9a818ad2015-02-22 22:03:38 +0000790 uint64_t FileSize = 0;
Zachary Turner9a818ad2015-02-22 22:03:38 +0000791
Zachary Turner2d11c202015-02-27 09:15:59 +0000792 Printer.NewLine();
793 WithColor(Printer, PDB_ColorItem::Identifier).get() << "Size";
David Majnemer6e081262015-10-15 01:27:19 +0000794 if (!sys::fs::file_size(FileName, FileSize)) {
Zachary Turner2d11c202015-02-27 09:15:59 +0000795 Printer << ": " << FileSize << " bytes";
796 } else {
797 Printer << ": (Unable to obtain file size)";
798 }
799
800 Printer.NewLine();
801 WithColor(Printer, PDB_ColorItem::Identifier).get() << "Guid";
802 Printer << ": " << GlobalScope->getGuid();
803
804 Printer.NewLine();
805 WithColor(Printer, PDB_ColorItem::Identifier).get() << "Age";
806 Printer << ": " << GlobalScope->getAge();
807
808 Printer.NewLine();
809 WithColor(Printer, PDB_ColorItem::Identifier).get() << "Attributes";
810 Printer << ": ";
Zachary Turner9a818ad2015-02-22 22:03:38 +0000811 if (GlobalScope->hasCTypes())
812 outs() << "HasCTypes ";
813 if (GlobalScope->hasPrivateSymbols())
814 outs() << "HasPrivateSymbols ";
Zachary Turner2d11c202015-02-27 09:15:59 +0000815 Printer.Unindent();
Zachary Turner9a818ad2015-02-22 22:03:38 +0000816
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000817 if (opts::pretty::Compilands) {
Zachary Turner2d11c202015-02-27 09:15:59 +0000818 Printer.NewLine();
819 WithColor(Printer, PDB_ColorItem::SectionHeader).get()
820 << "---COMPILANDS---";
821 Printer.Indent();
Zachary Turnerc074de02015-02-12 21:09:24 +0000822 auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
Zachary Turner2d11c202015-02-27 09:15:59 +0000823 CompilandDumper Dumper(Printer);
Zachary Turnera99000d2016-03-08 21:42:24 +0000824 CompilandDumpFlags options = CompilandDumper::Flags::None;
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000825 if (opts::pretty::Lines)
Zachary Turnera99000d2016-03-08 21:42:24 +0000826 options = options | CompilandDumper::Flags::Lines;
Zachary Turner9a818ad2015-02-22 22:03:38 +0000827 while (auto Compiland = Compilands->getNext())
Zachary Turnera99000d2016-03-08 21:42:24 +0000828 Dumper.start(*Compiland, options);
Zachary Turner2d11c202015-02-27 09:15:59 +0000829 Printer.Unindent();
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000830 }
831
Zachary Turner63230a4e2017-04-06 23:43:12 +0000832 if (opts::pretty::Classes || opts::pretty::Enums || opts::pretty::Typedefs) {
Zachary Turner2d11c202015-02-27 09:15:59 +0000833 Printer.NewLine();
834 WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---TYPES---";
835 Printer.Indent();
Zachary Turner65323652015-03-04 06:09:53 +0000836 TypeDumper Dumper(Printer);
Zachary Turnerb52d08d2015-03-01 06:51:29 +0000837 Dumper.start(*GlobalScope);
Zachary Turner2d11c202015-02-27 09:15:59 +0000838 Printer.Unindent();
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000839 }
840
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000841 if (opts::pretty::Symbols) {
Zachary Turner2d11c202015-02-27 09:15:59 +0000842 Printer.NewLine();
843 WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---SYMBOLS---";
844 Printer.Indent();
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000845 auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
Zachary Turner2d11c202015-02-27 09:15:59 +0000846 CompilandDumper Dumper(Printer);
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000847 while (auto Compiland = Compilands->getNext())
Zachary Turnerb52d08d2015-03-01 06:51:29 +0000848 Dumper.start(*Compiland, true);
Zachary Turner2d11c202015-02-27 09:15:59 +0000849 Printer.Unindent();
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000850 }
851
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000852 if (opts::pretty::Globals) {
Zachary Turner2d11c202015-02-27 09:15:59 +0000853 Printer.NewLine();
854 WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---GLOBALS---";
855 Printer.Indent();
Zachary Turner0683be22017-05-14 01:13:40 +0000856 if (shouldDumpSymLevel(opts::pretty::SymLevel::Functions)) {
Zachary Turner2d11c202015-02-27 09:15:59 +0000857 FunctionDumper Dumper(Printer);
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000858 auto Functions = GlobalScope->findAllChildren<PDBSymbolFunc>();
Zachary Turner0683be22017-05-14 01:13:40 +0000859 if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
860 while (auto Function = Functions->getNext()) {
861 Printer.NewLine();
862 Dumper.start(*Function, FunctionDumper::PointerType::None);
863 }
864 } else {
865 std::vector<std::unique_ptr<PDBSymbolFunc>> Funcs;
866 while (auto Func = Functions->getNext())
867 Funcs.push_back(std::move(Func));
868 std::sort(Funcs.begin(), Funcs.end(),
869 opts::pretty::compareFunctionSymbols);
870 for (const auto &Func : Funcs) {
871 Printer.NewLine();
872 Dumper.start(*Func, FunctionDumper::PointerType::None);
873 }
Zachary Turner2d11c202015-02-27 09:15:59 +0000874 }
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000875 }
Zachary Turner0683be22017-05-14 01:13:40 +0000876 if (shouldDumpSymLevel(opts::pretty::SymLevel::Data)) {
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000877 auto Vars = GlobalScope->findAllChildren<PDBSymbolData>();
Zachary Turner2d11c202015-02-27 09:15:59 +0000878 VariableDumper Dumper(Printer);
Zachary Turner0683be22017-05-14 01:13:40 +0000879 if (opts::pretty::SymbolOrder == opts::pretty::SymbolSortMode::None) {
880 while (auto Var = Vars->getNext())
881 Dumper.start(*Var);
882 } else {
883 std::vector<std::unique_ptr<PDBSymbolData>> Datas;
884 while (auto Var = Vars->getNext())
885 Datas.push_back(std::move(Var));
886 std::sort(Datas.begin(), Datas.end(), opts::pretty::compareDataSymbols);
887 for (const auto &Var : Datas)
888 Dumper.start(*Var);
889 }
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000890 }
Zachary Turner0683be22017-05-14 01:13:40 +0000891 if (shouldDumpSymLevel(opts::pretty::SymLevel::Thunks)) {
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000892 auto Thunks = GlobalScope->findAllChildren<PDBSymbolThunk>();
Zachary Turner2d11c202015-02-27 09:15:59 +0000893 CompilandDumper Dumper(Printer);
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000894 while (auto Thunk = Thunks->getNext())
Zachary Turnerb52d08d2015-03-01 06:51:29 +0000895 Dumper.dump(*Thunk);
Zachary Turnerdb18f5c2015-02-27 09:15:18 +0000896 }
Zachary Turner2d11c202015-02-27 09:15:59 +0000897 Printer.Unindent();
Zachary Turner7058dfc2015-01-27 22:40:14 +0000898 }
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000899 if (opts::pretty::Externals) {
Zachary Turnere5cb2692015-05-01 20:24:26 +0000900 Printer.NewLine();
901 WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---EXTERNALS---";
902 Printer.Indent();
903 ExternalSymbolDumper Dumper(Printer);
904 Dumper.start(*GlobalScope);
905 }
Zachary Turnera30bd1a2016-06-30 17:42:48 +0000906 if (opts::pretty::Lines) {
Zachary Turnera99000d2016-03-08 21:42:24 +0000907 Printer.NewLine();
908 }
Zachary Turnera5549172015-02-10 22:43:25 +0000909 outs().flush();
Zachary Turnerfcb14ad2015-01-27 20:46:21 +0000910}
911
Zachary Turner8fb441a2017-05-18 23:03:41 +0000912static void mergePdbs() {
913 BumpPtrAllocator Allocator;
914 TypeTableBuilder MergedTpi(Allocator);
915 TypeTableBuilder MergedIpi(Allocator);
916
917 // Create a Tpi and Ipi type table with all types from all input files.
918 for (const auto &Path : opts::merge::InputFilenames) {
919 std::unique_ptr<IPDBSession> Session;
920 auto &File = loadPDB(Path, Session);
Zachary Turnerd4136e92017-05-22 21:07:43 +0000921 SmallVector<TypeIndex, 128> TypeMap;
922 SmallVector<TypeIndex, 128> IdMap;
Zachary Turner8fb441a2017-05-18 23:03:41 +0000923 if (File.hasPDBTpiStream()) {
924 auto &Tpi = ExitOnErr(File.getPDBTpiStream());
Zachary Turnerd4136e92017-05-22 21:07:43 +0000925 ExitOnErr(codeview::mergeTypeRecords(MergedTpi, TypeMap, nullptr,
Zachary Turnercfd80652017-05-24 00:35:32 +0000926 Tpi.typeArray()));
Zachary Turner8fb441a2017-05-18 23:03:41 +0000927 }
928 if (File.hasPDBIpiStream()) {
929 auto &Ipi = ExitOnErr(File.getPDBIpiStream());
Zachary Turnerd4136e92017-05-22 21:07:43 +0000930 ExitOnErr(codeview::mergeIdRecords(MergedIpi, TypeMap, IdMap,
Zachary Turnercfd80652017-05-24 00:35:32 +0000931 Ipi.typeArray()));
Zachary Turner8fb441a2017-05-18 23:03:41 +0000932 }
933 }
934
935 // Then write the PDB.
936 PDBFileBuilder Builder(Allocator);
937 ExitOnErr(Builder.initialize(4096));
938 // Add each of the reserved streams. We might not put any data in them,
939 // but at least they have to be present.
940 for (uint32_t I = 0; I < kSpecialStreamCount; ++I)
941 ExitOnErr(Builder.getMsfBuilder().addStream(0));
942
943 auto &DestTpi = Builder.getTpiBuilder();
944 auto &DestIpi = Builder.getIpiBuilder();
Reid Klecknerded38802017-05-23 18:23:59 +0000945 MergedTpi.ForEachRecord([&DestTpi](TypeIndex TI, ArrayRef<uint8_t> Data) {
946 DestTpi.addTypeRecord(Data, None);
947 });
948 MergedIpi.ForEachRecord([&DestIpi](TypeIndex TI, ArrayRef<uint8_t> Data) {
949 DestIpi.addTypeRecord(Data, None);
950 });
Zachary Turner990d0c82017-06-12 21:34:53 +0000951 Builder.getInfoBuilder().addFeature(PdbRaw_FeatureSig::VC140);
Zachary Turner8fb441a2017-05-18 23:03:41 +0000952
Zachary Turnerbdc16ed2017-05-19 06:25:09 +0000953 SmallString<64> OutFile(opts::merge::PdbOutputFile);
Zachary Turner8fb441a2017-05-18 23:03:41 +0000954 if (OutFile.empty()) {
955 OutFile = opts::merge::InputFilenames[0];
956 llvm::sys::path::replace_extension(OutFile, "merged.pdb");
957 }
958 ExitOnErr(Builder.commit(OutFile));
959}
960
Zachary Turner6b124f22017-06-23 19:54:44 +0000961static bool parseRange(StringRef Str,
962 Optional<opts::bytes::NumberRange> &Parsed) {
963 if (Str.empty())
Zachary Turner99402032017-06-22 20:58:11 +0000964 return true;
965
966 llvm::Regex R("^([^-]+)(-([^-]+))?$");
967 llvm::SmallVector<llvm::StringRef, 2> Matches;
Zachary Turner6b124f22017-06-23 19:54:44 +0000968 if (!R.match(Str, &Matches))
Zachary Turner99402032017-06-22 20:58:11 +0000969 return false;
970
Zachary Turner6b124f22017-06-23 19:54:44 +0000971 Parsed.emplace();
972 if (!to_integer(Matches[1], Parsed->Min))
Zachary Turner99402032017-06-22 20:58:11 +0000973 return false;
974
975 if (!Matches[3].empty()) {
Zachary Turner6b124f22017-06-23 19:54:44 +0000976 Parsed->Max.emplace();
977 if (!to_integer(Matches[3], *Parsed->Max))
Zachary Turner99402032017-06-22 20:58:11 +0000978 return false;
979 }
980 return true;
981}
982
Zachary Turnerfcb14ad2015-01-27 20:46:21 +0000983int main(int argc_, const char *argv_[]) {
984 // Print a stack trace if we signal out.
Richard Smith2ad6d482016-06-09 00:53:21 +0000985 sys::PrintStackTraceOnErrorSignal(argv_[0]);
Zachary Turnerfcb14ad2015-01-27 20:46:21 +0000986 PrettyStackTraceProgram X(argc_, argv_);
987
Zachary Turnerbd336e42017-06-09 20:46:17 +0000988 ExitOnErr.setBanner("llvm-pdbutil: ");
David Majnemerc165c882016-05-28 18:25:15 +0000989
Zachary Turnerfcb14ad2015-01-27 20:46:21 +0000990 SmallVector<const char *, 256> argv;
David Majnemer6e081262015-10-15 01:27:19 +0000991 SpecificBumpPtrAllocator<char> ArgAllocator;
David Majnemerc165c882016-05-28 18:25:15 +0000992 ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
993 argv, makeArrayRef(argv_, argc_), ArgAllocator)));
Zachary Turnerfcb14ad2015-01-27 20:46:21 +0000994
995 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
996
997 cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
Zachary Turner6b124f22017-06-23 19:54:44 +0000998
999 if (opts::BytesSubcommand) {
1000 if (!parseRange(opts::bytes::DumpBlockRangeOpt,
1001 opts::bytes::DumpBlockRange)) {
1002 errs() << "Argument '" << opts::bytes::DumpBlockRangeOpt
1003 << "' invalid format.\n";
1004 errs().flush();
1005 exit(1);
1006 }
1007 if (!parseRange(opts::bytes::DumpByteRangeOpt,
1008 opts::bytes::DumpByteRange)) {
1009 errs() << "Argument '" << opts::bytes::DumpByteRangeOpt
1010 << "' invalid format.\n";
1011 errs().flush();
1012 exit(1);
1013 }
Zachary Turner72c5b642016-09-09 18:17:52 +00001014 }
Zachary Turnera99000d2016-03-08 21:42:24 +00001015
Zachary Turner7df69952017-06-22 20:57:39 +00001016 if (opts::DumpSubcommand) {
1017 if (opts::dump::RawAll) {
1018 opts::dump::DumpLines = true;
1019 opts::dump::DumpInlineeLines = true;
1020 opts::dump::DumpXme = true;
1021 opts::dump::DumpXmi = true;
1022 opts::dump::DumpIds = true;
1023 opts::dump::DumpPublics = true;
1024 opts::dump::DumpSectionContribs = true;
1025 opts::dump::DumpSectionMap = true;
1026 opts::dump::DumpStreams = true;
Zachary Turner5f098522017-06-23 20:28:14 +00001027 opts::dump::DumpStreamBlocks = true;
Zachary Turner7df69952017-06-22 20:57:39 +00001028 opts::dump::DumpStringTable = true;
1029 opts::dump::DumpSummary = true;
1030 opts::dump::DumpSymbols = true;
1031 opts::dump::DumpIds = true;
1032 opts::dump::DumpIdExtras = true;
1033 opts::dump::DumpTypes = true;
1034 opts::dump::DumpTypeExtras = true;
1035 opts::dump::DumpModules = true;
1036 opts::dump::DumpModuleFiles = true;
Zachary Turner44a643c2017-01-12 22:28:15 +00001037 }
Zachary Turner7797c722015-03-02 04:39:56 +00001038 }
Zachary Turner3eedd162017-06-08 23:39:33 +00001039 if (opts::PdbToYamlSubcommand) {
1040 if (opts::pdb2yaml::All) {
1041 opts::pdb2yaml::StreamMetadata = true;
1042 opts::pdb2yaml::StreamDirectory = true;
1043 opts::pdb2yaml::PdbStream = true;
1044 opts::pdb2yaml::StringTable = true;
1045 opts::pdb2yaml::DbiStream = true;
1046 opts::pdb2yaml::TpiStream = true;
1047 opts::pdb2yaml::IpiStream = true;
Zachary Turner63055452017-06-15 22:24:24 +00001048 opts::pdb2yaml::DumpModules = true;
1049 opts::pdb2yaml::DumpModuleFiles = true;
1050 opts::pdb2yaml::DumpModuleSyms = true;
1051 opts::pdb2yaml::DumpModuleSubsections.push_back(
1052 opts::ModuleSubsection::All);
1053 if (llvm::is_contained(opts::pdb2yaml::DumpModuleSubsections,
1054 opts::ModuleSubsection::All)) {
1055 opts::pdb2yaml::DumpModuleSubsections.reset();
1056 opts::pdb2yaml::DumpModuleSubsections.push_back(
1057 opts::ModuleSubsection::All);
1058 }
Zachary Turner3eedd162017-06-08 23:39:33 +00001059 }
Zachary Turner63055452017-06-15 22:24:24 +00001060
1061 if (opts::pdb2yaml::DumpModuleSyms || opts::pdb2yaml::DumpModuleFiles)
1062 opts::pdb2yaml::DumpModules = true;
1063
1064 if (opts::pdb2yaml::DumpModules)
1065 opts::pdb2yaml::DbiStream = true;
Zachary Turner3eedd162017-06-08 23:39:33 +00001066 }
Zachary Turnerfcb14ad2015-01-27 20:46:21 +00001067
Zachary Turner93839cb2016-06-02 05:07:49 +00001068 llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded);
Zachary Turnerfcb14ad2015-01-27 20:46:21 +00001069
Zachary Turnera30bd1a2016-06-30 17:42:48 +00001070 if (opts::PdbToYamlSubcommand) {
Zachary Turner8848a7a2016-07-06 18:05:57 +00001071 pdb2Yaml(opts::pdb2yaml::InputFilename.front());
Zachary Turnera30bd1a2016-06-30 17:42:48 +00001072 } else if (opts::YamlToPdbSubcommand) {
Bob Haarmande33a6372017-05-17 20:46:48 +00001073 if (opts::yaml2pdb::YamlPdbOutputFile.empty()) {
1074 SmallString<16> OutputFilename(opts::yaml2pdb::InputFilename.getValue());
1075 sys::path::replace_extension(OutputFilename, ".pdb");
1076 opts::yaml2pdb::YamlPdbOutputFile = OutputFilename.str();
1077 }
1078 yamlToPdb(opts::yaml2pdb::InputFilename);
Zachary Turnerd50c0132017-02-01 18:30:22 +00001079 } else if (opts::AnalyzeSubcommand) {
1080 dumpAnalysis(opts::analyze::InputFilename.front());
Zachary Turnera30bd1a2016-06-30 17:42:48 +00001081 } else if (opts::PrettySubcommand) {
1082 if (opts::pretty::Lines)
1083 opts::pretty::Compilands = true;
1084
1085 if (opts::pretty::All) {
1086 opts::pretty::Compilands = true;
1087 opts::pretty::Symbols = true;
1088 opts::pretty::Globals = true;
1089 opts::pretty::Types = true;
1090 opts::pretty::Externals = true;
1091 opts::pretty::Lines = true;
1092 }
1093
Zachary Turner63230a4e2017-04-06 23:43:12 +00001094 if (opts::pretty::Types) {
1095 opts::pretty::Classes = true;
1096 opts::pretty::Typedefs = true;
1097 opts::pretty::Enums = true;
1098 }
1099
Zachary Turnera30bd1a2016-06-30 17:42:48 +00001100 // When adding filters for excluded compilands and types, we need to
Zachary Turner72c5b642016-09-09 18:17:52 +00001101 // remember that these are regexes. So special characters such as * and \
1102 // need to be escaped in the regex. In the case of a literal \, this means
1103 // it needs to be escaped again in the C++. So matching a single \ in the
1104 // input requires 4 \es in the C++.
Zachary Turnera30bd1a2016-06-30 17:42:48 +00001105 if (opts::pretty::ExcludeCompilerGenerated) {
1106 opts::pretty::ExcludeTypes.push_back("__vc_attributes");
1107 opts::pretty::ExcludeCompilands.push_back("\\* Linker \\*");
1108 }
1109 if (opts::pretty::ExcludeSystemLibraries) {
1110 opts::pretty::ExcludeCompilands.push_back(
1111 "f:\\\\binaries\\\\Intermediate\\\\vctools\\\\crt_bld");
1112 opts::pretty::ExcludeCompilands.push_back("f:\\\\dd\\\\vctools\\\\crt");
1113 opts::pretty::ExcludeCompilands.push_back(
1114 "d:\\\\th.obj.x86fre\\\\minkernel");
1115 }
1116 std::for_each(opts::pretty::InputFilenames.begin(),
1117 opts::pretty::InputFilenames.end(), dumpPretty);
Zachary Turner7df69952017-06-22 20:57:39 +00001118 } else if (opts::DumpSubcommand) {
1119 std::for_each(opts::dump::InputFilenames.begin(),
1120 opts::dump::InputFilenames.end(), dumpRaw);
Zachary Turner99402032017-06-22 20:58:11 +00001121 } else if (opts::BytesSubcommand) {
1122 std::for_each(opts::bytes::InputFilenames.begin(),
1123 opts::bytes::InputFilenames.end(), dumpBytes);
Zachary Turner6ac232c2017-03-13 23:28:25 +00001124 } else if (opts::DiffSubcommand) {
1125 if (opts::diff::InputFilenames.size() != 2) {
1126 errs() << "diff subcommand expects exactly 2 arguments.\n";
1127 exit(1);
1128 }
1129 diff(opts::diff::InputFilenames[0], opts::diff::InputFilenames[1]);
Zachary Turner8fb441a2017-05-18 23:03:41 +00001130 } else if (opts::MergeSubcommand) {
1131 if (opts::merge::InputFilenames.size() < 2) {
1132 errs() << "merge subcommand requires at least 2 input files.\n";
1133 exit(1);
1134 }
1135 mergePdbs();
Zachary Turner1dc9fd32016-06-14 20:48:36 +00001136 }
Zachary Turnerfcb14ad2015-01-27 20:46:21 +00001137
Zachary Turner819e77d2016-05-06 20:51:57 +00001138 outs().flush();
Zachary Turnerfcb14ad2015-01-27 20:46:21 +00001139 return 0;
1140}