Zachary Turner | bd336e4 | 2017-06-09 20:46:17 +0000 | [diff] [blame] | 1 | //===- llvm-pdbutil.cpp - Dump debug info from a PDB file -------*- C++ -*-===// |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 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 | // |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 10 | // Dumps debug information present in PDB files. |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Zachary Turner | bd336e4 | 2017-06-09 20:46:17 +0000 | [diff] [blame] | 14 | #include "llvm-pdbutil.h" |
Zachary Turner | d50c013 | 2017-02-01 18:30:22 +0000 | [diff] [blame] | 15 | |
| 16 | #include "Analyze.h" |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 17 | #include "BytesOutputStyle.h" |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 18 | #include "Diff.h" |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 19 | #include "DumpOutputStyle.h" |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 20 | #include "LinePrinter.h" |
Zachary Turner | d311739 | 2016-06-03 19:28:33 +0000 | [diff] [blame] | 21 | #include "OutputStyle.h" |
Zachary Turner | a9054dd | 2017-01-11 00:35:43 +0000 | [diff] [blame] | 22 | #include "PrettyCompilandDumper.h" |
| 23 | #include "PrettyExternalSymbolDumper.h" |
| 24 | #include "PrettyFunctionDumper.h" |
| 25 | #include "PrettyTypeDumper.h" |
| 26 | #include "PrettyVariableDumper.h" |
Zachary Turner | 7120a47 | 2016-06-06 20:37:05 +0000 | [diff] [blame] | 27 | #include "YAMLOutputStyle.h" |
Zachary Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 28 | |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 29 | #include "llvm/ADT/ArrayRef.h" |
David Majnemer | 6e08126 | 2015-10-15 01:27:19 +0000 | [diff] [blame] | 30 | #include "llvm/ADT/BitVector.h" |
| 31 | #include "llvm/ADT/DenseMap.h" |
Zachary Turner | 8a2ebfb | 2017-05-01 23:27:42 +0000 | [diff] [blame] | 32 | #include "llvm/ADT/STLExtras.h" |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 33 | #include "llvm/ADT/StringExtras.h" |
Zachary Turner | 8d7fa9b | 2015-02-10 22:47:14 +0000 | [diff] [blame] | 34 | #include "llvm/Config/config.h" |
Zachary Turner | 8c099fe | 2017-05-30 16:36:15 +0000 | [diff] [blame] | 35 | #include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h" |
| 36 | #include "llvm/DebugInfo/CodeView/DebugInlineeLinesSubsection.h" |
| 37 | #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h" |
Zachary Turner | 526f4f2 | 2017-05-19 19:26:58 +0000 | [diff] [blame] | 38 | #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h" |
Zachary Turner | a8cfc29 | 2017-06-14 15:59:27 +0000 | [diff] [blame] | 39 | #include "llvm/DebugInfo/CodeView/StringsAndChecksums.h" |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 40 | #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h" |
Zachary Turner | b32ec02 | 2017-05-18 23:04:08 +0000 | [diff] [blame] | 41 | #include "llvm/DebugInfo/CodeView/TypeTableBuilder.h" |
Zachary Turner | a3225b0 | 2016-07-29 20:56:36 +0000 | [diff] [blame] | 42 | #include "llvm/DebugInfo/MSF/MSFBuilder.h" |
Zachary Turner | 819e77d | 2016-05-06 20:51:57 +0000 | [diff] [blame] | 43 | #include "llvm/DebugInfo/PDB/GenericError.h" |
Zachary Turner | a554917 | 2015-02-10 22:43:25 +0000 | [diff] [blame] | 44 | #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h" |
Zachary Turner | a554917 | 2015-02-10 22:43:25 +0000 | [diff] [blame] | 45 | #include "llvm/DebugInfo/PDB/IPDBRawSymbol.h" |
Chandler Carruth | 71f308a | 2015-02-13 09:09:03 +0000 | [diff] [blame] | 46 | #include "llvm/DebugInfo/PDB/IPDBSession.h" |
Zachary Turner | 67c5601 | 2017-04-27 16:11:19 +0000 | [diff] [blame] | 47 | #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h" |
Adrian McCarthy | 6b6b8c4 | 2017-01-25 22:38:55 +0000 | [diff] [blame] | 48 | #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 Turner | e204a6c | 2017-05-02 18:00:13 +0000 | [diff] [blame] | 55 | #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h" |
Adrian McCarthy | 6b6b8c4 | 2017-01-25 22:38:55 +0000 | [diff] [blame] | 56 | #include "llvm/DebugInfo/PDB/Native/RawConstants.h" |
| 57 | #include "llvm/DebugInfo/PDB/Native/RawError.h" |
Adrian McCarthy | 6b6b8c4 | 2017-01-25 22:38:55 +0000 | [diff] [blame] | 58 | #include "llvm/DebugInfo/PDB/Native/TpiStream.h" |
| 59 | #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h" |
Chandler Carruth | 71f308a | 2015-02-13 09:09:03 +0000 | [diff] [blame] | 60 | #include "llvm/DebugInfo/PDB/PDB.h" |
Zachary Turner | a554917 | 2015-02-10 22:43:25 +0000 | [diff] [blame] | 61 | #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h" |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 62 | #include "llvm/DebugInfo/PDB/PDBSymbolData.h" |
Chandler Carruth | 71f308a | 2015-02-13 09:09:03 +0000 | [diff] [blame] | 63 | #include "llvm/DebugInfo/PDB/PDBSymbolExe.h" |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 64 | #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h" |
| 65 | #include "llvm/DebugInfo/PDB/PDBSymbolThunk.h" |
Zachary Turner | d9dc282 | 2017-03-02 20:52:51 +0000 | [diff] [blame] | 66 | #include "llvm/Support/BinaryByteStream.h" |
Zachary Turner | 93839cb | 2016-06-02 05:07:49 +0000 | [diff] [blame] | 67 | #include "llvm/Support/COM.h" |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 68 | #include "llvm/Support/CommandLine.h" |
| 69 | #include "llvm/Support/ConvertUTF.h" |
Zachary Turner | 1dc9fd3 | 2016-06-14 20:48:36 +0000 | [diff] [blame] | 70 | #include "llvm/Support/FileOutputBuffer.h" |
Zachary Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 71 | #include "llvm/Support/FileSystem.h" |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 72 | #include "llvm/Support/Format.h" |
| 73 | #include "llvm/Support/ManagedStatic.h" |
David Majnemer | 6e08126 | 2015-10-15 01:27:19 +0000 | [diff] [blame] | 74 | #include "llvm/Support/MemoryBuffer.h" |
Bob Haarman | de33a637 | 2017-05-17 20:46:48 +0000 | [diff] [blame] | 75 | #include "llvm/Support/Path.h" |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 76 | #include "llvm/Support/PrettyStackTrace.h" |
Chandler Carruth | 71f308a | 2015-02-13 09:09:03 +0000 | [diff] [blame] | 77 | #include "llvm/Support/Process.h" |
Zachary Turner | 72c5b64 | 2016-09-09 18:17:52 +0000 | [diff] [blame] | 78 | #include "llvm/Support/Regex.h" |
Reid Kleckner | b034526 | 2016-05-04 16:09:04 +0000 | [diff] [blame] | 79 | #include "llvm/Support/ScopedPrinter.h" |
Daniel Sanders | d41718e | 2016-04-22 12:04:42 +0000 | [diff] [blame] | 80 | #include "llvm/Support/Signals.h" |
Zachary Turner | 0a43efe | 2016-04-25 17:38:08 +0000 | [diff] [blame] | 81 | #include "llvm/Support/raw_ostream.h" |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 82 | |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 83 | using namespace llvm; |
Zachary Turner | a96cce6 | 2016-06-03 03:25:59 +0000 | [diff] [blame] | 84 | using namespace llvm::codeview; |
Zachary Turner | bac69d3 | 2016-07-22 19:56:05 +0000 | [diff] [blame] | 85 | using namespace llvm::msf; |
Zachary Turner | 2f09b50 | 2016-04-29 17:28:47 +0000 | [diff] [blame] | 86 | using namespace llvm::pdb; |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 87 | |
| 88 | namespace opts { |
Zachary Turner | c0acf68 | 2015-02-15 20:27:53 +0000 | [diff] [blame] | 89 | |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 90 | cl::SubCommand DumpSubcommand("dump", "Dump MSF and CodeView debug info"); |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 91 | cl::SubCommand BytesSubcommand("bytes", "Dump raw bytes from the PDB file"); |
| 92 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 93 | cl::SubCommand |
| 94 | PrettySubcommand("pretty", |
| 95 | "Dump semantic information about types and symbols"); |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 96 | |
| 97 | cl::SubCommand DiffSubcommand("diff", "Diff the contents of 2 PDB files"); |
| 98 | |
Zachary Turner | ab58ae8 | 2016-06-30 17:43:00 +0000 | [diff] [blame] | 99 | cl::SubCommand |
| 100 | YamlToPdbSubcommand("yaml2pdb", |
| 101 | "Generate a PDB file from a YAML description"); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 102 | cl::SubCommand |
| 103 | PdbToYamlSubcommand("pdb2yaml", |
| 104 | "Generate a detailed YAML description of a PDB File"); |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 105 | |
Zachary Turner | d50c013 | 2017-02-01 18:30:22 +0000 | [diff] [blame] | 106 | cl::SubCommand |
| 107 | AnalyzeSubcommand("analyze", |
| 108 | "Analyze various aspects of a PDB's structure"); |
| 109 | |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 110 | cl::SubCommand MergeSubcommand("merge", |
| 111 | "Merge multiple PDBs into a single PDB"); |
| 112 | |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 113 | cl::OptionCategory TypeCategory("Symbol Type Options"); |
Zachary Turner | c883a8c | 2017-04-12 23:18:21 +0000 | [diff] [blame] | 114 | cl::OptionCategory FilterCategory("Filtering and Sorting Options"); |
Zachary Turner | e5cb269 | 2015-05-01 20:24:26 +0000 | [diff] [blame] | 115 | cl::OptionCategory OtherOptions("Other Options"); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 116 | |
| 117 | namespace pretty { |
| 118 | cl::list<std::string> InputFilenames(cl::Positional, |
| 119 | cl::desc("<input PDB files>"), |
| 120 | cl::OneOrMore, cl::sub(PrettySubcommand)); |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 121 | |
| 122 | cl::opt<bool> Compilands("compilands", cl::desc("Display compilands"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 123 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 124 | cl::opt<bool> Symbols("module-syms", |
| 125 | cl::desc("Display symbols for each compiland"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 126 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 127 | cl::opt<bool> Globals("globals", cl::desc("Dump global symbols"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 128 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | e5cb269 | 2015-05-01 20:24:26 +0000 | [diff] [blame] | 129 | cl::opt<bool> Externals("externals", cl::desc("Dump external symbols"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 130 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 131 | cl::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 Turner | 63230a4e | 2017-04-06 23:43:12 +0000 | [diff] [blame] | 140 | cl::opt<bool> |
| 141 | Types("types", |
| 142 | cl::desc("Display all types (implies -classes, -enums, -typedefs)"), |
| 143 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
| 144 | cl::opt<bool> Classes("classes", cl::desc("Display class types"), |
| 145 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
| 146 | cl::opt<bool> Enums("enums", cl::desc("Display enum types"), |
| 147 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
| 148 | cl::opt<bool> Typedefs("typedefs", cl::desc("Display typedef types"), |
| 149 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 150 | cl::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 Turner | 4dc4f01 | 2017-04-13 21:11:00 +0000 | [diff] [blame] | 160 | cl::opt<ClassSortMode> ClassOrder( |
| 161 | "class-order", cl::desc("Class sort order"), cl::init(ClassSortMode::None), |
Zachary Turner | 1690164 | 2017-04-24 17:47:24 +0000 | [diff] [blame] | 162 | 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 Turner | da307b6 | 2017-04-25 20:22:29 +0000 | [diff] [blame] | 170 | "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 Turner | 4dc4f01 | 2017-04-13 21:11:00 +0000 | [diff] [blame] | 176 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
| 177 | |
Zachary Turner | c883a8c | 2017-04-12 23:18:21 +0000 | [diff] [blame] | 178 | cl::opt<ClassDefinitionFormat> ClassFormat( |
| 179 | "class-definitions", cl::desc("Class definition format"), |
Zachary Turner | da949c1 | 2017-04-24 17:47:52 +0000 | [diff] [blame] | 180 | cl::init(ClassDefinitionFormat::All), |
Zachary Turner | c883a8c | 2017-04-12 23:18:21 +0000 | [diff] [blame] | 181 | cl::values( |
Zachary Turner | da949c1 | 2017-04-24 17:47:52 +0000 | [diff] [blame] | 182 | clEnumValN(ClassDefinitionFormat::All, "all", |
Zachary Turner | 9e7dda3 | 2017-04-12 23:18:51 +0000 | [diff] [blame] | 183 | "Display all class members including data, constants, " |
Zachary Turner | 4dc4f01 | 2017-04-13 21:11:00 +0000 | [diff] [blame] | 184 | "typedefs, functions, etc"), |
Zachary Turner | da949c1 | 2017-04-24 17:47:52 +0000 | [diff] [blame] | 185 | clEnumValN(ClassDefinitionFormat::Layout, "layout", |
Zachary Turner | c883a8c | 2017-04-12 23:18:21 +0000 | [diff] [blame] | 186 | "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 Turner | da949c1 | 2017-04-24 17:47:52 +0000 | [diff] [blame] | 190 | cl::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 Turner | 63230a4e | 2017-04-06 23:43:12 +0000 | [diff] [blame] | 193 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 194 | cl::opt<bool> Lines("lines", cl::desc("Line tables"), cl::cat(TypeCategory), |
| 195 | cl::sub(PrettySubcommand)); |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 196 | cl::opt<bool> |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 197 | All("all", cl::desc("Implies all other options in 'Symbol Types' category"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 198 | cl::cat(TypeCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | f5abda2 | 2015-03-01 06:49:49 +0000 | [diff] [blame] | 199 | |
Zachary Turner | e5cb269 | 2015-05-01 20:24:26 +0000 | [diff] [blame] | 200 | cl::opt<uint64_t> LoadAddress( |
| 201 | "load-address", |
| 202 | cl::desc("Assume the module is loaded at the specified address"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 203 | cl::cat(OtherOptions), cl::sub(PrettySubcommand)); |
Adrian McCarthy | 65d2688 | 2017-03-15 20:17:58 +0000 | [diff] [blame] | 204 | cl::opt<bool> Native("native", cl::desc("Use native PDB reader instead of DIA"), |
Adrian McCarthy | 1aa207d | 2017-03-23 15:28:15 +0000 | [diff] [blame] | 205 | cl::cat(OtherOptions), cl::sub(PrettySubcommand)); |
| 206 | cl::opt<cl::boolOrDefault> |
| 207 | ColorOutput("color-output", |
| 208 | cl::desc("Override use of color (default = isatty)"), |
| 209 | cl::cat(OtherOptions), cl::sub(PrettySubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 210 | cl::list<std::string> ExcludeTypes( |
| 211 | "exclude-types", cl::desc("Exclude types by regular expression"), |
| 212 | cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
| 213 | cl::list<std::string> ExcludeSymbols( |
| 214 | "exclude-symbols", cl::desc("Exclude symbols by regular expression"), |
| 215 | cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
| 216 | cl::list<std::string> ExcludeCompilands( |
| 217 | "exclude-compilands", cl::desc("Exclude compilands by regular expression"), |
| 218 | cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 4dddcc6 | 2015-09-29 19:49:06 +0000 | [diff] [blame] | 219 | |
| 220 | cl::list<std::string> IncludeTypes( |
| 221 | "include-types", |
| 222 | cl::desc("Include only types which match a regular expression"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 223 | cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 4dddcc6 | 2015-09-29 19:49:06 +0000 | [diff] [blame] | 224 | cl::list<std::string> IncludeSymbols( |
| 225 | "include-symbols", |
| 226 | cl::desc("Include only symbols which match a regular expression"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 227 | cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 4dddcc6 | 2015-09-29 19:49:06 +0000 | [diff] [blame] | 228 | cl::list<std::string> IncludeCompilands( |
| 229 | "include-compilands", |
| 230 | cl::desc("Include only compilands those which match a regular expression"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 231 | cl::ZeroOrMore, cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 4dc4f01 | 2017-04-13 21:11:00 +0000 | [diff] [blame] | 232 | cl::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)); |
| 236 | cl::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 Turner | da307b6 | 2017-04-25 20:22:29 +0000 | [diff] [blame] | 240 | cl::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 Turner | 4dddcc6 | 2015-09-29 19:49:06 +0000 | [diff] [blame] | 246 | |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 247 | cl::opt<bool> ExcludeCompilerGenerated( |
| 248 | "no-compiler-generated", |
| 249 | cl::desc("Don't show compiler generated types and symbols"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 250 | cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 251 | cl::opt<bool> |
| 252 | ExcludeSystemLibraries("no-system-libs", |
| 253 | cl::desc("Don't show symbols from system libraries"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 254 | cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
Zachary Turner | 10169b6 | 2017-04-06 23:43:39 +0000 | [diff] [blame] | 255 | |
Zachary Turner | 6532365 | 2015-03-04 06:09:53 +0000 | [diff] [blame] | 256 | cl::opt<bool> NoEnumDefs("no-enum-definitions", |
| 257 | cl::desc("Don't display full enum definitions"), |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 258 | cl::cat(FilterCategory), cl::sub(PrettySubcommand)); |
| 259 | } |
| 260 | |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 261 | namespace diff { |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 262 | cl::list<std::string> InputFilenames(cl::Positional, |
| 263 | cl::desc("<first> <second>"), |
| 264 | cl::OneOrMore, cl::sub(DiffSubcommand)); |
| 265 | } |
| 266 | |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 267 | cl::OptionCategory FileOptions("Module & File Options"); |
| 268 | |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 269 | namespace bytes { |
Zachary Turner | dd73968 | 2017-06-23 21:11:54 +0000 | [diff] [blame] | 270 | cl::OptionCategory MsfBytes("MSF File Options"); |
| 271 | cl::OptionCategory DbiBytes("Dbi Stream Options"); |
| 272 | cl::OptionCategory PdbBytes("PDB Stream Options"); |
Zachary Turner | c2f5b4b | 2017-06-23 21:50:54 +0000 | [diff] [blame] | 273 | cl::OptionCategory Types("Type Options"); |
Zachary Turner | fa33282 | 2017-06-23 23:08:57 +0000 | [diff] [blame^] | 274 | cl::OptionCategory ModuleCategory("Module Options"); |
Zachary Turner | dd73968 | 2017-06-23 21:11:54 +0000 | [diff] [blame] | 275 | |
Zachary Turner | 6b124f2 | 2017-06-23 19:54:44 +0000 | [diff] [blame] | 276 | llvm::Optional<NumberRange> DumpBlockRange; |
| 277 | llvm::Optional<NumberRange> DumpByteRange; |
| 278 | |
| 279 | cl::opt<std::string> DumpBlockRangeOpt( |
| 280 | "block-range", cl::value_desc("start[-end]"), |
| 281 | cl::desc("Dump binary data from specified range of blocks."), |
Zachary Turner | dd73968 | 2017-06-23 21:11:54 +0000 | [diff] [blame] | 282 | cl::sub(BytesSubcommand), cl::cat(MsfBytes)); |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 283 | |
| 284 | cl::opt<std::string> |
Zachary Turner | 6b124f2 | 2017-06-23 19:54:44 +0000 | [diff] [blame] | 285 | DumpByteRangeOpt("byte-range", cl::value_desc("start[-end]"), |
| 286 | cl::desc("Dump binary data from specified range of bytes"), |
Zachary Turner | dd73968 | 2017-06-23 21:11:54 +0000 | [diff] [blame] | 287 | cl::sub(BytesSubcommand), cl::cat(MsfBytes)); |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 288 | |
| 289 | cl::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 Turner | dd73968 | 2017-06-23 21:11:54 +0000 | [diff] [blame] | 293 | cl::sub(BytesSubcommand), cl::cat(MsfBytes)); |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 294 | |
Zachary Turner | 6c3e41b | 2017-06-23 20:18:38 +0000 | [diff] [blame] | 295 | cl::opt<bool> NameMap("name-map", cl::desc("Dump bytes of PDB Name Map"), |
Zachary Turner | dd73968 | 2017-06-23 21:11:54 +0000 | [diff] [blame] | 296 | cl::sub(BytesSubcommand), cl::cat(PdbBytes)); |
| 297 | |
| 298 | cl::opt<bool> SectionContributions("sc", cl::desc("Dump section contributions"), |
| 299 | cl::sub(BytesSubcommand), cl::cat(DbiBytes)); |
| 300 | cl::opt<bool> SectionMap("sm", cl::desc("Dump section map"), |
| 301 | cl::sub(BytesSubcommand), cl::cat(DbiBytes)); |
| 302 | cl::opt<bool> ModuleInfos("modi", cl::desc("Dump module info"), |
| 303 | cl::sub(BytesSubcommand), cl::cat(DbiBytes)); |
| 304 | cl::opt<bool> FileInfo("files", cl::desc("Dump source file info"), |
| 305 | cl::sub(BytesSubcommand), cl::cat(DbiBytes)); |
| 306 | cl::opt<bool> TypeServerMap("type-server", cl::desc("Dump type server map"), |
| 307 | cl::sub(BytesSubcommand), cl::cat(DbiBytes)); |
| 308 | cl::opt<bool> ECData("ec", cl::desc("Dump edit and continue map"), |
| 309 | cl::sub(BytesSubcommand), cl::cat(DbiBytes)); |
Zachary Turner | 6c3e41b | 2017-06-23 20:18:38 +0000 | [diff] [blame] | 310 | |
Zachary Turner | c2f5b4b | 2017-06-23 21:50:54 +0000 | [diff] [blame] | 311 | cl::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)); |
| 316 | cl::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 Turner | fa33282 | 2017-06-23 23:08:57 +0000 | [diff] [blame^] | 321 | cl::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)); |
| 326 | cl::opt<bool> ModuleSyms("syms", cl::desc("Dump symbol record substream"), |
| 327 | cl::sub(BytesSubcommand), cl::cat(ModuleCategory)); |
| 328 | cl::opt<bool> ModuleC11("c11-chunks", cl::Hidden, |
| 329 | cl::desc("Dump C11 CodeView debug chunks"), |
| 330 | cl::sub(BytesSubcommand), cl::cat(ModuleCategory)); |
| 331 | cl::opt<bool> ModuleC13("chunks", cl::desc("Dump C13 CodeView debug chunks"), |
| 332 | cl::sub(BytesSubcommand), cl::cat(ModuleCategory)); |
| 333 | |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 334 | cl::list<std::string> InputFilenames(cl::Positional, |
| 335 | cl::desc("<input PDB files>"), |
| 336 | cl::OneOrMore, cl::sub(BytesSubcommand)); |
| 337 | |
| 338 | } // namespace bytes |
| 339 | |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 340 | namespace dump { |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 341 | |
| 342 | cl::OptionCategory MsfOptions("MSF Container Options"); |
| 343 | cl::OptionCategory TypeOptions("Type Record Options"); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 344 | cl::OptionCategory SymbolOptions("Symbol Options"); |
| 345 | cl::OptionCategory MiscOptions("Miscellaneous Options"); |
| 346 | |
| 347 | // MSF OPTIONS |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 348 | cl::opt<bool> DumpSummary("summary", cl::desc("dump file summary"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 349 | cl::cat(MsfOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 350 | cl::opt<bool> DumpStreams("streams", |
| 351 | cl::desc("dump summary of the PDB streams"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 352 | cl::cat(MsfOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 5f09852 | 2017-06-23 20:28:14 +0000 | [diff] [blame] | 353 | cl::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 Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 357 | |
| 358 | // TYPE OPTIONS |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 359 | cl::opt<bool> DumpTypes("types", |
| 360 | cl::desc("dump CodeView type records from TPI stream"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 361 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 362 | cl::opt<bool> DumpTypeData( |
| 363 | "type-data", |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 364 | cl::desc("dump CodeView type record raw bytes from TPI stream"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 365 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 366 | |
Zachary Turner | f8a2e04 | 2017-06-15 23:04:42 +0000 | [diff] [blame] | 367 | cl::opt<bool> DumpTypeExtras("type-extras", |
| 368 | cl::desc("dump type hashes and index offsets"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 369 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 370 | |
Zachary Turner | 59224cb | 2017-06-16 23:42:15 +0000 | [diff] [blame] | 371 | cl::list<uint32_t> DumpTypeIndex( |
| 372 | "type-index", cl::ZeroOrMore, |
| 373 | cl::desc("only dump types with the specified hexadecimal type index"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 374 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 59224cb | 2017-06-16 23:42:15 +0000 | [diff] [blame] | 375 | |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 376 | cl::opt<bool> DumpIds("ids", |
| 377 | cl::desc("dump CodeView type records from IPI stream"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 378 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 379 | cl::opt<bool> |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 380 | DumpIdData("id-data", |
| 381 | cl::desc("dump CodeView type record raw bytes from IPI stream"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 382 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 383 | |
Zachary Turner | f8a2e04 | 2017-06-15 23:04:42 +0000 | [diff] [blame] | 384 | cl::opt<bool> DumpIdExtras("id-extras", |
| 385 | cl::desc("dump id hashes and index offsets"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 386 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 59224cb | 2017-06-16 23:42:15 +0000 | [diff] [blame] | 387 | cl::list<uint32_t> DumpIdIndex( |
| 388 | "id-index", cl::ZeroOrMore, |
| 389 | cl::desc("only dump ids with the specified hexadecimal type index"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 390 | cl::cat(TypeOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | f8a2e04 | 2017-06-15 23:04:42 +0000 | [diff] [blame] | 391 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 392 | // SYMBOL OPTIONS |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 393 | cl::opt<bool> DumpPublics("publics", cl::desc("dump Publics stream data"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 394 | cl::cat(SymbolOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 395 | cl::opt<bool> DumpSymbols("symbols", cl::desc("dump module symbols"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 396 | cl::cat(SymbolOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 397 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 398 | cl::opt<bool> |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 399 | DumpSymRecordBytes("sym-data", |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 400 | cl::desc("dump CodeView symbol record raw bytes"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 401 | cl::cat(SymbolOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 402 | |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 403 | // MODULE & FILE OPTIONS |
| 404 | cl::opt<bool> DumpModules("modules", cl::desc("dump compiland information"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 405 | cl::cat(FileOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 406 | cl::opt<bool> DumpModuleFiles( |
| 407 | "files", |
Zachary Turner | 4e95064 | 2017-06-15 23:56:19 +0000 | [diff] [blame] | 408 | cl::desc("Dump the source files that contribute to each module's."), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 409 | cl::cat(FileOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 4e95064 | 2017-06-15 23:56:19 +0000 | [diff] [blame] | 410 | cl::opt<bool> DumpLines( |
| 411 | "l", |
| 412 | cl::desc("dump source file/line information (DEBUG_S_LINES subsection)"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 413 | cl::cat(FileOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 4e95064 | 2017-06-15 23:56:19 +0000 | [diff] [blame] | 414 | cl::opt<bool> DumpInlineeLines( |
| 415 | "il", |
| 416 | cl::desc("dump inlinee line information (DEBUG_S_INLINEELINES subsection)"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 417 | cl::cat(FileOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 47d9a56 | 2017-06-16 00:04:24 +0000 | [diff] [blame] | 418 | cl::opt<bool> DumpXmi( |
| 419 | "xmi", |
| 420 | cl::desc( |
| 421 | "dump cross module imports (DEBUG_S_CROSSSCOPEIMPORTS subsection)"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 422 | cl::cat(FileOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 47d9a56 | 2017-06-16 00:04:24 +0000 | [diff] [blame] | 423 | cl::opt<bool> DumpXme( |
| 424 | "xme", |
| 425 | cl::desc( |
| 426 | "dump cross module exports (DEBUG_S_CROSSSCOPEEXPORTS subsection)"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 427 | cl::cat(FileOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 428 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 429 | // MISCELLANEOUS OPTIONS |
Zachary Turner | 760ad4d | 2017-01-20 22:42:09 +0000 | [diff] [blame] | 430 | cl::opt<bool> DumpStringTable("string-table", cl::desc("dump PDB String Table"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 431 | cl::cat(MiscOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | 760ad4d | 2017-01-20 22:42:09 +0000 | [diff] [blame] | 432 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 433 | cl::opt<bool> DumpSectionContribs("section-contribs", |
| 434 | cl::desc("dump section contributions"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 435 | cl::cat(MiscOptions), |
| 436 | cl::sub(DumpSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 437 | cl::opt<bool> DumpSectionMap("section-map", cl::desc("dump section map"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 438 | cl::cat(MiscOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 439 | |
Zachary Turner | ab58ae8 | 2016-06-30 17:43:00 +0000 | [diff] [blame] | 440 | cl::opt<bool> RawAll("all", cl::desc("Implies most other options."), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 441 | cl::cat(MiscOptions), cl::sub(DumpSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 442 | |
| 443 | cl::list<std::string> InputFilenames(cl::Positional, |
| 444 | cl::desc("<input PDB files>"), |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 445 | cl::OneOrMore, cl::sub(DumpSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 446 | } |
| 447 | |
| 448 | namespace yaml2pdb { |
| 449 | cl::opt<std::string> |
| 450 | YamlPdbOutputFile("pdb", cl::desc("the name of the PDB file to write"), |
| 451 | cl::sub(YamlToPdbSubcommand)); |
| 452 | |
Bob Haarman | de33a637 | 2017-05-17 20:46:48 +0000 | [diff] [blame] | 453 | cl::opt<std::string> InputFilename(cl::Positional, |
| 454 | cl::desc("<input YAML file>"), cl::Required, |
| 455 | cl::sub(YamlToPdbSubcommand)); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | namespace pdb2yaml { |
Bob Haarman | 69fd2b7 | 2017-05-26 23:46:20 +0000 | [diff] [blame] | 459 | cl::opt<bool> All("all", |
| 460 | cl::desc("Dump everything we know how to dump."), |
| 461 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 462 | cl::opt<bool> NoFileHeaders("no-file-headers", |
| 463 | cl::desc("Do not dump MSF file headers"), |
| 464 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 465 | cl::opt<bool> Minimal("minimal", |
| 466 | cl::desc("Don't write fields with default values"), |
| 467 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
Zachary Turner | f6b9382 | 2016-07-11 21:45:09 +0000 | [diff] [blame] | 468 | |
Zachary Turner | ab58ae8 | 2016-06-30 17:43:00 +0000 | [diff] [blame] | 469 | cl::opt<bool> StreamMetadata( |
| 470 | "stream-metadata", |
| 471 | cl::desc("Dump the number of streams and each stream's size"), |
Zachary Turner | f6b9382 | 2016-07-11 21:45:09 +0000 | [diff] [blame] | 472 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
Zachary Turner | ab58ae8 | 2016-06-30 17:43:00 +0000 | [diff] [blame] | 473 | cl::opt<bool> StreamDirectory( |
| 474 | "stream-directory", |
| 475 | cl::desc("Dump each stream's block map (implies -stream-metadata)"), |
Zachary Turner | f6b9382 | 2016-07-11 21:45:09 +0000 | [diff] [blame] | 476 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
Zachary Turner | faa554b | 2016-07-15 22:16:56 +0000 | [diff] [blame] | 477 | cl::opt<bool> PdbStream("pdb-stream", |
| 478 | cl::desc("Dump the PDB Stream (Stream 1)"), |
| 479 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
Zachary Turner | 760ad4d | 2017-01-20 22:42:09 +0000 | [diff] [blame] | 480 | |
| 481 | cl::opt<bool> StringTable("string-table", cl::desc("Dump the PDB String Table"), |
| 482 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
| 483 | |
Zachary Turner | faa554b | 2016-07-15 22:16:56 +0000 | [diff] [blame] | 484 | cl::opt<bool> DbiStream("dbi-stream", |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 485 | cl::desc("Dump the DBI Stream Headers (Stream 2)"), |
Zachary Turner | faa554b | 2016-07-15 22:16:56 +0000 | [diff] [blame] | 486 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
Zachary Turner | ee3b9c2 | 2017-04-25 20:22:02 +0000 | [diff] [blame] | 487 | |
Zachary Turner | ac5763e | 2016-08-18 16:49:29 +0000 | [diff] [blame] | 488 | cl::opt<bool> TpiStream("tpi-stream", |
| 489 | cl::desc("Dump the TPI Stream (Stream 3)"), |
| 490 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
| 491 | |
Zachary Turner | de9ba15 | 2016-09-15 18:22:31 +0000 | [diff] [blame] | 492 | cl::opt<bool> IpiStream("ipi-stream", |
| 493 | cl::desc("Dump the IPI Stream (Stream 5)"), |
| 494 | cl::sub(PdbToYamlSubcommand), cl::init(false)); |
| 495 | |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 496 | // MODULE & FILE OPTIONS |
| 497 | cl::opt<bool> DumpModules("modules", cl::desc("dump compiland information"), |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 498 | cl::cat(FileOptions), cl::sub(PdbToYamlSubcommand)); |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 499 | cl::opt<bool> DumpModuleFiles("module-files", cl::desc("dump file information"), |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 500 | cl::cat(FileOptions), |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 501 | cl::sub(PdbToYamlSubcommand)); |
| 502 | cl::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 Turner | deb3913 | 2017-06-09 00:28:08 +0000 | [diff] [blame] | 518 | 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 Turner | 3226fe9 | 2017-06-09 20:46:52 +0000 | [diff] [blame] | 526 | clEnumValN(ModuleSubsection::CoffSymbolRVAs, "rvas", |
| 527 | "COFF Symbol RVAs (DEBUG_S_COFF_SYMBOL_RVA subsection)"), |
Zachary Turner | 28c22c8 | 2017-06-09 00:53:59 +0000 | [diff] [blame] | 528 | clEnumValN(ModuleSubsection::Unknown, "unknown", |
| 529 | "Any subsection not covered by another option"), |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 530 | clEnumValN(ModuleSubsection::All, "all", "All known subsections")), |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 531 | cl::cat(FileOptions), cl::sub(PdbToYamlSubcommand)); |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 532 | cl::opt<bool> DumpModuleSyms("module-syms", cl::desc("dump module symbols"), |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 533 | cl::cat(FileOptions), |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 534 | cl::sub(PdbToYamlSubcommand)); |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 535 | |
| 536 | cl::list<std::string> InputFilename(cl::Positional, |
| 537 | cl::desc("<input PDB file>"), cl::Required, |
| 538 | cl::sub(PdbToYamlSubcommand)); |
| 539 | } // namespace pdb2yaml |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 540 | |
Zachary Turner | d50c013 | 2017-02-01 18:30:22 +0000 | [diff] [blame] | 541 | namespace analyze { |
| 542 | cl::opt<bool> StringTable("hash-collisions", cl::desc("Find hash collisions"), |
| 543 | cl::sub(AnalyzeSubcommand), cl::init(false)); |
| 544 | cl::list<std::string> InputFilename(cl::Positional, |
| 545 | cl::desc("<input PDB file>"), cl::Required, |
| 546 | cl::sub(AnalyzeSubcommand)); |
| 547 | } |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 548 | |
| 549 | namespace merge { |
| 550 | cl::list<std::string> InputFilenames(cl::Positional, |
| 551 | cl::desc("<input PDB files>"), |
| 552 | cl::OneOrMore, cl::sub(MergeSubcommand)); |
| 553 | cl::opt<std::string> |
| 554 | PdbOutputFile("pdb", cl::desc("the name of the PDB file to write"), |
| 555 | cl::sub(MergeSubcommand)); |
| 556 | } |
Zachary Turner | 49693b4 | 2015-01-28 01:22:33 +0000 | [diff] [blame] | 557 | } |
| 558 | |
David Majnemer | c165c88 | 2016-05-28 18:25:15 +0000 | [diff] [blame] | 559 | static ExitOnError ExitOnErr; |
| 560 | |
Zachary Turner | 1dc9fd3 | 2016-06-14 20:48:36 +0000 | [diff] [blame] | 561 | static void yamlToPdb(StringRef Path) { |
Zachary Turner | e109dc6 | 2016-07-22 19:56:26 +0000 | [diff] [blame] | 562 | BumpPtrAllocator Allocator; |
Zachary Turner | 1dc9fd3 | 2016-06-14 20:48:36 +0000 | [diff] [blame] | 563 | 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 Turner | c6d54da | 2016-09-09 17:46:17 +0000 | [diff] [blame] | 574 | pdb::yaml::PdbObject YamlObj(Allocator); |
Zachary Turner | 1dc9fd3 | 2016-06-14 20:48:36 +0000 | [diff] [blame] | 575 | In >> YamlObj; |
| 576 | |
Zachary Turner | e109dc6 | 2016-07-22 19:56:26 +0000 | [diff] [blame] | 577 | PDBFileBuilder Builder(Allocator); |
Zachary Turner | dbeaea7 | 2016-07-11 21:45:26 +0000 | [diff] [blame] | 578 | |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 579 | uint32_t BlockSize = 4096; |
| 580 | if (YamlObj.Headers.hasValue()) |
| 581 | BlockSize = YamlObj.Headers->SuperBlock.BlockSize; |
| 582 | ExitOnErr(Builder.initialize(BlockSize)); |
Zachary Turner | 620961d | 2016-09-14 23:00:02 +0000 | [diff] [blame] | 583 | // 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 Turner | 8848a7a | 2016-07-06 18:05:57 +0000 | [diff] [blame] | 591 | |
Zachary Turner | a8cfc29 | 2017-06-14 15:59:27 +0000 | [diff] [blame] | 592 | StringsAndChecksums Strings; |
| 593 | Strings.setStrings(std::make_shared<DebugStringTableSubsection>()); |
| 594 | |
Zachary Turner | 760ad4d | 2017-01-20 22:42:09 +0000 | [diff] [blame] | 595 | if (YamlObj.StringTable.hasValue()) { |
Zachary Turner | 760ad4d | 2017-01-20 22:42:09 +0000 | [diff] [blame] | 596 | for (auto S : *YamlObj.StringTable) |
Zachary Turner | a8cfc29 | 2017-06-14 15:59:27 +0000 | [diff] [blame] | 597 | Strings.strings()->insert(S); |
Zachary Turner | 760ad4d | 2017-01-20 22:42:09 +0000 | [diff] [blame] | 598 | } |
| 599 | |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 600 | pdb::yaml::PdbInfoStream DefaultInfoStream; |
| 601 | pdb::yaml::PdbDbiStream DefaultDbiStream; |
| 602 | pdb::yaml::PdbTpiStream DefaultTpiStream; |
Zachary Turner | d4136e9 | 2017-05-22 21:07:43 +0000 | [diff] [blame] | 603 | pdb::yaml::PdbTpiStream DefaultIpiStream; |
Zachary Turner | 1dc9fd3 | 2016-06-14 20:48:36 +0000 | [diff] [blame] | 604 | |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 605 | 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 Turner | 05d5e61 | 2017-03-16 20:19:11 +0000 | [diff] [blame] | 612 | for (auto F : Info.Features) |
| 613 | InfoBuilder.addFeature(F); |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 614 | |
| 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 Turner | 05d5e61 | 2017-03-16 20:19:11 +0000 | [diff] [blame] | 625 | auto &ModiBuilder = ExitOnErr(DbiBuilder.addModuleInfo(MI.Mod)); |
Bob Haarman | ea91faf | 2017-05-25 18:04:17 +0000 | [diff] [blame] | 626 | ModiBuilder.setObjFileName(MI.Obj); |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 627 | |
| 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 Turner | ebd3ae8 | 2017-06-01 21:52:41 +0000 | [diff] [blame] | 632 | for (auto Symbol : ModiStream.Symbols) { |
| 633 | ModiBuilder.addSymbol( |
| 634 | Symbol.toCodeViewSymbol(Allocator, CodeViewContainer::Pdb)); |
| 635 | } |
Zachary Turner | d218c26 | 2016-07-22 15:46:37 +0000 | [diff] [blame] | 636 | } |
Zachary Turner | 8a2ebfb | 2017-05-01 23:27:42 +0000 | [diff] [blame] | 637 | |
Zachary Turner | a8cfc29 | 2017-06-14 15:59:27 +0000 | [diff] [blame] | 638 | // 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 Turner | deb3913 | 2017-06-09 00:28:08 +0000 | [diff] [blame] | 642 | auto CodeViewSubsections = ExitOnErr(CodeViewYAML::toCodeViewSubsectionList( |
| 643 | Allocator, MI.Subsections, Strings)); |
Zachary Turner | 92dcdda | 2017-06-02 19:49:14 +0000 | [diff] [blame] | 644 | for (auto &SS : CodeViewSubsections) { |
Zachary Turner | a8cfc29 | 2017-06-14 15:59:27 +0000 | [diff] [blame] | 645 | ModiBuilder.addDebugSubsection(SS); |
Zachary Turner | 8a2ebfb | 2017-05-01 23:27:42 +0000 | [diff] [blame] | 646 | } |
Zachary Turner | dbeaea7 | 2016-07-11 21:45:26 +0000 | [diff] [blame] | 647 | } |
| 648 | |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 649 | auto &TpiBuilder = Builder.getTpiBuilder(); |
| 650 | const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream); |
| 651 | TpiBuilder.setVersionHeader(Tpi.Version); |
Zachary Turner | d427383 | 2017-05-30 21:53:05 +0000 | [diff] [blame] | 652 | for (const auto &R : Tpi.Records) { |
| 653 | CVType Type = R.toCodeViewRecord(Allocator); |
| 654 | TpiBuilder.addTypeRecord(Type.RecordData, None); |
| 655 | } |
Zachary Turner | c6d54da | 2016-09-09 17:46:17 +0000 | [diff] [blame] | 656 | |
Zachary Turner | d4136e9 | 2017-05-22 21:07:43 +0000 | [diff] [blame] | 657 | const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream); |
Zachary Turner | ea4e607 | 2017-03-15 22:18:53 +0000 | [diff] [blame] | 658 | auto &IpiBuilder = Builder.getIpiBuilder(); |
| 659 | IpiBuilder.setVersionHeader(Ipi.Version); |
Zachary Turner | d427383 | 2017-05-30 21:53:05 +0000 | [diff] [blame] | 660 | for (const auto &R : Ipi.Records) { |
| 661 | CVType Type = R.toCodeViewRecord(Allocator); |
| 662 | IpiBuilder.addTypeRecord(Type.RecordData, None); |
| 663 | } |
Zachary Turner | de9ba15 | 2016-09-15 18:22:31 +0000 | [diff] [blame] | 664 | |
Zachary Turner | a8cfc29 | 2017-06-14 15:59:27 +0000 | [diff] [blame] | 665 | Builder.getStringTableBuilder().setStrings(*Strings.strings()); |
| 666 | |
Rui Ueyama | fc22cef | 2016-09-30 20:34:44 +0000 | [diff] [blame] | 667 | ExitOnErr(Builder.commit(opts::yaml2pdb::YamlPdbOutputFile)); |
Zachary Turner | 1dc9fd3 | 2016-06-14 20:48:36 +0000 | [diff] [blame] | 668 | } |
| 669 | |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 670 | static PDBFile &loadPDB(StringRef Path, std::unique_ptr<IPDBSession> &Session) { |
Adrian McCarthy | 8f71319 | 2017-01-27 00:01:55 +0000 | [diff] [blame] | 671 | ExitOnErr(loadDataForPDB(PDB_ReaderType::Native, Path, Session)); |
Zachary Turner | 8848a7a | 2016-07-06 18:05:57 +0000 | [diff] [blame] | 672 | |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 673 | NativeSession *NS = static_cast<NativeSession *>(Session.get()); |
| 674 | return NS->getPDBFile(); |
| 675 | } |
| 676 | |
| 677 | static void pdb2Yaml(StringRef Path) { |
| 678 | std::unique_ptr<IPDBSession> Session; |
| 679 | auto &File = loadPDB(Path, Session); |
| 680 | |
Zachary Turner | 8848a7a | 2016-07-06 18:05:57 +0000 | [diff] [blame] | 681 | auto O = llvm::make_unique<YAMLOutputStyle>(File); |
| 682 | O = llvm::make_unique<YAMLOutputStyle>(File); |
| 683 | |
| 684 | ExitOnErr(O->dump()); |
| 685 | } |
| 686 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 687 | static void dumpRaw(StringRef Path) { |
David Majnemer | 1573b24 | 2016-04-28 23:47:27 +0000 | [diff] [blame] | 688 | std::unique_ptr<IPDBSession> Session; |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 689 | auto &File = loadPDB(Path, Session); |
David Majnemer | 1573b24 | 2016-04-28 23:47:27 +0000 | [diff] [blame] | 690 | |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 691 | auto O = llvm::make_unique<DumpOutputStyle>(File); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 692 | |
| 693 | ExitOnErr(O->dump()); |
| 694 | } |
| 695 | |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 696 | static 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 Turner | d50c013 | 2017-02-01 18:30:22 +0000 | [diff] [blame] | 705 | static void dumpAnalysis(StringRef Path) { |
| 706 | std::unique_ptr<IPDBSession> Session; |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 707 | auto &File = loadPDB(Path, Session); |
Zachary Turner | d50c013 | 2017-02-01 18:30:22 +0000 | [diff] [blame] | 708 | auto O = llvm::make_unique<AnalysisStyle>(File); |
| 709 | |
| 710 | ExitOnErr(O->dump()); |
| 711 | } |
| 712 | |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 713 | static 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 Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 725 | bool 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 | |
| 735 | uint32_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 | |
| 742 | bool 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 | |
| 755 | bool 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 Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 768 | static void dumpPretty(StringRef Path) { |
| 769 | std::unique_ptr<IPDBSession> Session; |
David Majnemer | 1573b24 | 2016-04-28 23:47:27 +0000 | [diff] [blame] | 770 | |
Adrian McCarthy | 65d2688 | 2017-03-15 20:17:58 +0000 | [diff] [blame] | 771 | const auto ReaderType = |
| 772 | opts::pretty::Native ? PDB_ReaderType::Native : PDB_ReaderType::DIA; |
| 773 | ExitOnErr(loadDataForPDB(ReaderType, Path, Session)); |
David Majnemer | 1573b24 | 2016-04-28 23:47:27 +0000 | [diff] [blame] | 774 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 775 | if (opts::pretty::LoadAddress) |
| 776 | Session->setLoadAddress(opts::pretty::LoadAddress); |
Zachary Turner | 7058dfc | 2015-01-27 22:40:14 +0000 | [diff] [blame] | 777 | |
Adrian McCarthy | 1aa207d | 2017-03-23 15:28:15 +0000 | [diff] [blame] | 778 | 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 Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 783 | |
Zachary Turner | a554917 | 2015-02-10 22:43:25 +0000 | [diff] [blame] | 784 | auto GlobalScope(Session->getGlobalScope()); |
Zachary Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 785 | std::string FileName(GlobalScope->getSymbolsFileName()); |
| 786 | |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 787 | WithColor(Printer, PDB_ColorItem::None).get() << "Summary for "; |
| 788 | WithColor(Printer, PDB_ColorItem::Path).get() << FileName; |
| 789 | Printer.Indent(); |
Zachary Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 790 | uint64_t FileSize = 0; |
Zachary Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 791 | |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 792 | Printer.NewLine(); |
| 793 | WithColor(Printer, PDB_ColorItem::Identifier).get() << "Size"; |
David Majnemer | 6e08126 | 2015-10-15 01:27:19 +0000 | [diff] [blame] | 794 | if (!sys::fs::file_size(FileName, FileSize)) { |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 795 | 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 Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 811 | if (GlobalScope->hasCTypes()) |
| 812 | outs() << "HasCTypes "; |
| 813 | if (GlobalScope->hasPrivateSymbols()) |
| 814 | outs() << "HasPrivateSymbols "; |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 815 | Printer.Unindent(); |
Zachary Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 816 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 817 | if (opts::pretty::Compilands) { |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 818 | Printer.NewLine(); |
| 819 | WithColor(Printer, PDB_ColorItem::SectionHeader).get() |
| 820 | << "---COMPILANDS---"; |
| 821 | Printer.Indent(); |
Zachary Turner | c074de0 | 2015-02-12 21:09:24 +0000 | [diff] [blame] | 822 | auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>(); |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 823 | CompilandDumper Dumper(Printer); |
Zachary Turner | a99000d | 2016-03-08 21:42:24 +0000 | [diff] [blame] | 824 | CompilandDumpFlags options = CompilandDumper::Flags::None; |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 825 | if (opts::pretty::Lines) |
Zachary Turner | a99000d | 2016-03-08 21:42:24 +0000 | [diff] [blame] | 826 | options = options | CompilandDumper::Flags::Lines; |
Zachary Turner | 9a818ad | 2015-02-22 22:03:38 +0000 | [diff] [blame] | 827 | while (auto Compiland = Compilands->getNext()) |
Zachary Turner | a99000d | 2016-03-08 21:42:24 +0000 | [diff] [blame] | 828 | Dumper.start(*Compiland, options); |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 829 | Printer.Unindent(); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 830 | } |
| 831 | |
Zachary Turner | 63230a4e | 2017-04-06 23:43:12 +0000 | [diff] [blame] | 832 | if (opts::pretty::Classes || opts::pretty::Enums || opts::pretty::Typedefs) { |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 833 | Printer.NewLine(); |
| 834 | WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---TYPES---"; |
| 835 | Printer.Indent(); |
Zachary Turner | 6532365 | 2015-03-04 06:09:53 +0000 | [diff] [blame] | 836 | TypeDumper Dumper(Printer); |
Zachary Turner | b52d08d | 2015-03-01 06:51:29 +0000 | [diff] [blame] | 837 | Dumper.start(*GlobalScope); |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 838 | Printer.Unindent(); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 839 | } |
| 840 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 841 | if (opts::pretty::Symbols) { |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 842 | Printer.NewLine(); |
| 843 | WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---SYMBOLS---"; |
| 844 | Printer.Indent(); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 845 | auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>(); |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 846 | CompilandDumper Dumper(Printer); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 847 | while (auto Compiland = Compilands->getNext()) |
Zachary Turner | b52d08d | 2015-03-01 06:51:29 +0000 | [diff] [blame] | 848 | Dumper.start(*Compiland, true); |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 849 | Printer.Unindent(); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 850 | } |
| 851 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 852 | if (opts::pretty::Globals) { |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 853 | Printer.NewLine(); |
| 854 | WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---GLOBALS---"; |
| 855 | Printer.Indent(); |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 856 | if (shouldDumpSymLevel(opts::pretty::SymLevel::Functions)) { |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 857 | FunctionDumper Dumper(Printer); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 858 | auto Functions = GlobalScope->findAllChildren<PDBSymbolFunc>(); |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 859 | 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 Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 874 | } |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 875 | } |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 876 | if (shouldDumpSymLevel(opts::pretty::SymLevel::Data)) { |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 877 | auto Vars = GlobalScope->findAllChildren<PDBSymbolData>(); |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 878 | VariableDumper Dumper(Printer); |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 879 | 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 Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 890 | } |
Zachary Turner | 0683be2 | 2017-05-14 01:13:40 +0000 | [diff] [blame] | 891 | if (shouldDumpSymLevel(opts::pretty::SymLevel::Thunks)) { |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 892 | auto Thunks = GlobalScope->findAllChildren<PDBSymbolThunk>(); |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 893 | CompilandDumper Dumper(Printer); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 894 | while (auto Thunk = Thunks->getNext()) |
Zachary Turner | b52d08d | 2015-03-01 06:51:29 +0000 | [diff] [blame] | 895 | Dumper.dump(*Thunk); |
Zachary Turner | db18f5c | 2015-02-27 09:15:18 +0000 | [diff] [blame] | 896 | } |
Zachary Turner | 2d11c20 | 2015-02-27 09:15:59 +0000 | [diff] [blame] | 897 | Printer.Unindent(); |
Zachary Turner | 7058dfc | 2015-01-27 22:40:14 +0000 | [diff] [blame] | 898 | } |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 899 | if (opts::pretty::Externals) { |
Zachary Turner | e5cb269 | 2015-05-01 20:24:26 +0000 | [diff] [blame] | 900 | Printer.NewLine(); |
| 901 | WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---EXTERNALS---"; |
| 902 | Printer.Indent(); |
| 903 | ExternalSymbolDumper Dumper(Printer); |
| 904 | Dumper.start(*GlobalScope); |
| 905 | } |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 906 | if (opts::pretty::Lines) { |
Zachary Turner | a99000d | 2016-03-08 21:42:24 +0000 | [diff] [blame] | 907 | Printer.NewLine(); |
| 908 | } |
Zachary Turner | a554917 | 2015-02-10 22:43:25 +0000 | [diff] [blame] | 909 | outs().flush(); |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 910 | } |
| 911 | |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 912 | static 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 Turner | d4136e9 | 2017-05-22 21:07:43 +0000 | [diff] [blame] | 921 | SmallVector<TypeIndex, 128> TypeMap; |
| 922 | SmallVector<TypeIndex, 128> IdMap; |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 923 | if (File.hasPDBTpiStream()) { |
| 924 | auto &Tpi = ExitOnErr(File.getPDBTpiStream()); |
Zachary Turner | d4136e9 | 2017-05-22 21:07:43 +0000 | [diff] [blame] | 925 | ExitOnErr(codeview::mergeTypeRecords(MergedTpi, TypeMap, nullptr, |
Zachary Turner | cfd8065 | 2017-05-24 00:35:32 +0000 | [diff] [blame] | 926 | Tpi.typeArray())); |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 927 | } |
| 928 | if (File.hasPDBIpiStream()) { |
| 929 | auto &Ipi = ExitOnErr(File.getPDBIpiStream()); |
Zachary Turner | d4136e9 | 2017-05-22 21:07:43 +0000 | [diff] [blame] | 930 | ExitOnErr(codeview::mergeIdRecords(MergedIpi, TypeMap, IdMap, |
Zachary Turner | cfd8065 | 2017-05-24 00:35:32 +0000 | [diff] [blame] | 931 | Ipi.typeArray())); |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 932 | } |
| 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 Kleckner | ded3880 | 2017-05-23 18:23:59 +0000 | [diff] [blame] | 945 | 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 Turner | 990d0c8 | 2017-06-12 21:34:53 +0000 | [diff] [blame] | 951 | Builder.getInfoBuilder().addFeature(PdbRaw_FeatureSig::VC140); |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 952 | |
Zachary Turner | bdc16ed | 2017-05-19 06:25:09 +0000 | [diff] [blame] | 953 | SmallString<64> OutFile(opts::merge::PdbOutputFile); |
Zachary Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 954 | 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 Turner | 6b124f2 | 2017-06-23 19:54:44 +0000 | [diff] [blame] | 961 | static bool parseRange(StringRef Str, |
| 962 | Optional<opts::bytes::NumberRange> &Parsed) { |
| 963 | if (Str.empty()) |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 964 | return true; |
| 965 | |
| 966 | llvm::Regex R("^([^-]+)(-([^-]+))?$"); |
| 967 | llvm::SmallVector<llvm::StringRef, 2> Matches; |
Zachary Turner | 6b124f2 | 2017-06-23 19:54:44 +0000 | [diff] [blame] | 968 | if (!R.match(Str, &Matches)) |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 969 | return false; |
| 970 | |
Zachary Turner | 6b124f2 | 2017-06-23 19:54:44 +0000 | [diff] [blame] | 971 | Parsed.emplace(); |
| 972 | if (!to_integer(Matches[1], Parsed->Min)) |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 973 | return false; |
| 974 | |
| 975 | if (!Matches[3].empty()) { |
Zachary Turner | 6b124f2 | 2017-06-23 19:54:44 +0000 | [diff] [blame] | 976 | Parsed->Max.emplace(); |
| 977 | if (!to_integer(Matches[3], *Parsed->Max)) |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 978 | return false; |
| 979 | } |
| 980 | return true; |
| 981 | } |
| 982 | |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 983 | int main(int argc_, const char *argv_[]) { |
| 984 | // Print a stack trace if we signal out. |
Richard Smith | 2ad6d48 | 2016-06-09 00:53:21 +0000 | [diff] [blame] | 985 | sys::PrintStackTraceOnErrorSignal(argv_[0]); |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 986 | PrettyStackTraceProgram X(argc_, argv_); |
| 987 | |
Zachary Turner | bd336e4 | 2017-06-09 20:46:17 +0000 | [diff] [blame] | 988 | ExitOnErr.setBanner("llvm-pdbutil: "); |
David Majnemer | c165c88 | 2016-05-28 18:25:15 +0000 | [diff] [blame] | 989 | |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 990 | SmallVector<const char *, 256> argv; |
David Majnemer | 6e08126 | 2015-10-15 01:27:19 +0000 | [diff] [blame] | 991 | SpecificBumpPtrAllocator<char> ArgAllocator; |
David Majnemer | c165c88 | 2016-05-28 18:25:15 +0000 | [diff] [blame] | 992 | ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector( |
| 993 | argv, makeArrayRef(argv_, argc_), ArgAllocator))); |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 994 | |
| 995 | llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. |
| 996 | |
| 997 | cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n"); |
Zachary Turner | 6b124f2 | 2017-06-23 19:54:44 +0000 | [diff] [blame] | 998 | |
| 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 Turner | 72c5b64 | 2016-09-09 18:17:52 +0000 | [diff] [blame] | 1014 | } |
Zachary Turner | a99000d | 2016-03-08 21:42:24 +0000 | [diff] [blame] | 1015 | |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 1016 | 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 Turner | 5f09852 | 2017-06-23 20:28:14 +0000 | [diff] [blame] | 1027 | opts::dump::DumpStreamBlocks = true; |
Zachary Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 1028 | 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 Turner | 44a643c | 2017-01-12 22:28:15 +0000 | [diff] [blame] | 1037 | } |
Zachary Turner | 7797c72 | 2015-03-02 04:39:56 +0000 | [diff] [blame] | 1038 | } |
Zachary Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 1039 | 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 Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 1048 | 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 Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 1059 | } |
Zachary Turner | 6305545 | 2017-06-15 22:24:24 +0000 | [diff] [blame] | 1060 | |
| 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 Turner | 3eedd16 | 2017-06-08 23:39:33 +0000 | [diff] [blame] | 1066 | } |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 1067 | |
Zachary Turner | 93839cb | 2016-06-02 05:07:49 +0000 | [diff] [blame] | 1068 | llvm::sys::InitializeCOMRAII COM(llvm::sys::COMThreadingMode::MultiThreaded); |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 1069 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 1070 | if (opts::PdbToYamlSubcommand) { |
Zachary Turner | 8848a7a | 2016-07-06 18:05:57 +0000 | [diff] [blame] | 1071 | pdb2Yaml(opts::pdb2yaml::InputFilename.front()); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 1072 | } else if (opts::YamlToPdbSubcommand) { |
Bob Haarman | de33a637 | 2017-05-17 20:46:48 +0000 | [diff] [blame] | 1073 | 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 Turner | d50c013 | 2017-02-01 18:30:22 +0000 | [diff] [blame] | 1079 | } else if (opts::AnalyzeSubcommand) { |
| 1080 | dumpAnalysis(opts::analyze::InputFilename.front()); |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 1081 | } 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 Turner | 63230a4e | 2017-04-06 23:43:12 +0000 | [diff] [blame] | 1094 | if (opts::pretty::Types) { |
| 1095 | opts::pretty::Classes = true; |
| 1096 | opts::pretty::Typedefs = true; |
| 1097 | opts::pretty::Enums = true; |
| 1098 | } |
| 1099 | |
Zachary Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 1100 | // When adding filters for excluded compilands and types, we need to |
Zachary Turner | 72c5b64 | 2016-09-09 18:17:52 +0000 | [diff] [blame] | 1101 | // 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 Turner | a30bd1a | 2016-06-30 17:42:48 +0000 | [diff] [blame] | 1105 | 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 Turner | 7df6995 | 2017-06-22 20:57:39 +0000 | [diff] [blame] | 1118 | } else if (opts::DumpSubcommand) { |
| 1119 | std::for_each(opts::dump::InputFilenames.begin(), |
| 1120 | opts::dump::InputFilenames.end(), dumpRaw); |
Zachary Turner | 9940203 | 2017-06-22 20:58:11 +0000 | [diff] [blame] | 1121 | } else if (opts::BytesSubcommand) { |
| 1122 | std::for_each(opts::bytes::InputFilenames.begin(), |
| 1123 | opts::bytes::InputFilenames.end(), dumpBytes); |
Zachary Turner | 6ac232c | 2017-03-13 23:28:25 +0000 | [diff] [blame] | 1124 | } 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 Turner | 8fb441a | 2017-05-18 23:03:41 +0000 | [diff] [blame] | 1130 | } 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 Turner | 1dc9fd3 | 2016-06-14 20:48:36 +0000 | [diff] [blame] | 1136 | } |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 1137 | |
Zachary Turner | 819e77d | 2016-05-06 20:51:57 +0000 | [diff] [blame] | 1138 | outs().flush(); |
Zachary Turner | fcb14ad | 2015-01-27 20:46:21 +0000 | [diff] [blame] | 1139 | return 0; |
| 1140 | } |