RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity
fec24444bc
llvm-mirror/lib/DebugInfo/CodeView/SymbolDumper.cpp

637 lines
24 KiB
C++
Raw Normal View History

Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
//===-- SymbolDumper.cpp - CodeView symbol info dumper ----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/CodeView/SymbolDumper.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h"
[CodeView] Add more DebugSubsection implementations. This adds implementations for Symbols and FrameData, and renames the existing codeview::StringTable class to conform to the DebugSectionStringTable convention. llvm-svn: 304222
2017-05-30 19:13:33 +02:00
#include "llvm/DebugInfo/CodeView/DebugStringTableSubsection.h"
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 07:07:49 +02:00
#include "llvm/DebugInfo/CodeView/EnumTables.h"
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
#include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h"
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbackPipeline.h"
#include "llvm/DebugInfo/CodeView/SymbolVisitorCallbacks.h"
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
#include "llvm/DebugInfo/CodeView/TypeIndex.h"
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
#include "llvm/Support/Error.h"
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
#include "llvm/Support/ScopedPrinter.h"
#include <system_error>
using namespace llvm;
using namespace llvm::codeview;
namespace {
/// Use this private dumper implementation to keep implementation details about
/// the visitor out of SymbolDumper.h.
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
class CVSymbolDumperImpl : public SymbolVisitorCallbacks {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
public:
Resubmit "[CodeView] Provide a common interface for type collections." This was originally reverted because it was a breaking a bunch of bots and the breakage was not surfacing on Windows. After much head-scratching this was ultimately traced back to a bug in the lit test runner related to its pipe handling. Now that the bug in lit is fixed, Windows correctly reports these test failures, and as such I have finally (hopefully) fixed all of them in this patch. llvm-svn: 303446
2017-05-19 21:26:58 +02:00
CVSymbolDumperImpl(TypeCollection &Types, SymbolDumpDelegate *ObjDelegate,
Remove unused variable. llvm-svn: 270516
2016-05-24 02:06:04 +02:00
ScopedPrinter &W, bool PrintRecordBytes)
Resubmit "[CodeView] Provide a common interface for type collections." This was originally reverted because it was a breaking a bunch of bots and the breakage was not surfacing on Windows. After much head-scratching this was ultimately traced back to a bug in the lit test runner related to its pipe handling. Now that the bug in lit is fixed, Windows correctly reports these test failures, and as such I have finally (hopefully) fixed all of them in this patch. llvm-svn: 303446
2017-05-19 21:26:58 +02:00
: Types(Types), ObjDelegate(ObjDelegate), W(W),
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
PrintRecordBytes(PrintRecordBytes), InFunctionScope(false) {}
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
/// CVSymbolVisitor overrides.
#define SYMBOL_RECORD(EnumName, EnumVal, Name) \
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error visitKnownRecord(CVSymbol &CVR, Name &Record) override;
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
[CodeView] Move CodeView YAML code to ObjectYAML. This is the beginning of an effort to move the codeview yaml reader / writer into ObjectYAML so that it can be shared. Currently the only consumer / producer of CodeView YAML is llvm-pdbdump, but CodeView can exist outside of PDB files, and indeed is put into object files and passed to the linker to produce PDB files. Furthermore, there are subtle differences in the types of records that show up in object file CodeView vs PDB file CodeView, but they are otherwise 99% the same. By having this code in ObjectYAML, we can have llvm-pdbdump reuse this code, while teaching obj2yaml and yaml2obj to use this syntax for dealing with object files that can contain CodeView. This patch only adds support for CodeView type information to ObjectYAML. Subsequent patches will add support for CodeView symbol information. llvm-svn: 304248
2017-05-30 23:53:05 +02:00
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error visitSymbolBegin(CVSymbol &Record) override;
Error visitSymbolEnd(CVSymbol &Record) override;
Error visitUnknownSymbol(CVSymbol &Record) override;
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
private:
void printLocalVariableAddrRange(const LocalVariableAddrRange &Range,
uint32_t RelocationOffset);
void printLocalVariableAddrGap(ArrayRef<LocalVariableAddrGap> Gaps);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
void printTypeIndex(StringRef FieldName, TypeIndex TI);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
Resubmit "[CodeView] Provide a common interface for type collections." This was originally reverted because it was a breaking a bunch of bots and the breakage was not surfacing on Windows. After much head-scratching this was ultimately traced back to a bug in the lit test runner related to its pipe handling. Now that the bug in lit is fixed, Windows correctly reports these test failures, and as such I have finally (hopefully) fixed all of them in this patch. llvm-svn: 303446
2017-05-19 21:26:58 +02:00
TypeCollection &Types;
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
SymbolDumpDelegate *ObjDelegate;
ScopedPrinter &W;
bool PrintRecordBytes;
bool InFunctionScope;
};
}
[codeview] Change readobj symbol dumping format Avoid duplicating DictScope with hand-written names everywhere. Print the S_-prefixed symbol kind for every record. This should make it easier to search for certain kinds of records when debugging PDB linking. llvm-svn: 307732
2017-07-12 01:41:41 +02:00
static StringRef getSymbolKindName(SymbolKind Kind) {
switch (Kind) {
#define SYMBOL_RECORD(EnumName, EnumVal, Name) \
case EnumName: \
return #Name;
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
default:
break;
}
return "UnknownSym";
}
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
void CVSymbolDumperImpl::printLocalVariableAddrRange(
const LocalVariableAddrRange &Range, uint32_t RelocationOffset) {
DictScope S(W, "LocalVariableAddrRange");
if (ObjDelegate)
ObjDelegate->printRelocatedField("OffsetStart", RelocationOffset,
Range.OffsetStart);
W.printHex("ISectStart", Range.ISectStart);
W.printHex("Range", Range.Range);
}
void CVSymbolDumperImpl::printLocalVariableAddrGap(
ArrayRef<LocalVariableAddrGap> Gaps) {
for (auto &Gap : Gaps) {
ListScope S(W, "LocalVariableAddrGap");
W.printHex("GapStartOffset", Gap.GapStartOffset);
W.printHex("Range", Gap.Range);
}
}
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
void CVSymbolDumperImpl::printTypeIndex(StringRef FieldName, TypeIndex TI) {
Resubmit "[CodeView] Provide a common interface for type collections." This was originally reverted because it was a breaking a bunch of bots and the breakage was not surfacing on Windows. After much head-scratching this was ultimately traced back to a bug in the lit test runner related to its pipe handling. Now that the bug in lit is fixed, Windows correctly reports these test failures, and as such I have finally (hopefully) fixed all of them in this patch. llvm-svn: 303446
2017-05-19 21:26:58 +02:00
codeview::printTypeIndex(W, FieldName, TI, Types);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitSymbolBegin(CVSymbol &CVR) {
[codeview] Change readobj symbol dumping format Avoid duplicating DictScope with hand-written names everywhere. Print the S_-prefixed symbol kind for every record. This should make it easier to search for certain kinds of records when debugging PDB linking. llvm-svn: 307732
2017-07-12 01:41:41 +02:00
W.startLine() << getSymbolKindName(CVR.Type);
W.getOStream() << " {\n";
W.indent();
W.printEnum("Kind", unsigned(CVR.Type), getSymbolTypeNames());
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
}
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitSymbolEnd(CVSymbol &CVR) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (PrintRecordBytes && ObjDelegate)
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
ObjDelegate->printBinaryBlockWithRelocs("SymData", CVR.content());
[codeview] Change readobj symbol dumping format Avoid duplicating DictScope with hand-written names everywhere. Print the S_-prefixed symbol kind for every record. This should make it easier to search for certain kinds of records when debugging PDB linking. llvm-svn: 307732
2017-07-12 01:41:41 +02:00
W.unindent();
W.startLine() << "}\n";
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, BlockSym &Block) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
StringRef LinkageName;
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("PtrParent", Block.Parent);
W.printHex("PtrEnd", Block.End);
W.printHex("CodeSize", Block.CodeSize);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (ObjDelegate) {
ObjDelegate->printRelocatedField("CodeOffset", Block.getRelocationOffset(),
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Block.CodeOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Segment", Block.Segment);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("BlockName", Block.Name);
W.printString("LinkageName", LinkageName);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, Thunk32Sym &Thunk) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Parent", Thunk.Parent);
W.printNumber("End", Thunk.End);
W.printNumber("Next", Thunk.Next);
W.printNumber("Off", Thunk.Offset);
W.printNumber("Seg", Thunk.Segment);
W.printNumber("Len", Thunk.Length);
W.printEnum("Ordinal", uint8_t(Thunk.Thunk), getThunkOrdinalNames());
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
TrampolineSym &Tramp) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printEnum("Type", uint16_t(Tramp.Type), getTrampolineNames());
W.printNumber("Size", Tramp.Size);
W.printNumber("ThunkOff", Tramp.ThunkOffset);
W.printNumber("TargetOff", Tramp.TargetOffset);
W.printNumber("ThunkSection", Tramp.ThunkSection);
W.printNumber("TargetSection", Tramp.TargetSection);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, SectionSym &Section) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("SectionNumber", Section.SectionNumber);
W.printNumber("Alignment", Section.Alignment);
W.printNumber("Rva", Section.Rva);
W.printNumber("Length", Section.Length);
W.printFlags("Characteristics", Section.Characteristics,
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 07:07:49 +02:00
getImageSectionCharacteristicNames(),
COFF::SectionCharacteristics(0x00F00000));
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
W.printString("Name", Section.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
CoffGroupSym &CoffGroup) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Size", CoffGroup.Size);
W.printFlags("Characteristics", CoffGroup.Characteristics,
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 07:07:49 +02:00
getImageSectionCharacteristicNames(),
COFF::SectionCharacteristics(0x00F00000));
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Offset", CoffGroup.Offset);
W.printNumber("Segment", CoffGroup.Segment);
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
W.printString("Name", CoffGroup.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
BPRelativeSym &BPRel) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Offset", BPRel.Offset);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", BPRel.Type);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("VarName", BPRel.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
BuildInfoSym &BuildInfo) {
[CodeView] Dump BuildInfoSym and ProcSym type indices I need to print the type index in hex so that I can match it in FileCheck for a test I'm writing. llvm-svn: 308107
2017-07-15 20:10:39 +02:00
printTypeIndex("BuildId", BuildInfo.BuildId);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
CallSiteInfoSym &CallSiteInfo) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
StringRef LinkageName;
if (ObjDelegate) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
ObjDelegate->printRelocatedField("CodeOffset",
CallSiteInfo.getRelocationOffset(),
CallSiteInfo.CodeOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Segment", CallSiteInfo.Segment);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", CallSiteInfo.Type);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (!LinkageName.empty())
W.printString("LinkageName", LinkageName);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
EnvBlockSym &EnvBlock) {
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
ListScope L(W, "Entries");
for (auto Entry : EnvBlock.Fields) {
W.printString(Entry);
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
FileStaticSym &FileStatic) {
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 00:24:24 +02:00
printTypeIndex("Index", FileStatic.Index);
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("ModFilenameOffset", FileStatic.ModFilenameOffset);
W.printFlags("Flags", uint16_t(FileStatic.Flags), getLocalFlagNames());
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
W.printString("Name", FileStatic.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, ExportSym &Export) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Ordinal", Export.Ordinal);
W.printFlags("Flags", uint16_t(Export.Flags), getExportSymFlagNames());
[codeview] Add support for S_EXPORT symbol. llvm-svn: 270636
2016-05-25 02:12:40 +02:00
W.printString("Name", Export.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for S_EXPORT symbol. llvm-svn: 270636
2016-05-25 02:12:40 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
Compile2Sym &Compile2) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printEnum("Language", Compile2.getLanguage(), getSourceLanguageNames());
W.printFlags("Flags", Compile2.getFlags(), getCompileSym2FlagNames());
W.printEnum("Machine", unsigned(Compile2.Machine), getCPUTypeNames());
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
std::string FrontendVersion;
{
raw_string_ostream Out(FrontendVersion);
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Out << Compile2.VersionFrontendMajor << '.' << Compile2.VersionFrontendMinor
<< '.' << Compile2.VersionFrontendBuild;
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
std::string BackendVersion;
{
raw_string_ostream Out(BackendVersion);
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Out << Compile2.VersionBackendMajor << '.' << Compile2.VersionBackendMinor
<< '.' << Compile2.VersionBackendBuild;
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
W.printString("FrontendVersion", FrontendVersion);
W.printString("BackendVersion", BackendVersion);
W.printString("VersionName", Compile2.Version);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
Compile3Sym &Compile3) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printEnum("Language", Compile3.getLanguage(), getSourceLanguageNames());
W.printFlags("Flags", Compile3.getFlags(), getCompileSym3FlagNames());
W.printEnum("Machine", unsigned(Compile3.Machine), getCPUTypeNames());
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
std::string FrontendVersion;
{
raw_string_ostream Out(FrontendVersion);
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Out << Compile3.VersionFrontendMajor << '.' << Compile3.VersionFrontendMinor
<< '.' << Compile3.VersionFrontendBuild << '.'
<< Compile3.VersionFrontendQFE;
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
std::string BackendVersion;
{
raw_string_ostream Out(BackendVersion);
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Out << Compile3.VersionBackendMajor << '.' << Compile3.VersionBackendMinor
<< '.' << Compile3.VersionBackendBuild << '.'
<< Compile3.VersionBackendQFE;
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
W.printString("FrontendVersion", FrontendVersion);
W.printString("BackendVersion", BackendVersion);
W.printString("VersionName", Compile3.Version);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
ConstantSym &Constant) {
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", Constant.Type);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printNumber("Value", Constant.Value);
W.printString("Name", Constant.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
StringRef LinkageName;
if (ObjDelegate) {
ObjDelegate->printRelocatedField("DataOffset", Data.getRelocationOffset(),
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Data.DataOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", Data.Type);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("DisplayName", Data.Name);
if (!LinkageName.empty())
W.printString("LinkageName", LinkageName);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(
CVSymbol &CVR,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
DefRangeFramePointerRelFullScopeSym &DefRangeFramePointerRelFullScope) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Offset", DefRangeFramePointerRelFullScope.Offset);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(
CVSymbol &CVR, DefRangeFramePointerRelSym &DefRangeFramePointerRel) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Offset", DefRangeFramePointerRel.Offset);
printLocalVariableAddrRange(DefRangeFramePointerRel.Range,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
DefRangeFramePointerRel.getRelocationOffset());
printLocalVariableAddrGap(DefRangeFramePointerRel.Gaps);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(
CVSymbol &CVR, DefRangeRegisterRelSym &DefRangeRegisterRel) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("BaseRegister", DefRangeRegisterRel.Hdr.Register);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printBoolean("HasSpilledUDTMember",
DefRangeRegisterRel.hasSpilledUDTMember());
W.printNumber("OffsetInParent", DefRangeRegisterRel.offsetInParent());
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("BasePointerOffset", DefRangeRegisterRel.Hdr.BasePointerOffset);
printLocalVariableAddrRange(DefRangeRegisterRel.Range,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
DefRangeRegisterRel.getRelocationOffset());
printLocalVariableAddrGap(DefRangeRegisterRel.Gaps);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(
CVSymbol &CVR, DefRangeRegisterSym &DefRangeRegister) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Register", DefRangeRegister.Hdr.Register);
W.printNumber("MayHaveNoName", DefRangeRegister.Hdr.MayHaveNoName);
printLocalVariableAddrRange(DefRangeRegister.Range,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
DefRangeRegister.getRelocationOffset());
printLocalVariableAddrGap(DefRangeRegister.Gaps);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(
CVSymbol &CVR, DefRangeSubfieldRegisterSym &DefRangeSubfieldRegister) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Register", DefRangeSubfieldRegister.Hdr.Register);
W.printNumber("MayHaveNoName", DefRangeSubfieldRegister.Hdr.MayHaveNoName);
W.printNumber("OffsetInParent", DefRangeSubfieldRegister.Hdr.OffsetInParent);
printLocalVariableAddrRange(DefRangeSubfieldRegister.Range,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
DefRangeSubfieldRegister.getRelocationOffset());
printLocalVariableAddrGap(DefRangeSubfieldRegister.Gaps);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(
CVSymbol &CVR, DefRangeSubfieldSym &DefRangeSubfield) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (ObjDelegate) {
[CodeView] Add more DebugSubsection implementations. This adds implementations for Symbols and FrameData, and renames the existing codeview::StringTable class to conform to the DebugSectionStringTable convention. llvm-svn: 304222
2017-05-30 19:13:33 +02:00
DebugStringTableSubsectionRef Strings = ObjDelegate->getStringTable();
[llvm-readobj] Update readobj to re-use parsing code. llvm-readobj hand rolls some CodeView parsing code for string tables, so this patch updates it to re-use some of the newly introduced parsing code in LLVMDebugInfoCodeView. Differential Revision: https://reviews.llvm.org/D32772 llvm-svn: 302052
2017-05-03 19:11:11 +02:00
auto ExpectedProgram = Strings.getString(DefRangeSubfield.Program);
if (!ExpectedProgram) {
consumeError(ExpectedProgram.takeError());
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return llvm::make_error<CodeViewError>(
"String table offset outside of bounds of String Table!");
[llvm-readobj] Update readobj to re-use parsing code. llvm-readobj hand rolls some CodeView parsing code for string tables, so this patch updates it to re-use some of the newly introduced parsing code in LLVMDebugInfoCodeView. Differential Revision: https://reviews.llvm.org/D32772 llvm-svn: 302052
2017-05-03 19:11:11 +02:00
}
W.printString("Program", *ExpectedProgram);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("OffsetInParent", DefRangeSubfield.OffsetInParent);
printLocalVariableAddrRange(DefRangeSubfield.Range,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
DefRangeSubfield.getRelocationOffset());
printLocalVariableAddrGap(DefRangeSubfield.Gaps);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
DefRangeSym &DefRange) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (ObjDelegate) {
[CodeView] Add more DebugSubsection implementations. This adds implementations for Symbols and FrameData, and renames the existing codeview::StringTable class to conform to the DebugSectionStringTable convention. llvm-svn: 304222
2017-05-30 19:13:33 +02:00
DebugStringTableSubsectionRef Strings = ObjDelegate->getStringTable();
[llvm-readobj] Update readobj to re-use parsing code. llvm-readobj hand rolls some CodeView parsing code for string tables, so this patch updates it to re-use some of the newly introduced parsing code in LLVMDebugInfoCodeView. Differential Revision: https://reviews.llvm.org/D32772 llvm-svn: 302052
2017-05-03 19:11:11 +02:00
auto ExpectedProgram = Strings.getString(DefRange.Program);
if (!ExpectedProgram) {
consumeError(ExpectedProgram.takeError());
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return llvm::make_error<CodeViewError>(
"String table offset outside of bounds of String Table!");
[llvm-readobj] Update readobj to re-use parsing code. llvm-readobj hand rolls some CodeView parsing code for string tables, so this patch updates it to re-use some of the newly introduced parsing code in LLVMDebugInfoCodeView. Differential Revision: https://reviews.llvm.org/D32772 llvm-svn: 302052
2017-05-03 19:11:11 +02:00
}
W.printString("Program", *ExpectedProgram);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
printLocalVariableAddrRange(DefRange.Range, DefRange.getRelocationOffset());
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
printLocalVariableAddrGap(DefRange.Gaps);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
FrameCookieSym &FrameCookie) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
StringRef LinkageName;
if (ObjDelegate) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
ObjDelegate->printRelocatedField("CodeOffset",
FrameCookie.getRelocationOffset(),
FrameCookie.CodeOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Register", FrameCookie.Register);
W.printEnum("CookieKind", uint16_t(FrameCookie.CookieKind),
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 07:07:49 +02:00
getFrameCookieKindNames());
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Flags", FrameCookie.Flags);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
FrameProcSym &FrameProc) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("TotalFrameBytes", FrameProc.TotalFrameBytes);
W.printHex("PaddingFrameBytes", FrameProc.PaddingFrameBytes);
W.printHex("OffsetToPadding", FrameProc.OffsetToPadding);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printHex("BytesOfCalleeSavedRegisters",
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
FrameProc.BytesOfCalleeSavedRegisters);
W.printHex("OffsetOfExceptionHandler", FrameProc.OffsetOfExceptionHandler);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printHex("SectionIdOfExceptionHandler",
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
FrameProc.SectionIdOfExceptionHandler);
W.printFlags("Flags", static_cast<uint32_t>(FrameProc.Flags),
getFrameProcSymFlagNames());
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(
CVSymbol &CVR, HeapAllocationSiteSym &HeapAllocSite) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
StringRef LinkageName;
if (ObjDelegate) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
ObjDelegate->printRelocatedField("CodeOffset",
HeapAllocSite.getRelocationOffset(),
HeapAllocSite.CodeOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Segment", HeapAllocSite.Segment);
W.printHex("CallInstructionSize", HeapAllocSite.CallInstructionSize);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", HeapAllocSite.Type);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (!LinkageName.empty())
W.printString("LinkageName", LinkageName);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
InlineSiteSym &InlineSite) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("PtrParent", InlineSite.Parent);
W.printHex("PtrEnd", InlineSite.End);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Inlinee", InlineSite.Inlinee);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
ListScope BinaryAnnotations(W, "BinaryAnnotations");
for (auto &Annotation : InlineSite.annotations()) {
switch (Annotation.OpCode) {
case BinaryAnnotationsOpCode::Invalid:
[PDB] It is not an error getting the "Invalid" Annotation opcode. The linker can insert invalid opcodes to indicate padding bytes, and we should not fail in this case. llvm-svn: 298016
2017-03-17 01:15:27 +01:00
W.printString("(Annotation Padding)");
break;
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
case BinaryAnnotationsOpCode::CodeOffset:
case BinaryAnnotationsOpCode::ChangeCodeOffset:
case BinaryAnnotationsOpCode::ChangeCodeLength:
W.printHex(Annotation.Name, Annotation.U1);
break;
case BinaryAnnotationsOpCode::ChangeCodeOffsetBase:
case BinaryAnnotationsOpCode::ChangeLineEndDelta:
case BinaryAnnotationsOpCode::ChangeRangeKind:
case BinaryAnnotationsOpCode::ChangeColumnStart:
case BinaryAnnotationsOpCode::ChangeColumnEnd:
W.printNumber(Annotation.Name, Annotation.U1);
break;
case BinaryAnnotationsOpCode::ChangeLineOffset:
case BinaryAnnotationsOpCode::ChangeColumnEndDelta:
W.printNumber(Annotation.Name, Annotation.S1);
break;
case BinaryAnnotationsOpCode::ChangeFile:
if (ObjDelegate) {
W.printHex("ChangeFile",
ObjDelegate->getFileNameForFileOffset(Annotation.U1),
Annotation.U1);
} else {
W.printHex("ChangeFile", Annotation.U1);
}
break;
case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset: {
W.startLine() << "ChangeCodeOffsetAndLineOffset: {CodeOffset: "
<< W.hex(Annotation.U1) << ", LineOffset: " << Annotation.S1
<< "}\n";
break;
}
case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset: {
W.startLine() << "ChangeCodeLengthAndCodeOffset: {CodeOffset: "
<< W.hex(Annotation.U2)
<< ", Length: " << W.hex(Annotation.U1) << "}\n";
break;
}
}
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
RegisterSym &Register) {
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 00:24:24 +02:00
printTypeIndex("Type", Register.Index);
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printEnum("Seg", uint16_t(Register.Register), getRegisterNames());
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
W.printString("Name", Register.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628
2016-05-25 00:58:46 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, PublicSym32 &Public) {
[CodeView] Fix dumping of public symbol record flags I noticed nonsensical type information while dumping PDBs produced by MSVC. llvm-svn: 305708
2017-06-19 18:54:51 +02:00
W.printFlags("Flags", uint32_t(Public.Flags), getPublicSymFlagNames());
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("Seg", Public.Segment);
W.printNumber("Off", Public.Offset);
[codeview, pdb] Dump symbol records in publics stream Differential Revision: http://reviews.llvm.org/D20580 Reviewed By: ruiu llvm-svn: 270597
2016-05-24 20:55:14 +02:00
W.printString("Name", Public.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview, pdb] Dump symbol records in publics stream Differential Revision: http://reviews.llvm.org/D20580 Reviewed By: ruiu llvm-svn: 270597
2016-05-24 20:55:14 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, ProcRefSym &ProcRef) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printNumber("SumName", ProcRef.SumName);
W.printNumber("SymOffset", ProcRef.SymOffset);
W.printNumber("Mod", ProcRef.Module);
[codeview, pdb] Dump symbol records in publics stream Differential Revision: http://reviews.llvm.org/D20580 Reviewed By: ruiu llvm-svn: 270597
2016-05-24 20:55:14 +02:00
W.printString("Name", ProcRef.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
[codeview, pdb] Dump symbol records in publics stream Differential Revision: http://reviews.llvm.org/D20580 Reviewed By: ruiu llvm-svn: 270597
2016-05-24 20:55:14 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, LabelSym &Label) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
StringRef LinkageName;
if (ObjDelegate) {
ObjDelegate->printRelocatedField("CodeOffset", Label.getRelocationOffset(),
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Label.CodeOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Segment", Label.Segment);
W.printHex("Flags", uint8_t(Label.Flags));
W.printFlags("Flags", uint8_t(Label.Flags), getProcSymFlagNames());
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("DisplayName", Label.Name);
if (!LinkageName.empty())
W.printString("LinkageName", LinkageName);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, LocalSym &Local) {
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", Local.Type);
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printFlags("Flags", uint16_t(Local.Flags), getLocalFlagNames());
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("VarName", Local.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, ObjNameSym &ObjName) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Signature", ObjName.Signature);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("ObjectName", ObjName.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, ProcSym &Proc) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (InFunctionScope)
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return llvm::make_error<CodeViewError>(
"Visiting a ProcSym while inside function scope!");
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
InFunctionScope = true;
StringRef LinkageName;
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("PtrParent", Proc.Parent);
W.printHex("PtrEnd", Proc.End);
W.printHex("PtrNext", Proc.Next);
W.printHex("CodeSize", Proc.CodeSize);
W.printHex("DbgStart", Proc.DbgStart);
W.printHex("DbgEnd", Proc.DbgEnd);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("FunctionType", Proc.FunctionType);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
if (ObjDelegate) {
ObjDelegate->printRelocatedField("CodeOffset", Proc.getRelocationOffset(),
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Proc.CodeOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Segment", Proc.Segment);
W.printFlags("Flags", static_cast<uint8_t>(Proc.Flags),
[pdb] Parse and dump section map and section contribs Differential Revision: http://reviews.llvm.org/D20876 Reviewed By: rnk, ruiu llvm-svn: 271488
2016-06-02 07:07:49 +02:00
getProcSymFlagNames());
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("DisplayName", Proc.Name);
if (!LinkageName.empty())
W.printString("LinkageName", LinkageName);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
ScopeEndSym &ScopeEnd) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
InFunctionScope = false;
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, CallerSym &Caller) {
ListScope S(W, CVR.kind() == S_CALLEES ? "Callees" : "Callers");
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
for (auto FuncID : Caller.Indices)
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("FuncID", FuncID);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
RegRelativeSym &RegRel) {
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
W.printHex("Offset", RegRel.Offset);
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", RegRel.Type);
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 00:24:24 +02:00
W.printEnum("Register", uint16_t(RegRel.Register), getRegisterNames());
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("VarName", RegRel.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
ThreadLocalDataSym &Data) {
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
StringRef LinkageName;
if (ObjDelegate) {
ObjDelegate->printRelocatedField("DataOffset", Data.getRelocationOffset(),
Resubmit "[CodeView] Hook CodeViewRecordIO for reading/writing symbols." The original patch was broken due to some undefined behavior as well as warnings that were triggering -Werror. llvm-svn: 290000
2016-12-16 23:48:14 +01:00
Data.DataOffset, &LinkageName);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", Data.Type);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("DisplayName", Data.Name);
if (!LinkageName.empty())
W.printString("LinkageName", LinkageName);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, UDTSym &UDT) {
[CodeView] Finish decoupling TypeDatabase from TypeDumper. Previously the type dumper itself was passed around to a lot of different places and manipulated in ways that were more appropriate on the type database. For example, the entire TypeDumper was passed into the symbol dumper, when all the symbol dumper wanted to do was lookup the name of a TypeIndex so it could print it. That's what the TypeDatabase is for -- mapping type indices to names. Another example is how if the user runs llvm-pdbdump with the option to dump symbols but not types, we still have to visit all types so that we can print minimal information about the type of a symbol, but just without dumping full symbol records. The way we did this before is by hacking it up so that we run everything through the type dumper with a null printer, so that the output goes to /dev/null. But really, we don't need to dump anything, all we want to do is build the type database. Since TypeDatabaseVisitor now exists independently of TypeDumper, we can do this. We just build a custom visitor callback pipeline that includes a database visitor but not a dumper. All the hackery around printers etc goes away. After this patch, we could probably even delete the entire CVTypeDumper class since really all it is at this point is a thin wrapper that hides the details of how to build a useful visitation pipeline. It's not a priority though, so CVTypeDumper remains for now. After this patch we will be able to easily plug in a different style of type dumper by only implementing the proper visitation methods to dump one-line output and then sticking it on the pipeline. Differential Revision: https://reviews.llvm.org/D28524 llvm-svn: 291724
2017-01-12 00:24:22 +01:00
printTypeIndex("Type", UDT.Type);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
W.printString("UDTName", UDT.Name);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumperImpl::visitUnknownSymbol(CVSymbol &CVR) {
W.printNumber("Length", CVR.length());
return Error::success();
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumper::dump(CVRecord<SymbolKind> &Record) {
SymbolVisitorCallbackPipeline Pipeline;
[CodeView] Properly align symbol records on read/write. Object files have symbol records not aligned to any particular boundary (e.g. 1-byte aligned), while PDB files have symbol records padded to 4-byte aligned boundaries. Since they share the same reading / writing code, we have to provide an option to specify the alignment and propagate it up to the producer or consumer who knows what the alignment is supposed to be for the given container type. Added a test for this by modifying the existing PDB -> YAML -> PDB round-tripping code to round trip symbol records as well as types. Differential Revision: https://reviews.llvm.org/D33785 llvm-svn: 304484
2017-06-01 23:52:41 +02:00
SymbolDeserializer Deserializer(ObjDelegate.get(), Container);
Resubmit "[CodeView] Provide a common interface for type collections." This was originally reverted because it was a breaking a bunch of bots and the breakage was not surfacing on Windows. After much head-scratching this was ultimately traced back to a bug in the lit test runner related to its pipe handling. Now that the bug in lit is fixed, Windows correctly reports these test failures, and as such I have finally (hopefully) fixed all of them in this patch. llvm-svn: 303446
2017-05-19 21:26:58 +02:00
CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, PrintRecordBytes);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Pipeline.addCallbackToPipeline(Deserializer);
Pipeline.addCallbackToPipeline(Dumper);
CVSymbolVisitor Visitor(Pipeline);
return Visitor.visitSymbolRecord(Record);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Error CVSymbolDumper::dump(const CVSymbolArray &Symbols) {
SymbolVisitorCallbackPipeline Pipeline;
[CodeView] Properly align symbol records on read/write. Object files have symbol records not aligned to any particular boundary (e.g. 1-byte aligned), while PDB files have symbol records padded to 4-byte aligned boundaries. Since they share the same reading / writing code, we have to provide an option to specify the alignment and propagate it up to the producer or consumer who knows what the alignment is supposed to be for the given container type. Added a test for this by modifying the existing PDB -> YAML -> PDB round-tripping code to round trip symbol records as well as types. Differential Revision: https://reviews.llvm.org/D33785 llvm-svn: 304484
2017-06-01 23:52:41 +02:00
SymbolDeserializer Deserializer(ObjDelegate.get(), Container);
Resubmit "[CodeView] Provide a common interface for type collections." This was originally reverted because it was a breaking a bunch of bots and the breakage was not surfacing on Windows. After much head-scratching this was ultimately traced back to a bug in the lit test runner related to its pipe handling. Now that the bug in lit is fixed, Windows correctly reports these test failures, and as such I have finally (hopefully) fixed all of them in this patch. llvm-svn: 303446
2017-05-19 21:26:58 +02:00
CVSymbolDumperImpl Dumper(Types, ObjDelegate.get(), W, PrintRecordBytes);
Refactor Symbol visitor code. Type visitor code had already been refactored previously to decouple the visitor and the visitor callback interface. This was necessary for having the flexibility to visit in different ways (for example, dumping to yaml, reading from yaml, dumping to ScopedPrinter, etc). This patch merely implements the same visitation pattern for symbol records that has already been implemented for type records. llvm-svn: 283609
2016-10-07 23:34:46 +02:00
Pipeline.addCallbackToPipeline(Deserializer);
Pipeline.addCallbackToPipeline(Dumper);
CVSymbolVisitor Visitor(Pipeline);
return Visitor.visitSymbolStream(Symbols);
Make a symbol visitor and use it to dump CV symbols. Differential Revision: http://reviews.llvm.org/D20534 Reviewed By: rnk llvm-svn: 270511
2016-05-24 01:41:13 +02:00
}
Reference in New Issue Copy Permalink