maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/tools/llvm-pdbutil/llvm-pdbutil.h

220 lines
6.7 KiB
C
Raw Normal View History

Rename llvm-pdbdump -> llvm-pdbutil. This is to reflect the evolving nature of the tool as being useful for more than just dumping PDBs, as it can do many other things. Differential Revision: https://reviews.llvm.org/D34062 llvm-svn: 305106
2017-06-10 04:46:17 +08:00
//===- llvm-pdbutil.h ----------------------------------------- *- C++ --*-===//
[llvm-pdbdump] Rewrite dumper using visitor pattern. This increases the flexibility of how to dump different symbol types -- necessary for context-sensitive formatting of symbol types -- and also improves the modularity by allowing the dumping to be implemented in the actual dumper, as opposed to in the PDB library. llvm-svn: 230184
2015-02-23 06:03:38 +08:00
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 16:50:56 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
[llvm-pdbdump] Rewrite dumper using visitor pattern. This increases the flexibility of how to dump different symbol types -- necessary for context-sensitive formatting of symbol types -- and also improves the modularity by allowing the dumping to be implemented in the actual dumper, as opposed to in the PDB library. llvm-svn: 230184
2015-02-23 06:03:38 +08:00
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
#define LLVM_TOOLS_LLVMPDBDUMP_LLVMPDBDUMP_H
[llvm-pdbutil] Allow diff to force module equivalencies. Sometimes the normal module equivalence detection algorithm doesn't quite work. For example, you might build the same program with MSVC and clang-cl, outputting to different object files, exes, and PDBs, then compare them. If the object files have different names though, then they won't be treated as equivalent. This way we can force specific module indices to be treated as equivalent. llvm-svn: 309983
2017-08-04 04:30:09 +08:00
#include "llvm/ADT/DenseMap.h"
[pdb] Add command line options for dumping individual streams and blocks I ran into a situation where I wanted to print out the contents of page 6 of a PDB as a binary blob, and there was no straightforward way to do that. In addition to adding that, this patch also adds the ability to dump a stream by index as a binary blob, and it will stitch together all the blocks and dump the whole thing as one seemingly contiguous sequence of bytes. llvm-svn: 281070
2016-09-10 02:17:52 +08:00
#include "llvm/ADT/Optional.h"
[llvm-pdbutil] Support dumping CodeView from object files. We have llvm-readobj for dumping CodeView from object files, and llvm-pdbutil has always been more focused on PDB. However, llvm-pdbutil has a lot of useful options for summarizing debug information in aggregate and presenting high level statistical views. Furthermore, it's arguably better as a testing tool since we don't have to write tests to conform to a state-machine like structure where you match multiple lines in succession, each depending on a previous match. llvm-pdbutil dumps much more concisely, so it's possible to use single-line matches in many cases where as with readobj tests you have to use multi-line matches with an implicit state machine. Because of this, I'm adding object file support to llvm-pdbutil. In fact, this mirrors the cvdump tool from Microsoft, which also supports both object files and pdb files. In the future we could perhaps rename this tool llvm-cvutil. In the meantime, this allows us to deep dive into object files the same way we already can with PDB files. llvm-svn: 312358
2017-09-02 04:06:56 +08:00
#include "llvm/ADT/PointerUnion.h"
[llvm-pdbdump] Many minor fixes and improvements A short list of some of the improvements: 1) Now supports -all command line argument, which implies many other command line arguments to simplify usage. 2) Now supports -no-compiler-generated command line argument to exclude compiler generated types. 3) Prints base class list. 4) -class-definitions implies -types. 5) Proper display of bitfields. 6) Can now distinguish between struct/class/interface/union. And a few other minor tweaks. llvm-svn: 230933
2015-03-02 12:39:56 +08:00
#include "llvm/Support/CommandLine.h"
[llvm-pdbdump] Rewrite dumper using visitor pattern. This increases the flexibility of how to dump different symbol types -- necessary for context-sensitive formatting of symbol types -- and also improves the modularity by allowing the dumping to be implemented in the actual dumper, as opposed to in the PDB library. llvm-svn: 230184
2015-02-23 06:03:38 +08:00
#include "llvm/Support/raw_ostream.h"
[llvm-pdbdump] Add the option to sort functions and data. llvm-svn: 302998
2017-05-14 09:13:40 +08:00
#include <memory>
#include <stdint.h>
namespace llvm {
[llvm-pdbutil] Support dumping CodeView from object files. We have llvm-readobj for dumping CodeView from object files, and llvm-pdbutil has always been more focused on PDB. However, llvm-pdbutil has a lot of useful options for summarizing debug information in aggregate and presenting high level statistical views. Furthermore, it's arguably better as a testing tool since we don't have to write tests to conform to a state-machine like structure where you match multiple lines in succession, each depending on a previous match. llvm-pdbutil dumps much more concisely, so it's possible to use single-line matches in many cases where as with readobj tests you have to use multi-line matches with an implicit state machine. Because of this, I'm adding object file support to llvm-pdbutil. In fact, this mirrors the cvdump tool from Microsoft, which also supports both object files and pdb files. In the future we could perhaps rename this tool llvm-cvutil. In the meantime, this allows us to deep dive into object files the same way we already can with PDB files. llvm-svn: 312358
2017-09-02 04:06:56 +08:00
namespace object {
class COFFObjectFile;
}
[llvm-pdbdump] Add the option to sort functions and data. llvm-svn: 302998
2017-05-14 09:13:40 +08:00
namespace pdb {
class PDBSymbolData;
class PDBSymbolFunc;
[llvm-pdbutil] Support dumping CodeView from object files. We have llvm-readobj for dumping CodeView from object files, and llvm-pdbutil has always been more focused on PDB. However, llvm-pdbutil has a lot of useful options for summarizing debug information in aggregate and presenting high level statistical views. Furthermore, it's arguably better as a testing tool since we don't have to write tests to conform to a state-machine like structure where you match multiple lines in succession, each depending on a previous match. llvm-pdbutil dumps much more concisely, so it's possible to use single-line matches in many cases where as with readobj tests you have to use multi-line matches with an implicit state machine. Because of this, I'm adding object file support to llvm-pdbutil. In fact, this mirrors the cvdump tool from Microsoft, which also supports both object files and pdb files. In the future we could perhaps rename this tool llvm-cvutil. In the meantime, this allows us to deep dive into object files the same way we already can with PDB files. llvm-svn: 312358
2017-09-02 04:06:56 +08:00
class PDBFile;
[llvm-pdbdump] Add the option to sort functions and data. llvm-svn: 302998
2017-05-14 09:13:40 +08:00
uint32_t getTypeLength(const PDBSymbolData &Symbol);
}
[llvm-pdbutil] Support dumping CodeView from object files. We have llvm-readobj for dumping CodeView from object files, and llvm-pdbutil has always been more focused on PDB. However, llvm-pdbutil has a lot of useful options for summarizing debug information in aggregate and presenting high level statistical views. Furthermore, it's arguably better as a testing tool since we don't have to write tests to conform to a state-machine like structure where you match multiple lines in succession, each depending on a previous match. llvm-pdbutil dumps much more concisely, so it's possible to use single-line matches in many cases where as with readobj tests you have to use multi-line matches with an implicit state machine. Because of this, I'm adding object file support to llvm-pdbutil. In fact, this mirrors the cvdump tool from Microsoft, which also supports both object files and pdb files. In the future we could perhaps rename this tool llvm-cvutil. In the meantime, this allows us to deep dive into object files the same way we already can with PDB files. llvm-svn: 312358
2017-09-02 04:06:56 +08:00
typedef llvm::PointerUnion<object::COFFObjectFile *, pdb::PDBFile *>
PdbOrCoffObj;
[llvm-pdbdump] Add the option to sort functions and data. llvm-svn: 302998
2017-05-14 09:13:40 +08:00
}
[llvm-pdbdump] Many minor fixes and improvements A short list of some of the improvements: 1) Now supports -all command line argument, which implies many other command line arguments to simplify usage. 2) Now supports -no-compiler-generated command line argument to exclude compiler generated types. 3) Prints base class list. 4) -class-definitions implies -types. 5) Proper display of bitfields. 6) Can now distinguish between struct/class/interface/union. And a few other minor tweaks. llvm-svn: 230933
2015-03-02 12:39:56 +08:00
namespace opts {
[llvm-pdbdump] Introduce an abstraction for the output style. This opens the door to introducing a YAML outputter which can be used for machine consumption. Currently the yaml output style is unimplemented and returns an error if you try to use it. Reviewed By: rnk, ruiu Differential Revision: http://reviews.llvm.org/D20967 llvm-svn: 271712
2016-06-04 03:28:33 +08:00
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
enum class DumpLevel { None, Basic, Verbose };
[llvm-pdbdump] Improve consistency among subcommands. The pdb2yaml and raw subcommands did something very similar but with a different output format, and they used a lot of the same command line options, but each one re-implemented the command line option with slightly different spellings / options. This patch merges them together into a single definition which is shared by both subcommands. This new syntax also allows for more flexibility in the way debug subsections are dumped. Differential Revision: https://reviews.llvm.org/D33996 llvm-svn: 305032
2017-06-09 07:39:33 +08:00
enum class ModuleSubsection {
Unknown,
Lines,
FileChecksums,
InlineeLines,
CrossScopeImports,
CrossScopeExports,
[CodeView] Support remaining debug subsection types This adds support for Symbols, StringTable, and FrameData subsection types. Even though these subsections rarely if ever appear in a PDB file (they are usually in object files), there's no theoretical reason why they *couldn't* appear in a PDB. The real issue though is that in order to add support for dumping and writing them (which will be useful for object files), we need a way to test them. And since there is no support for reading and writing them to / from object files yet, making PDB support them is the best way to both add support for the underlying format and add support for tests at the same time. Later, when we go to add support for reading / writing them from object files, we'll need only minimal changes in the underlying read/write code. llvm-svn: 305037
2017-06-09 08:28:08 +08:00
StringTable,
Symbols,
FrameData,
[pdb] Support CoffSymbolRVA debug subsection. llvm-svn: 305108
2017-06-10 04:46:52 +08:00
CoffSymbolRVAs,
[llvm-pdbdump] Improve consistency among subcommands. The pdb2yaml and raw subcommands did something very similar but with a different output format, and they used a lot of the same command line options, but each one re-implemented the command line option with slightly different spellings / options. This patch merges them together into a single definition which is shared by both subcommands. This new syntax also allows for more flexibility in the way debug subsections are dumped. Differential Revision: https://reviews.llvm.org/D33996 llvm-svn: 305032
2017-06-09 07:39:33 +08:00
All
};
Update llvm-pdbdump to use subcommands. llvm-svn: 274247
2016-07-01 01:42:48 +08:00
namespace pretty {
[llvm-pdbdump] Display padding bytes on record layout When dumping classes, show where padding occurs, and at the end of the class print statistics about how many bytes total of padding exist in a class. Since PDB doesn't specifically contain information about padding, we have to mimic this by sort of reversing a small portion of the record layout algorithm (e.g. looking at offsets and sizes and trying to determine whether something is part of the same field or a new field). Differential Revision: https://reviews.llvm.org/D31800 llvm-svn: 299869
2017-04-11 03:33:29 +08:00
[llvm-pdbdump] Merge functionality of graphical and text dumpers. The *real* difference between these two was that a) The "graphical" dumper could recurse, while the text one could not. b) The "text" dumper could display nested types and functions, while the graphical one could not. Merge these two so that there is only one dumper that can recurse arbitrarily deep and optionally display nested types or not. llvm-svn: 301204
2017-04-25 01:47:52 +08:00
enum class ClassDefinitionFormat { None, Layout, All };
[llvm-pdbdump] Allow sorting / filtering by immediate padding llvm-svn: 301358
2017-04-26 04:22:29 +08:00
enum class ClassSortMode {
None,
Name,
Size,
Padding,
PaddingPct,
PaddingImmediate,
PaddingPctImmediate
};
Allow specification of what kinds of class members to dump. Previously when dumping class definitions, there were only two modes - on or off. But it's useful to sometimes get a little more fine-grained. For example, you might only want to see the record layout (for example to look for extraneous padding). This patch adds a third mode, layout mode, which does exactly that. Only this-relative data members are displayed in this mode. Differential Revision: https://reviews.llvm.org/D31794 llvm-svn: 299733
2017-04-07 07:43:39 +08:00
[llvm-pdbdump] Add the option to sort functions and data. llvm-svn: 302998
2017-05-14 09:13:40 +08:00
enum class SymbolSortMode { None, Name, Size };
enum class SymLevel { Functions, Data, Thunks, All };
bool shouldDumpSymLevel(SymLevel Level);
bool compareFunctionSymbols(
const std::unique_ptr<llvm::pdb::PDBSymbolFunc> &F1,
const std::unique_ptr<llvm::pdb::PDBSymbolFunc> &F2);
bool compareDataSymbols(const std::unique_ptr<llvm::pdb::PDBSymbolData> &F1,
const std::unique_ptr<llvm::pdb::PDBSymbolData> &F2);
[PDB] One more fix for hasing GSI records. The reference implementation uses a case-insensitive string comparison for strings of equal length. This will cause the string "tEo" to compare less than "VUo". However we were using a case sensitive comparison, which would generate the opposite outcome. Switch to a case insensitive comparison. Also, when one of the strings contains non-ascii characters, fallback to a straight memcmp. The only way to really test this is with a DIA test. Before this patch, the test will fail (but succeed if link.exe is used instead of lld-link). After the patch, it succeeds even with lld-link. llvm-svn: 336464
2018-07-07 05:01:42 +08:00
extern llvm::cl::list<std::string> WithName;
[llvm-pdbdump] Many minor fixes and improvements A short list of some of the improvements: 1) Now supports -all command line argument, which implies many other command line arguments to simplify usage. 2) Now supports -no-compiler-generated command line argument to exclude compiler generated types. 3) Prints base class list. 4) -class-definitions implies -types. 5) Proper display of bitfields. 6) Can now distinguish between struct/class/interface/union. And a few other minor tweaks. llvm-svn: 230933
2015-03-02 12:39:56 +08:00
extern llvm::cl::opt<bool> Compilands;
extern llvm::cl::opt<bool> Symbols;
extern llvm::cl::opt<bool> Globals;
[llvm-pdbdump] Allow pretty to only dump specific types of types. Previously we just had the -types option, which would dump all classes, typedefs, and enums. But this produces a lot of output if you only want to view classes, for example. This patch breaks this down into 3 additional options, -classes, -enums, and -typedefs, and keeps the -types option around which implies all 3 more specific options. Differential Revision: https://reviews.llvm.org/D31791 llvm-svn: 299732
2017-04-07 07:43:12 +08:00
extern llvm::cl::opt<bool> Classes;
extern llvm::cl::opt<bool> Enums;
[NativePDB] Add support for reading function signatures. This adds support for parsing function signature records and returning them through the native DIA interface. llvm-svn: 342780
2018-09-22 06:36:28 +08:00
extern llvm::cl::opt<bool> Funcsigs;
[PDB] Add native support for dumping array types. llvm-svn: 343412
2018-10-01 00:19:18 +08:00
extern llvm::cl::opt<bool> Arrays;
[llvm-pdbdump] Allow pretty to only dump specific types of types. Previously we just had the -types option, which would dump all classes, typedefs, and enums. But this produces a lot of output if you only want to view classes, for example. This patch breaks this down into 3 additional options, -classes, -enums, and -typedefs, and keeps the -types option around which implies all 3 more specific options. Differential Revision: https://reviews.llvm.org/D31791 llvm-svn: 299732
2017-04-07 07:43:12 +08:00
extern llvm::cl::opt<bool> Typedefs;
[PDB] Better native API support for pointers. We didn't properly detect when a pointer was a member pointer, and when that was the case we were not properly returning class parent info. This caused member pointers to render incorrectly in pretty mode. However, we didn't even have pretty tests for pointers in native mode, so those are also added now to ensure this. llvm-svn: 343393
2018-09-30 07:28:19 +08:00
extern llvm::cl::opt<bool> Pointers;
[PDB] Add support for parsing VFTable Shape records. This allows them to be returned from the native API. llvm-svn: 343506
2018-10-02 01:55:16 +08:00
extern llvm::cl::opt<bool> VTShapes;
[llvm-pdbdump] Many minor fixes and improvements A short list of some of the improvements: 1) Now supports -all command line argument, which implies many other command line arguments to simplify usage. 2) Now supports -no-compiler-generated command line argument to exclude compiler generated types. 3) Prints base class list. 4) -class-definitions implies -types. 5) Proper display of bitfields. 6) Can now distinguish between struct/class/interface/union. And a few other minor tweaks. llvm-svn: 230933
2015-03-02 12:39:56 +08:00
extern llvm::cl::opt<bool> All;
Update llvm-pdbdump to use subcommands. llvm-svn: 274247
2016-07-01 01:42:48 +08:00
extern llvm::cl::opt<bool> ExcludeCompilerGenerated;
extern llvm::cl::opt<bool> NoEnumDefs;
extern llvm::cl::list<std::string> ExcludeTypes;
extern llvm::cl::list<std::string> ExcludeSymbols;
extern llvm::cl::list<std::string> ExcludeCompilands;
extern llvm::cl::list<std::string> IncludeTypes;
extern llvm::cl::list<std::string> IncludeSymbols;
extern llvm::cl::list<std::string> IncludeCompilands;
[llvm-pdbdump] Add the option to sort functions and data. llvm-svn: 302998
2017-05-14 09:13:40 +08:00
extern llvm::cl::opt<SymbolSortMode> SymbolOrder;
[llvm-pdbdump] Recursively dump class layout. llvm-svn: 300258
2017-04-14 05:11:00 +08:00
extern llvm::cl::opt<ClassSortMode> ClassOrder;
extern llvm::cl::opt<uint32_t> SizeThreshold;
extern llvm::cl::opt<uint32_t> PaddingThreshold;
[llvm-pdbdump] Allow sorting / filtering by immediate padding llvm-svn: 301358
2017-04-26 04:22:29 +08:00
extern llvm::cl::opt<uint32_t> ImmediatePaddingThreshold;
[llvm-pdbdump] Display padding bytes on record layout When dumping classes, show where padding occurs, and at the end of the class print statistics about how many bytes total of padding exist in a class. Since PDB doesn't specifically contain information about padding, we have to mimic this by sort of reversing a small portion of the record layout algorithm (e.g. looking at offsets and sizes and trying to determine whether something is part of the same field or a new field). Differential Revision: https://reviews.llvm.org/D31800 llvm-svn: 299869
2017-04-11 03:33:29 +08:00
extern llvm::cl::opt<ClassDefinitionFormat> ClassFormat;
[llvm-pdbdump] Merge functionality of graphical and text dumpers. The *real* difference between these two was that a) The "graphical" dumper could recurse, while the text one could not. b) The "text" dumper could display nested types and functions, while the graphical one could not. Merge these two so that there is only one dumper that can recurse arbitrarily deep and optionally display nested types or not. llvm-svn: 301204
2017-04-25 01:47:52 +08:00
extern llvm::cl::opt<uint32_t> ClassRecursionDepth;
Update llvm-pdbdump to use subcommands. llvm-svn: 274247
2016-07-01 01:42:48 +08:00
}
[llvm-pdbdump] Rewrite dumper using visitor pattern. This increases the flexibility of how to dump different symbol types -- necessary for context-sensitive formatting of symbol types -- and also improves the modularity by allowing the dumping to be implemented in the actual dumper, as opposed to in the PDB library. llvm-svn: 230184
2015-02-23 06:03:38 +08:00
[llvm-pdbutil] Create a "bytes" subcommand. This idea originally came about when I was doing some deep investigation of why certain bytes in a PDB that we round-tripped differed from their original bytes in the source PDB. I found myself having to hack up the code in many places to dump the bytes of this substream, or that record. It would be nice if we could just do this for every possible stream, substream, debug chunk type, etc. It doesn't make sense to put this under dump because there's just so many options that would detract from the more common use case of just dumping deserialized records. So making a new subcommand seems like the most logical course of action. In doing so, we already have two command line options that are suitable for this new subcommand, so start out by moving them there. llvm-svn: 306056
2017-06-23 04:58:11 +08:00
namespace bytes {
[llvm-pdbutil] Add the ability to dump raw bytes from the file. Normally we can only make sense of the content of a PDB in terms of streams and blocks, but in some cases it may be useful to dump bytes at a specific absolute file offset. For example, if you know that some interesting data is at a particular location and you want to see some surrounding data. llvm-svn: 306146
2017-06-24 03:54:44 +08:00
struct NumberRange {
uint64_t Min;
llvm::Optional<uint64_t> Max;
[pdb] Add command line options for dumping individual streams and blocks I ran into a situation where I wanted to print out the contents of page 6 of a PDB as a binary blob, and there was no straightforward way to do that. In addition to adding that, this patch also adds the ability to dump a stream by index as a binary blob, and it will stitch together all the blocks and dump the whole thing as one seemingly contiguous sequence of bytes. llvm-svn: 281070
2016-09-10 02:17:52 +08:00
};
[llvm-pdbutil] Add the ability to dump raw bytes from the file. Normally we can only make sense of the content of a PDB in terms of streams and blocks, but in some cases it may be useful to dump bytes at a specific absolute file offset. For example, if you know that some interesting data is at a particular location and you want to see some surrounding data. llvm-svn: 306146
2017-06-24 03:54:44 +08:00
extern llvm::Optional<NumberRange> DumpBlockRange;
extern llvm::Optional<NumberRange> DumpByteRange;
[llvm-pdbutil] Create a "bytes" subcommand. This idea originally came about when I was doing some deep investigation of why certain bytes in a PDB that we round-tripped differed from their original bytes in the source PDB. I found myself having to hack up the code in many places to dump the bytes of this substream, or that record. It would be nice if we could just do this for every possible stream, substream, debug chunk type, etc. It doesn't make sense to put this under dump because there's just so many options that would detract from the more common use case of just dumping deserialized records. So making a new subcommand seems like the most logical course of action. In doing so, we already have two command line options that are suitable for this new subcommand, so start out by moving them there. llvm-svn: 306056
2017-06-23 04:58:11 +08:00
extern llvm::cl::list<std::string> DumpStreamData;
[llvm-pdbutil] Dump raw bytes of pdb name map. This patch dumps the raw bytes of the pdb name map which contains the mapping of stream name to stream index for the string table and other reserved streams. llvm-svn: 306148
2017-06-24 04:18:38 +08:00
extern llvm::cl::opt<bool> NameMap;
[pdbutil] Add a command to dump the FPM. Recently problems have been discovered in the way we write the FPM (free page map). In order to fix this, we first need to establish a baseline about what a correct FPM looks like using an MSVC generated PDB, so that we can then make our own generated PDBs match. And in order to do this, the dumper needs a mode where it can dump an FPM so that we can write tests for it. This patch adds a command to dump the FPM, as well as a test against a known-good PDB. llvm-svn: 309894
2017-08-03 06:25:52 +08:00
extern llvm::cl::opt<bool> Fpm;
[llvm-pdbutil] Dump raw bytes of various DBI stream subsections. llvm-svn: 306160
2017-06-24 05:11:54 +08:00
extern llvm::cl::opt<bool> SectionContributions;
extern llvm::cl::opt<bool> SectionMap;
extern llvm::cl::opt<bool> ModuleInfos;
extern llvm::cl::opt<bool> FileInfo;
extern llvm::cl::opt<bool> TypeServerMap;
extern llvm::cl::opt<bool> ECData;
[llvm-pdbutil] Dump raw bytes of type and id records. llvm-svn: 306167
2017-06-24 05:50:54 +08:00
extern llvm::cl::list<uint32_t> TypeIndex;
extern llvm::cl::list<uint32_t> IdIndex;
[llvm-pdbutil] Dump raw bytes of module symbols and debug chunks. llvm-svn: 306179
2017-06-24 07:08:57 +08:00
extern llvm::cl::opt<uint32_t> ModuleIndex;
extern llvm::cl::opt<bool> ModuleSyms;
extern llvm::cl::opt<bool> ModuleC11;
extern llvm::cl::opt<bool> ModuleC13;
[llvm-pdbutil] Add a mode to `bytes` for dumping split debug chunks. llvm-svn: 306309
2017-06-27 01:22:36 +08:00
extern llvm::cl::opt<bool> SplitChunks;
[llvm-pdbutil] Create a "bytes" subcommand. This idea originally came about when I was doing some deep investigation of why certain bytes in a PDB that we round-tripped differed from their original bytes in the source PDB. I found myself having to hack up the code in many places to dump the bytes of this substream, or that record. It would be nice if we could just do this for every possible stream, substream, debug chunk type, etc. It doesn't make sense to put this under dump because there's just so many options that would detract from the more common use case of just dumping deserialized records. So making a new subcommand seems like the most logical course of action. In doing so, we already have two command line options that are suitable for this new subcommand, so start out by moving them there. llvm-svn: 306056
2017-06-23 04:58:11 +08:00
} // namespace bytes
namespace dump {
[pdb] Add command line options for dumping individual streams and blocks I ran into a situation where I wanted to print out the contents of page 6 of a PDB as a binary blob, and there was no straightforward way to do that. In addition to adding that, this patch also adds the ability to dump a stream by index as a binary blob, and it will stitch together all the blocks and dump the whole thing as one seemingly contiguous sequence of bytes. llvm-svn: 281070
2016-09-10 02:17:52 +08:00
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> DumpSummary;
[pdbutil] Add a command to dump the FPM. Recently problems have been discovered in the way we write the FPM (free page map). In order to fix this, we first need to establish a baseline about what a correct FPM looks like using an MSVC generated PDB, so that we can then make our own generated PDBs match. And in order to do this, the dumper needs a mode where it can dump an FPM so that we can write tests for it. This patch adds a command to dump the FPM, as well as a test against a known-good PDB. llvm-svn: 309894
2017-08-03 06:25:52 +08:00
extern llvm::cl::opt<bool> DumpFpm;
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> DumpStreams;
[llvm-pdbutil] Print detailed S_UDT stats. This adds a new command line option, -udt-stats, which breaks down the stats of S_UDT records. These are one of the biggest contributors to the size of /DEBUG:FASTLINK PDBs, so they need some additional tools to be able to analyze their usage. This option will dig into each S_UDT record and determine what kind of record it points to, and then break down the statistics by the target type. The goal here is to identify how our object files differ from MSVC object files in S_UDT records, so that we can output fewer of them and reach size parity. llvm-svn: 312276
2017-09-01 04:43:22 +08:00
extern llvm::cl::opt<bool> DumpSymbolStats;
[pdb] Add -type-stats and sort stats by descending size Summary: It prints this on chromium browser_tests.exe.pdb: Types Total: 5647475 entries ( 371,897,512 bytes, 65.85 avg) -------------------------------------------------------------------------- LF_CLASS: 397894 entries ( 119,537,780 bytes, 300.43 avg) LF_STRUCTURE: 236351 entries ( 83,208,084 bytes, 352.05 avg) LF_FIELDLIST: 291003 entries ( 66,087,920 bytes, 227.10 avg) LF_MFUNCTION: 1884176 entries ( 52,756,928 bytes, 28.00 avg) LF_POINTER: 1149030 entries ( 13,877,344 bytes, 12.08 avg) LF_ARGLIST: 789980 entries ( 12,436,752 bytes, 15.74 avg) LF_METHODLIST: 361498 entries ( 8,351,008 bytes, 23.10 avg) LF_ENUM: 16069 entries ( 6,108,340 bytes, 380.13 avg) LF_PROCEDURE: 269374 entries ( 4,309,984 bytes, 16.00 avg) LF_MODIFIER: 235602 entries ( 2,827,224 bytes, 12.00 avg) LF_UNION: 9131 entries ( 2,072,168 bytes, 226.94 avg) LF_VFTABLE: 323 entries ( 207,784 bytes, 643.29 avg) LF_ARRAY: 6639 entries ( 106,380 bytes, 16.02 avg) LF_VTSHAPE: 126 entries ( 6,472 bytes, 51.37 avg) LF_BITFIELD: 278 entries ( 3,336 bytes, 12.00 avg) LF_LABEL: 1 entries ( 8 bytes, 8.00 avg) The PDB is overall 1.9GB, so the LF_CLASS and LF_STRUCTURE declarations account for about 10% of the overall file size. I was surprised to find that on average LF_FIELDLIST records are short. Maybe this is because there are many more types with short member lists than there are instantiations with lots of members, like std::vector. Reviewers: aganea, zturner Subscribers: llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D59672 llvm-svn: 356813
2019-03-23 05:22:13 +08:00
extern llvm::cl::opt<bool> DumpTypeStats;
[llvm-pdbutil] Print detailed S_UDT stats. This adds a new command line option, -udt-stats, which breaks down the stats of S_UDT records. These are one of the biggest contributors to the size of /DEBUG:FASTLINK PDBs, so they need some additional tools to be able to analyze their usage. This option will dig into each S_UDT record and determine what kind of record it points to, and then break down the statistics by the target type. The goal here is to identify how our object files differ from MSVC object files in S_UDT records, so that we can output fewer of them and reach size parity. llvm-svn: 312276
2017-09-01 04:43:22 +08:00
extern llvm::cl::opt<bool> DumpUdtStats;
[llvm-pdbutil] Show what blocks a stream occupies. This is useful when you want to look at a specific chunk of a stream or look for discontinuities, and you need to know the list of blocks occupied by a stream. llvm-svn: 306150
2017-06-24 04:28:14 +08:00
extern llvm::cl::opt<bool> DumpStreamBlocks;
[llvm-pdbutil] Add support for dumping lines and inlinee lines. llvm-svn: 305529
2017-06-16 07:56:19 +08:00
extern llvm::cl::opt<bool> DumpLines;
extern llvm::cl::opt<bool> DumpInlineeLines;
[llvm-pdbutil] Add support for dumping cross module imports/exports. llvm-svn: 305532
2017-06-16 08:04:24 +08:00
extern llvm::cl::opt<bool> DumpXmi;
extern llvm::cl::opt<bool> DumpXme;
[PDB] Make our PDBs look more like MS PDBs. When investigating bugs in PDB generation, the first step is often to do the same link with link.exe and then compare PDBs. But comparing PDBs is hard because two completely different byte sequences can both be correct, so it hampers the investigation when you also have to spend time figuring out not just which bytes are different, but also if the difference is meaningful. This patch fixes a couple of cases related to string table emission, hash table emission, and the order in which we emit strings that makes more of our bytes the same as the bytes generated by MS PDBs. Differential Revision: https://reviews.llvm.org/D44810 llvm-svn: 328348
2018-03-24 02:43:39 +08:00
extern llvm::cl::opt<bool> DumpNamedStreams;
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> DumpStringTable;
[PDB] Make our PDBs look more like MS PDBs. When investigating bugs in PDB generation, the first step is often to do the same link with link.exe and then compare PDBs. But comparing PDBs is hard because two completely different byte sequences can both be correct, so it hampers the investigation when you also have to spend time figuring out not just which bytes are different, but also if the difference is meaningful. This patch fixes a couple of cases related to string table emission, hash table emission, and the order in which we emit strings that makes more of our bytes the same as the bytes generated by MS PDBs. Differential Revision: https://reviews.llvm.org/D44810 llvm-svn: 328348
2018-03-24 02:43:39 +08:00
extern llvm::cl::opt<bool> DumpStringTableDetails;
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> DumpTypes;
extern llvm::cl::opt<bool> DumpTypeData;
[llvm-pdbutil] Add back the ability to dump hashes and index offsets. This was regressed in a previous patch that re-wrote the dumper, and I'm incrementally adding back the pieces that are missing. llvm-svn: 305524
2017-06-16 07:04:42 +08:00
extern llvm::cl::opt<bool> DumpTypeExtras;
Remove some dead code / includes. I'm trying to get rid of the TypeDatabase class, so the first step is to minimize its footprint. llvm-svn: 305611
2017-06-17 07:42:15 +08:00
extern llvm::cl::list<uint32_t> DumpTypeIndex;
[llvm-pdbutil] Add the ability to dump the dependency tree for a type Previously we had the -type-index option which would dump the record of a single, but we had no way to follow the dependency graph backwards and also dump all dependent types. Having this option makes test-writing better, because we can limit the test to only those records that are of importance for the thing we're trying to test, which allows us to use things like CHECK-NEXT to reduce fragility. Differential Revision: https://reviews.llvm.org/D34899 llvm-svn: 306852
2017-07-01 02:15:47 +08:00
extern llvm::cl::opt<bool> DumpTypeDependents;
[llvm-pdbutil] Add -type-ref-stats to help find unused type info Summary: This considers module symbol streams and the global symbol stream to be roots. Most types that this considers "unreferenced" are referenced by LF_UDT_MOD_SRC_LINE id records, which VC seems to always include. Essentially, they are types that the user can only find in the debugger if they call them by name, they cannot be found by traversing a symbol. In practice, around 80% of type information in a PDB is referenced by a symbol. That seems like a reasonable number. I don't really plan to do anything with this tool. It mostly just exists for informational purposes, and to confirm that we probably don't need to implement type reference tracking in LLD. We can continue to merge all types as we do today without wasting space. Reviewers: zturner, aganea Subscribers: mgorny, hiraditya, arphaman, jdoerfert, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D59620 llvm-svn: 356692
2019-03-22 02:02:34 +08:00
extern llvm::cl::opt<bool> DumpTypeRefStats;
[llvm-pdbutil] Dump image section headers. Image section headers are stored in the DBI stream, but we had no way to dump them. This patch adds dumping support, along with some tests that LLD actually dumps them correctly. Differential Revision: https://reviews.llvm.org/D36332 llvm-svn: 310107
2017-08-05 04:02:38 +08:00
extern llvm::cl::opt<bool> DumpSectionHeaders;
Remove some dead code / includes. I'm trying to get rid of the TypeDatabase class, so the first step is to minimize its footprint. llvm-svn: 305611
2017-06-17 07:42:15 +08:00
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> DumpIds;
extern llvm::cl::opt<bool> DumpIdData;
[llvm-pdbutil] Add back the ability to dump hashes and index offsets. This was regressed in a previous patch that re-wrote the dumper, and I'm incrementally adding back the pieces that are missing. llvm-svn: 305524
2017-06-16 07:04:42 +08:00
extern llvm::cl::opt<bool> DumpIdExtras;
Remove some dead code / includes. I'm trying to get rid of the TypeDatabase class, so the first step is to minimize its footprint. llvm-svn: 305611
2017-06-17 07:42:15 +08:00
extern llvm::cl::list<uint32_t> DumpIdIndex;
[llvm-pdbutil] Add an option to only dump specific module indices. Often something interesting (like a symbol) is in a particular module, and you don't want to dump symbols from all other 300 modules to see the one you want. This adds a -modi option so that we only dump the specified module. llvm-svn: 310000
2017-08-04 07:11:52 +08:00
extern llvm::cl::opt<uint32_t> DumpModi;
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 22:53:25 +08:00
extern llvm::cl::opt<bool> JustMyCode;
[PDB] Add the ability to map forward references to full decls. Some records point to an LF_CLASS, LF_UNION, LF_STRUCTURE, or LF_ENUM which is a forward reference and doesn't contain complete debug information. In these cases, we'd like to be able to quickly locate the full record. The TPI stream stores an array of pre-computed record hash values, one for each type record. If we pre-process this on startup, we can build a mapping from hash value -> {list of possible matching type indices}. Since hashes of full records are only based on the name and or unique name and not the full record contents, we can then use forward ref record to compute the hash of what *would* be the full record by just hashing the name, use this to get the list of possible matches, and iterate those looking for a match on name or unique name. llvm-pdbutil is updated to resolve forward references for the purposes of testing (plus it's just useful). Differential Revision: https://reviews.llvm.org/D52283 llvm-svn: 342656
2018-09-20 23:50:13 +08:00
extern llvm::cl::opt<bool> DontResolveForwardRefs;
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> DumpSymbols;
extern llvm::cl::opt<bool> DumpSymRecordBytes;
[llvm-pdbutil] Dump more info about globals. We add an option to dump the entire global / public symbol record stream. Previously we would dump globals or publics, but not both. And when we did dump them, we would always dump them in the order they were referenced by the corresponding hash streams, not in the order they were serialized in. This patch adds a lower level mode that just dumps the whole stream in serialization order. Additionally, when dumping global-extras, we now dump the hash bitmap as well as the record offset instead of dumping all zeros for the offsets. llvm-svn: 336407
2018-07-06 10:59:25 +08:00
extern llvm::cl::opt<bool> DumpGSIRecords;
[PDB] Improve GSI hash table dumping for publics and globals The PDB "symbol stream" actually contains symbol records for the publics and the globals stream. The globals and publics streams are essentially hash tables that point into a single stream of records. In order to match cvdump's behavior, we need to only dump symbol records referenced from the hash table. This patch implements that, and then implements global stream dumping, since it's just a subset of public stream dumping. Now we shouldn't see S_PROCREF or S_GDATA32 records when dumping publics, and instead we should see those record in the globals stream. llvm-svn: 309066
2017-07-26 08:40:36 +08:00
extern llvm::cl::opt<bool> DumpGlobals;
[PDB] Add the ability to lookup global symbols by name. The Globals table is a hash table keyed on symbol name, so it's possible to lookup symbols by name in O(1) time. Add a function to the globals stream to do this, and add an option to llvm-pdbutil to exercise this, then use it to write some tests to verify correctness. llvm-svn: 343951
2018-10-08 12:19:16 +08:00
extern llvm::cl::list<std::string> DumpGlobalNames;
[PDB] Improve GSI hash table dumping for publics and globals The PDB "symbol stream" actually contains symbol records for the publics and the globals stream. The globals and publics streams are essentially hash tables that point into a single stream of records. In order to match cvdump's behavior, we need to only dump symbol records referenced from the hash table. This patch implements that, and then implements global stream dumping, since it's just a subset of public stream dumping. Now we shouldn't see S_PROCREF or S_GDATA32 records when dumping publics, and instead we should see those record in the globals stream. llvm-svn: 309066
2017-07-26 08:40:36 +08:00
extern llvm::cl::opt<bool> DumpGlobalExtras;
[llvm-pdbdump] Introduce an abstraction for the output style. This opens the door to introducing a YAML outputter which can be used for machine consumption. Currently the yaml output style is unimplemented and returns an error if you try to use it. Reviewed By: rnk, ruiu Differential Revision: http://reviews.llvm.org/D20967 llvm-svn: 271712
2016-06-04 03:28:33 +08:00
extern llvm::cl::opt<bool> DumpPublics;
[PDB] Dump extra info about the publics stream This includes the hash table, the address map, and the thunk table and section offset table. The last two are only used for incremental linking, which LLD doesn't support, so they are less interesting. The hash table is particularly important to get right, since this is the one of the streams that debuggers use to translate addresses to symbols. llvm-svn: 308764
2017-07-22 02:28:55 +08:00
extern llvm::cl::opt<bool> DumpPublicExtras;
[llvm-pdbdump] Introduce an abstraction for the output style. This opens the door to introducing a YAML outputter which can be used for machine consumption. Currently the yaml output style is unimplemented and returns an error if you try to use it. Reviewed By: rnk, ruiu Differential Revision: http://reviews.llvm.org/D20967 llvm-svn: 271712
2016-06-04 03:28:33 +08:00
extern llvm::cl::opt<bool> DumpSectionContribs;
extern llvm::cl::opt<bool> DumpSectionMap;
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> DumpModules;
extern llvm::cl::opt<bool> DumpModuleFiles;
[PDB] Write FPO Data to the PDB. llvm-svn: 342003
2018-09-12 06:35:01 +08:00
extern llvm::cl::opt<bool> DumpFpo;
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
extern llvm::cl::opt<bool> RawAll;
Update llvm-pdbdump to use subcommands. llvm-svn: 274247
2016-07-01 01:42:48 +08:00
}
[llvm-pdbdump] Introduce an abstraction for the output style. This opens the door to introducing a YAML outputter which can be used for machine consumption. Currently the yaml output style is unimplemented and returns an error if you try to use it. Reviewed By: rnk, ruiu Differential Revision: http://reviews.llvm.org/D20967 llvm-svn: 271712
2016-06-04 03:28:33 +08:00
Update llvm-pdbdump to use subcommands. llvm-svn: 274247
2016-07-01 01:42:48 +08:00
namespace pdb2yaml {
[llvm-pdbdump] pdb2yaml: add an -all option to dump everything we can Reviewers: amccarth, rnk, zturner Reviewed By: zturner Subscribers: fhahn, llvm-commits Differential Revision: https://reviews.llvm.org/D33613 llvm-svn: 304047
2017-05-27 07:46:20 +08:00
extern llvm::cl::opt<bool> All;
[pdb] Add a pdb2yaml option to not dump file headers. This will be useful once we start adding the ability to dump type records and symbol records, since it will allow us to generate mergeable information instead of information that specifies an entire file. llvm-svn: 275109
2016-07-12 05:45:09 +08:00
extern llvm::cl::opt<bool> NoFileHeaders;
[pdb] Write the module info and symbol record streams. Previously we did not have support for writing detailed module information for each module, as well as the symbol records. This patch adds support for this, and in doing so enables the ability to construct minimal PDBs from just a few lines of YAML. A test is added to illustrate this functionality. llvm-svn: 297900
2017-03-16 06:18:53 +08:00
extern llvm::cl::opt<bool> Minimal;
Update llvm-pdbdump to use subcommands. llvm-svn: 274247
2016-07-01 01:42:48 +08:00
extern llvm::cl::opt<bool> StreamMetadata;
extern llvm::cl::opt<bool> StreamDirectory;
[pdb] Write the Named Stream mapping to Yaml and binary. Differential Revision: https://reviews.llvm.org/D28919 llvm-svn: 292665
2017-01-21 06:42:09 +08:00
extern llvm::cl::opt<bool> StringTable;
[pdb] Round trip the PDB stream between YAML and binary PDB. This gets writing of the PDB stream working. llvm-svn: 274647
2016-07-07 02:05:57 +08:00
extern llvm::cl::opt<bool> PdbStream;
Refactor the PDB writing to use a builder approach llvm-svn: 275110
2016-07-12 05:45:26 +08:00
extern llvm::cl::opt<bool> DbiStream;
Resubmit "Write the TPI stream from a PDB to Yaml." The original patch was breaking some buildbots due to an incorrect ordering of function definitions which caused some compilers to recognize a definition but others to not. llvm-svn: 279089
2016-08-19 00:49:29 +08:00
extern llvm::cl::opt<bool> TpiStream;
[pdb] Write the IPI stream. The IPI stream is structurally identical to the TPI stream, but it contains different record types. So we just re-use the TPI writing code. llvm-svn: 281638
2016-09-16 02:22:31 +08:00
extern llvm::cl::opt<bool> IpiStream;
Dump public symbol records in pdb2yaml mode llvm-svn: 345348
2018-10-26 08:17:31 +08:00
extern llvm::cl::opt<bool> PublicsStream;
Update llvm-pdbdump to use subcommands. llvm-svn: 274247
2016-07-01 01:42:48 +08:00
extern llvm::cl::list<std::string> InputFilename;
[llvm-pdbdump] Improve consistency among subcommands. The pdb2yaml and raw subcommands did something very similar but with a different output format, and they used a lot of the same command line options, but each one re-implemented the command line option with slightly different spellings / options. This patch merges them together into a single definition which is shared by both subcommands. This new syntax also allows for more flexibility in the way debug subsections are dumped. Differential Revision: https://reviews.llvm.org/D33996 llvm-svn: 305032
2017-06-09 07:39:33 +08:00
extern llvm::cl::opt<bool> DumpModules;
extern llvm::cl::opt<bool> DumpModuleFiles;
extern llvm::cl::list<ModuleSubsection> DumpModuleSubsections;
extern llvm::cl::opt<bool> DumpModuleSyms;
Resubmit "[llvm-pdbutil] rewrite the "raw" output style." This resubmits commit c0c249e9f2ef83e1d1e5f166b50673d92f3579d7. It was broken due to some weird template issues, which have since been fixed. llvm-svn: 305517
2017-06-16 06:24:24 +08:00
} // namespace pdb2yaml
Fix some differences between lld and MSVC generated PDBs. A couple of things were different about our generated PDBs. 1) We were outputting the wrong Version on the PDB Stream. The version we were setting was newer than what MSVC is setting. It's not clear what the implications are, but we change LLD to use PdbImplVC70, as MSVC does. 2) For the optional debug stream indices in the DBI Stream, we were outputting 0 to mean "the stream is not present". MSVC outputs uint16_t(-1), which is the "correct" way to specify that a stream is not present. So we fix that as well. 3) We were setting the PDB Stream signature to 0. This is supposed to be the result of calling time(nullptr). Although this leads to non-deterministic builds, a better way to solve that is by having a command line option explicitly for generating a reproducible build, and have the default behavior of lld-link match the default behavior of link. To test this, I'm making use of the new and improved `pdb diff` sub command. To make it suitable for writing tests against, I had to modify the diff subcommand slightly to print less verbose output. Previously it would always print | <column> | <value1> | <value2> | which is quite verbose, and the values are fragile. All we really want to know is "did we produce the same value as link?" So I added command line options to print a single character representing the result status (different, identical, equivalent), and another to hide the value display. Note that just inspecting the diff output used to write the test, you can see some things that are obviously wrong. That is just reflective of the fact that this is the state of affairs today, not that we're asserting that this is "correct". We can use this as a starting point to discover differences, fix them, and update the test. Differential Revision: https://reviews.llvm.org/D35086 llvm-svn: 307422
2017-07-08 02:45:56 +08:00
[PDB] Add an explain subcommand. When investigating various things, we often have a file offset and what to know what's in the PDB at that address. For example we may be doing a binary comparison of two LLD-generated PDBs to look for sources of non-determinism, or we may wish to compare an LLD-generated PDB with a Microsoft generated PDB for sources of byte-for-byte incompatibility. In these cases, we can do a binary diff of the two files, and once we find a mismatched byte we can use explain to figure out what that byte is, immediately honining in on the problem. This patch implements this by trying to narrow the meaning of a particular file offset down as much as possible. Differential Revision: https://reviews.llvm.org/D44959 llvm-svn: 328799
2018-03-30 00:28:20 +08:00
namespace explain {
[llvm-pdbutil] Add the ability to explain binary files. Using this, you can use llvm-pdbutil to export the contents of a stream to a binary file, then run explain on the binary file so that it treats the offset as an offset into the stream instead of an offset into a file. This makes it easy to compare the contents of the same stream from two different files. llvm-svn: 329207
2018-04-05 01:29:09 +08:00
enum class InputFileType { PDBFile, PDBStream, DBIStream, Names, ModuleStream };
[PDB] Add an explain subcommand. When investigating various things, we often have a file offset and what to know what's in the PDB at that address. For example we may be doing a binary comparison of two LLD-generated PDBs to look for sources of non-determinism, or we may wish to compare an LLD-generated PDB with a Microsoft generated PDB for sources of byte-for-byte incompatibility. In these cases, we can do a binary diff of the two files, and once we find a mismatched byte we can use explain to figure out what that byte is, immediately honining in on the problem. This patch implements this by trying to narrow the meaning of a particular file offset down as much as possible. Differential Revision: https://reviews.llvm.org/D44959 llvm-svn: 328799
2018-03-30 00:28:20 +08:00
extern llvm::cl::list<std::string> InputFilename;
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-31 01:16:50 +08:00
extern llvm::cl::list<uint64_t> Offsets;
[llvm-pdbutil] Add the ability to explain binary files. Using this, you can use llvm-pdbutil to export the contents of a stream to a binary file, then run explain on the binary file so that it treats the offset as an offset into the stream instead of an offset into a file. This makes it easy to compare the contents of the same stream from two different files. llvm-svn: 329207
2018-04-05 01:29:09 +08:00
extern llvm::cl::opt<InputFileType> InputType;
[PDB] Add an explain subcommand. When investigating various things, we often have a file offset and what to know what's in the PDB at that address. For example we may be doing a binary comparison of two LLD-generated PDBs to look for sources of non-determinism, or we may wish to compare an LLD-generated PDB with a Microsoft generated PDB for sources of byte-for-byte incompatibility. In these cases, we can do a binary diff of the two files, and once we find a mismatched byte we can use explain to figure out what that byte is, immediately honining in on the problem. This patch implements this by trying to narrow the meaning of a particular file offset down as much as possible. Differential Revision: https://reviews.llvm.org/D44959 llvm-svn: 328799
2018-03-30 00:28:20 +08:00
} // namespace explain
[llvm-pdbutil] Add an export subcommand. This command can dump the binary contents of a stream to a file. This is useful when you want to do side-by-side comparisons of a specific stream from two PDBs to examine the differences between them. You can export both of them to a file, then open them up side by side in a hex editor (for example), so as to eliminate any differences that might arise from the contents being on different blocks in the PDB. In subsequent patches I plan to improve the "explain" subcommand so that you can explain the contents of a binary file that isn't necessarily a full PDB, but one of these dumped streams, by telling the subcommand how to interpret the contents. llvm-svn: 329002
2018-04-03 02:35:21 +08:00
namespace exportstream {
extern llvm::cl::opt<std::string> OutputFile;
extern llvm::cl::opt<std::string> Stream;
extern llvm::cl::opt<bool> ForceName;
} // namespace exportstream
[llvm-pdbdump] Rewrite dumper using visitor pattern. This increases the flexibility of how to dump different symbol types -- necessary for context-sensitive formatting of symbol types -- and also improves the modularity by allowing the dumping to be implemented in the actual dumper, as opposed to in the PDB library. llvm-svn: 230184
2015-02-23 06:03:38 +08:00
}
pdbdump: Print "Publics" stream. Publics stream seems to contain information as to public symbols. It actually contains a serialized hash table along with fixed-sized headers. This patch is not complete. It scans only till the end of the stream and dump the header information. I'll write code to de-serialize the hash table later. Reviewers: zturner Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D20256 llvm-svn: 269484
2016-05-14 05:21:53 +08:00
#endif