RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity
old12
llvm-mirror/tools/llvm-pdbutil/StreamUtil.cpp

195 lines
7.8 KiB
C++
Raw Permalink Normal View History

Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
//===- StreamUtil.cpp - PDB stream utilities --------------------*- C++ -*-===//
//
Update the file headers across all of the LLVM projects in the monorepo to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. llvm-svn: 351636
2019-01-19 09:50:56 +01:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
//
//===----------------------------------------------------------------------===//
#include "StreamUtil.h"
[llvm-pdbutil] Add the ability to truncate stream purpose names. This will be useful for aligning fields to a fixed with in subsequent patches. llvm-svn: 307204
2017-07-05 23:54:58 +02:00
#include "FormatUtil.h"
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseMapInfo.h"
Rename some PDB classes. We have a lot of very similarly named classes related to dealing with module debug info. This patch has NFC, it just renames some classes to be more descriptive (albeit slightly more to type). The mapping from old to new class names is as follows: Old | New ModInfo | DbiModuleDescriptor ModuleSubstream | ModuleDebugFragment ModStream | ModuleDebugStream With the corresponding Builder classes renamed accordingly. Differential Revision: https://reviews.llvm.org/D32506 llvm-svn: 301555
2017-04-27 18:11:19 +02:00
#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
[PDB] Don't build the entire source file list up front. I tried to run llvm-pdbdump on a very large (~1.5GB) PDB to try and identify show-stopping performance problems. This patch addresses the first such problem. When loading the DBI stream, before anyone has even tried to access a single record, we build an in memory map of every source file for every module. In the particular PDB I was using, this was over 85 million files. Specifically, the complexity is O(m*n) where m is the number of modules and n is the average number of source files (including headers) per module. The whole reason for doing this was so that we could have constant time access to any module and any of its source file lists. However, we can still get O(1) access to the source file list for a given module with a simple O(m) precomputation, and access to the list of modules is already O(1) anyway. So this patches reduces the O(m*n) up-front precomputation to an O(m) one, where n is ~6,500 and n*m is about 85 million in my pathological test case. Differential Revision: https://reviews.llvm.org/D32870 llvm-svn: 302205
2017-05-05 01:53:29 +02:00
#include "llvm/DebugInfo/PDB/Native/DbiModuleList.h"
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
[llvm-pdbutil] Add the ability to truncate stream purpose names. This will be useful for aligning fields to a fixed with in subsequent patches. llvm-svn: 307204
2017-07-05 23:54:58 +02:00
using namespace llvm;
using namespace llvm::pdb;
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
std::string StreamInfo::getLongName() const {
if (Purpose == StreamPurpose::NamedStream)
return formatv("Named Stream \"{0}\"", Name).str();
if (Purpose == StreamPurpose::ModuleStream)
return formatv("Module \"{0}\"", Name).str();
return Name;
}
StreamInfo StreamInfo::createStream(StreamPurpose Purpose, StringRef Name,
uint32_t StreamIndex) {
StreamInfo Result;
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-28 20:23:46 +01:00
Result.Name = std::string(Name);
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
Result.StreamIndex = StreamIndex;
Result.Purpose = Purpose;
return Result;
}
StreamInfo StreamInfo::createModuleStream(StringRef Module,
uint32_t StreamIndex, uint32_t Modi) {
StreamInfo Result;
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-28 20:23:46 +01:00
Result.Name = std::string(Module);
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
Result.StreamIndex = StreamIndex;
Result.ModuleIndex = Modi;
Result.Purpose = StreamPurpose::ModuleStream;
return Result;
}
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
static inline StreamInfo stream(StreamPurpose Purpose, StringRef Label,
uint32_t Idx) {
return StreamInfo::createStream(Purpose, Label, Idx);
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
}
static inline StreamInfo moduleStream(StringRef Label, uint32_t StreamIdx,
uint32_t Modi) {
return StreamInfo::createModuleStream(Label, StreamIdx, Modi);
}
struct IndexedModuleDescriptor {
uint32_t Modi;
DbiModuleDescriptor Descriptor;
};
void llvm::pdb::discoverStreamPurposes(PDBFile &File,
SmallVectorImpl<StreamInfo> &Streams) {
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
// It's OK if we fail to load some of these streams, we still attempt to print
// what we can.
auto Dbi = File.getPDBDbiStream();
auto Tpi = File.getPDBTpiStream();
auto Ipi = File.getPDBIpiStream();
auto Info = File.getPDBInfoStream();
uint32_t StreamCount = File.getNumStreams();
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
DenseMap<uint16_t, IndexedModuleDescriptor> ModStreams;
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
DenseMap<uint16_t, std::string> NamedStreams;
if (Dbi) {
[PDB] Don't build the entire source file list up front. I tried to run llvm-pdbdump on a very large (~1.5GB) PDB to try and identify show-stopping performance problems. This patch addresses the first such problem. When loading the DBI stream, before anyone has even tried to access a single record, we build an in memory map of every source file for every module. In the particular PDB I was using, this was over 85 million files. Specifically, the complexity is O(m*n) where m is the number of modules and n is the average number of source files (including headers) per module. The whole reason for doing this was so that we could have constant time access to any module and any of its source file lists. However, we can still get O(1) access to the source file list for a given module with a simple O(m) precomputation, and access to the list of modules is already O(1) anyway. So this patches reduces the O(m*n) up-front precomputation to an O(m) one, where n is ~6,500 and n*m is about 85 million in my pathological test case. Differential Revision: https://reviews.llvm.org/D32870 llvm-svn: 302205
2017-05-05 01:53:29 +02:00
const DbiModuleList &Modules = Dbi->modules();
for (uint32_t I = 0; I < Modules.getModuleCount(); ++I) {
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
IndexedModuleDescriptor IMD;
IMD.Modi = I;
IMD.Descriptor = Modules.getModuleDescriptor(I);
uint16_t SN = IMD.Descriptor.getModuleStreamIndex();
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
if (SN != kInvalidStreamIndex)
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
ModStreams[SN] = IMD;
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
}
}
if (Info) {
for (auto &NSE : Info->named_streams()) {
if (NSE.second != kInvalidStreamIndex)
Make llvm::StringRef to std::string conversions explicit. This is how it should've been and brings it more in line with std::string_view. There should be no functional change here. This is mostly mechanical from a custom clang-tidy check, with a lot of manual fixups. It uncovers a lot of minor inefficiencies. This doesn't actually modify StringRef yet, I'll do that in a follow-up.
2020-01-28 20:23:46 +01:00
NamedStreams[NSE.second] = std::string(NSE.first());
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
}
}
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
Streams.resize(StreamCount);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
for (uint16_t StreamIdx = 0; StreamIdx < StreamCount; ++StreamIdx) {
if (StreamIdx == OldMSFDirectory)
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "Old MSF Directory", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (StreamIdx == StreamPDB)
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::PDB, "PDB Stream", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (StreamIdx == StreamDBI)
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::DBI, "DBI Stream", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (StreamIdx == StreamTPI)
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::TPI, "TPI Stream", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (StreamIdx == StreamIPI)
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::IPI, "IPI Stream", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi && StreamIdx == Dbi->getGlobalSymbolStreamIndex())
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::GlobalHash, "Global Symbol Hash", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi && StreamIdx == Dbi->getPublicSymbolStreamIndex())
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::PublicHash, "Public Symbol Hash", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi && StreamIdx == Dbi->getSymRecordStreamIndex())
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Symbols, "Symbol Records", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Tpi && StreamIdx == Tpi->getTypeHashStreamIndex())
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::TpiHash, "TPI Hash", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Tpi && StreamIdx == Tpi->getTypeHashStreamAuxIndex())
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "TPI Aux Hash", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Ipi && StreamIdx == Ipi->getTypeHashStreamIndex())
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::IpiHash, "IPI Hash", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Ipi && StreamIdx == Ipi->getTypeHashStreamAuxIndex())
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "IPI Aux Hash", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi &&
StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Exception))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "Exception Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Fixup))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "Fixup Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::FPO))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::Other, "FPO Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi &&
StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::NewFPO))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "New FPO Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi &&
StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::OmapFromSrc))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "Omap From Source Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi &&
StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::OmapToSrc))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "Omap To Source Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Pdata))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::Other, "Pdata", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi &&
StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::SectionHdr))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "Section Header Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi &&
StreamIdx ==
Dbi->getDebugStreamIndex(DbgHeaderType::SectionHdrOrig))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::Other,
"Section Header Original Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi &&
StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::TokenRidMap))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::Other, "Token Rid Data", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else if (Dbi && StreamIdx == Dbi->getDebugStreamIndex(DbgHeaderType::Xdata))
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::Other, "Xdata", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
else {
auto ModIter = ModStreams.find(StreamIdx);
auto NSIter = NamedStreams.find(StreamIdx);
if (ModIter != ModStreams.end()) {
[llvm-pdbutil] Add support for dumping detailed module stats. This adds support for dumping a summary of module symbols and CodeView debug chunks. This option prints a table for each module of all of the symbols that occurred in the module and the number of times it occurred and total byte size. Then at the end it prints the totals for the entire file. Additionally, this patch adds the -jmc (just my code) option, which suppresses modules which are from external libraries or linker imports, so that you can focus only on the object files and libraries that originate from your own source code. llvm-svn: 311338
2017-08-21 16:53:25 +02:00
Streams[StreamIdx] =
moduleStream(ModIter->second.Descriptor.getModuleName(), StreamIdx,
ModIter->second.Modi);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
} else if (NSIter != NamedStreams.end()) {
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] =
stream(StreamPurpose::NamedStream, NSIter->second, StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
} else {
[llvm-pdbutil] Dig deeper into the PDB and DBI streams when explaining. This will show more detail when using `llvm-pdbutil explain` on an offset in the DBI or PDB streams. Specifically, it will dig into individual header fields and substreams to give a more precise description of what the byte represents. llvm-svn: 328878
2018-03-30 19:16:50 +02:00
Streams[StreamIdx] = stream(StreamPurpose::Other, "???", StreamIdx);
Add the beginning of PDB diffing support. For now this only diffs the stream directory and the MSF Superblock. Future patches will drill down into individual streams to find out where the differences lie. Differential Revision: https://reviews.llvm.org/D30908 llvm-svn: 297689
2017-03-14 00:28:25 +01:00
}
}
}
// Consume errors from missing streams.
if (!Dbi)
consumeError(Dbi.takeError());
if (!Tpi)
consumeError(Tpi.takeError());
if (!Ipi)
consumeError(Ipi.takeError());
if (!Info)
consumeError(Info.takeError());
}
Reference in New Issue Copy Permalink