InputFile.h
4.31 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
//===- InputFile.h -------------------------------------------- *- C++ --*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVMPDBDUMP_INPUTFILE_H
#define LLVM_TOOLS_LLVMPDBDUMP_INPUTFILE_H
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/PointerUnion.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/iterator.h"
#include "llvm/DebugInfo/CodeView/DebugChecksumsSubsection.h"
#include "llvm/DebugInfo/CodeView/StringsAndChecksums.h"
#include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
#include "llvm/Object/Binary.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Support/Error.h"
namespace llvm {
namespace codeview {
class LazyRandomTypeCollection;
}
namespace object {
class COFFObjectFile;
class SectionRef;
} // namespace object
namespace pdb {
class InputFile;
class LinePrinter;
class PDBFile;
class NativeSession;
class SymbolGroupIterator;
class SymbolGroup;
class InputFile {
InputFile();
std::unique_ptr<NativeSession> PdbSession;
object::OwningBinary<object::Binary> CoffObject;
std::unique_ptr<MemoryBuffer> UnknownFile;
PointerUnion<PDBFile *, object::COFFObjectFile *, MemoryBuffer *> PdbOrObj;
using TypeCollectionPtr = std::unique_ptr<codeview::LazyRandomTypeCollection>;
TypeCollectionPtr Types;
TypeCollectionPtr Ids;
enum TypeCollectionKind { kTypes, kIds };
codeview::LazyRandomTypeCollection &
getOrCreateTypeCollection(TypeCollectionKind Kind);
public:
~InputFile();
InputFile(InputFile &&Other) = default;
static Expected<InputFile> open(StringRef Path,
bool AllowUnknownFile = false);
PDBFile &pdb();
const PDBFile &pdb() const;
object::COFFObjectFile &obj();
const object::COFFObjectFile &obj() const;
MemoryBuffer &unknown();
const MemoryBuffer &unknown() const;
StringRef getFilePath() const;
bool hasTypes() const;
bool hasIds() const;
codeview::LazyRandomTypeCollection &types();
codeview::LazyRandomTypeCollection &ids();
iterator_range<SymbolGroupIterator> symbol_groups();
SymbolGroupIterator symbol_groups_begin();
SymbolGroupIterator symbol_groups_end();
bool isPdb() const;
bool isObj() const;
bool isUnknown() const;
};
class SymbolGroup {
friend class SymbolGroupIterator;
public:
explicit SymbolGroup(InputFile *File, uint32_t GroupIndex = 0);
Expected<StringRef> getNameFromStringTable(uint32_t Offset) const;
void formatFromFileName(LinePrinter &Printer, StringRef File,
bool Append = false) const;
void formatFromChecksumsOffset(LinePrinter &Printer, uint32_t Offset,
bool Append = false) const;
StringRef name() const;
codeview::DebugSubsectionArray getDebugSubsections() const {
return Subsections;
}
const ModuleDebugStreamRef &getPdbModuleStream() const;
const InputFile &getFile() const { return *File; }
InputFile &getFile() { return *File; }
bool hasDebugStream() const { return DebugStream != nullptr; }
private:
void initializeForPdb(uint32_t Modi);
void updatePdbModi(uint32_t Modi);
void updateDebugS(const codeview::DebugSubsectionArray &SS);
void rebuildChecksumMap();
InputFile *File = nullptr;
StringRef Name;
codeview::DebugSubsectionArray Subsections;
std::shared_ptr<ModuleDebugStreamRef> DebugStream;
codeview::StringsAndChecksumsRef SC;
StringMap<codeview::FileChecksumEntry> ChecksumsByFile;
};
class SymbolGroupIterator
: public iterator_facade_base<SymbolGroupIterator,
std::forward_iterator_tag, SymbolGroup> {
public:
SymbolGroupIterator();
explicit SymbolGroupIterator(InputFile &File);
SymbolGroupIterator(const SymbolGroupIterator &Other) = default;
SymbolGroupIterator &operator=(const SymbolGroupIterator &R) = default;
const SymbolGroup &operator*() const;
SymbolGroup &operator*();
bool operator==(const SymbolGroupIterator &R) const;
SymbolGroupIterator &operator++();
private:
void scanToNextDebugS();
bool isEnd() const;
uint32_t Index = 0;
Optional<object::section_iterator> SectionIter;
SymbolGroup Value;
};
} // namespace pdb
} // namespace llvm
#endif