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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
//===--- PCHReader.h - Precompiled Headers Reader ---------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the PCHReader class, which reads a precompiled header.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_FRONTEND_PCH_READER_H
#define LLVM_CLANG_FRONTEND_PCH_READER_H
#include "clang/AST/DeclarationName.h"
#include "clang/AST/ExternalASTSource.h"
#include "clang/AST/Type.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Bitcode/BitstreamReader.h"
#include "llvm/Support/DataTypes.h"
#include <string>
#include <utility>
#include <vector>
namespace llvm {
class MemoryBuffer;
}
namespace clang {
class ASTContext;
class Decl;
class DeclContext;
class Preprocessor;
/// \brief Reads a precompiled head containing the contents of a
/// translation unit.
///
/// The PCHReader class reads a bitstream (produced by the PCHWriter
/// class) containing the serialized representation of a given
/// abstract syntax tree and its supporting data structures. An
/// instance of the PCHReader can be attached to an ASTContext object,
/// which will provide access to the contents of the PCH file.
///
/// The PCH reader provides lazy de-serialization of declarations, as
/// required when traversing the AST. Only those AST nodes that are
/// actually required will be de-serialized.
class PCHReader : public ExternalASTSource {
/// \brief The preprocessor that will be loading the source file.
Preprocessor &PP;
/// \brief The AST context into which we'll read the PCH file.
ASTContext &Context;
/// \brief The bitstream reader from which we'll read the PCH file.
llvm::BitstreamReader Stream;
/// \brief The memory buffer that stores the data associated with
/// this PCH file.
llvm::OwningPtr<llvm::MemoryBuffer> Buffer;
/// \brief Offset of each type within the bitstream, indexed by the
/// type ID, or the representation of a Type*.
llvm::SmallVector<uint64_t, 16> TypeOffsets;
/// \brief Whether the type with a given index has already been loaded.
///
/// When the bit at a given index I is true, then TypeOffsets[I] is
/// the already-loaded Type*. Otherwise, TypeOffsets[I] is the
/// location of the type's record in the PCH file.
///
/// FIXME: We can probably eliminate this, e.g., by bitmangling the
/// values in TypeOffsets.
std::vector<bool> TypeAlreadyLoaded;
/// \brief Offset of each declaration within the bitstream, indexed
/// by the declaration ID.
llvm::SmallVector<uint64_t, 16> DeclOffsets;
/// \brief Whether the declaration with a given index has already
/// been loaded.
///
/// When the bit at the given index I is true, then DeclOffsets[I]
/// is the already-loaded Decl*. Otherwise, DeclOffsets[I] is the
/// location of the declaration's record in the PCH file.
///
/// FIXME: We can probably eliminate this, e.g., by bitmangling the
/// values in DeclOffsets.
std::vector<bool> DeclAlreadyLoaded;
typedef llvm::DenseMap<const DeclContext *, std::pair<uint64_t, uint64_t> >
DeclContextOffsetsMap;
/// \brief Offsets of the lexical and visible declarations for each
/// DeclContext.
DeclContextOffsetsMap DeclContextOffsets;
bool ReadPCHBlock();
bool ReadSourceManagerBlock();
bool ReadTypeOffsets();
bool ReadDeclOffsets();
QualType ReadTypeRecord(uint64_t Offset);
void LoadedDecl(unsigned Index, Decl *D);
Decl *ReadDeclRecord(uint64_t Offset, unsigned Index);
PCHReader(const PCHReader&); // do not implement
PCHReader &operator=(const PCHReader &); // do not implement
public:
typedef llvm::SmallVector<uint64_t, 64> RecordData;
PCHReader(Preprocessor &PP, ASTContext &Context)
: PP(PP), Context(Context), Buffer() { }
~PCHReader();
bool ReadPCH(const std::string &FileName);
/// \brief Resolve a type ID into a type, potentially building a new
/// type.
virtual QualType GetType(unsigned ID);
/// \brief Resolve a declaration ID into a declaration, potentially
/// building a new declaration.
virtual Decl *GetDecl(unsigned ID);
/// \brief Read all of the declarations lexically stored in a
/// declaration context.
///
/// \param DC The declaration context whose declarations will be
/// read.
///
/// \param Decls Vector that will contain the declarations loaded
/// from the external source. The caller is responsible for merging
/// these declarations with any declarations already stored in the
/// declaration context.
///
/// \returns true if there was an error while reading the
/// declarations for this declaration context.
virtual bool ReadDeclsLexicallyInContext(DeclContext *DC,
llvm::SmallVectorImpl<unsigned> &Decls);
/// \brief Read all of the declarations visible from a declaration
/// context.
///
/// \param DC The declaration context whose visible declarations
/// will be read.
///
/// \param Decls A vector of visible declaration structures,
/// providing the mapping from each name visible in the declaration
/// context to the declaration IDs of declarations with that name.
///
/// \returns true if there was an error while reading the
/// declarations for this declaration context.
///
/// FIXME: Using this intermediate data structure results in an
/// extraneous copying of the data. Could we pass in a reference to
/// the StoredDeclsMap instead?
virtual bool ReadDeclsVisibleInContext(DeclContext *DC,
llvm::SmallVectorImpl<VisibleDeclaration> & Decls);
/// \brief Print some statistics about PCH usage.
virtual void PrintStats();
const IdentifierInfo *GetIdentifierInfo(const RecordData &Record,
unsigned &Idx);
DeclarationName ReadDeclarationName(const RecordData &Record, unsigned &Idx);
};
} // end namespace clang
#endif
|
