clang  15.0.0git
ASTRecordReader.h
Go to the documentation of this file.
1 //===- ASTRecordReader.h - Helper classes for reading AST -------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines classes that are useful in the implementation of
10 // the ASTReader.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_SERIALIZATION_ASTRECORDREADER_H
15 #define LLVM_CLANG_SERIALIZATION_ASTRECORDREADER_H
16 
17 #include "clang/AST/ASTContext.h"
19 #include "clang/Lex/Token.h"
22 #include "llvm/ADT/APFloat.h"
23 #include "llvm/ADT/APInt.h"
24 #include "llvm/ADT/APSInt.h"
25 
26 namespace clang {
27 class OMPTraitInfo;
28 class OMPChildren;
29 
30 /// An object for streaming information from a record.
32  : public serialization::DataStreamBasicReader<ASTRecordReader> {
35 
36  ASTReader *Reader;
37  ModuleFile *F;
38  unsigned Idx = 0;
39  ASTReader::RecordData Record;
40 
43 
44 public:
45  /// Construct an ASTRecordReader that uses the default encoding scheme.
47  : DataStreamBasicReader(Reader.getContext()), Reader(&Reader), F(&F) {}
48 
49  /// Reads a record with id AbbrevID from Cursor, resetting the
50  /// internal state.
51  Expected<unsigned> readRecord(llvm::BitstreamCursor &Cursor,
52  unsigned AbbrevID);
53 
54  /// Is this a module file for a module (rather than a PCH or similar).
55  bool isModule() const { return F->isModule(); }
56 
57  /// Retrieve the AST context that this AST reader supplements.
58  ASTContext &getContext() { return Reader->getContext(); }
59 
60  /// The current position in this record.
61  unsigned getIdx() const { return Idx; }
62 
63  /// The length of this record.
64  size_t size() const { return Record.size(); }
65 
66  /// An arbitrary index in this record.
67  const uint64_t &operator[](size_t N) { return Record[N]; }
68 
69  /// Returns the last value in this record.
70  uint64_t back() { return Record.back(); }
71 
72  /// Returns the current value in this record, and advances to the
73  /// next value.
74  uint64_t readInt() { return Record[Idx++]; }
75 
77  auto Array = llvm::makeArrayRef(Record).slice(Idx, Len);
78  Idx += Len;
79  return Array;
80  }
81 
82  /// Returns the current value in this record, without advancing.
83  uint64_t peekInt() { return Record[Idx]; }
84 
85  /// Skips the specified number of values.
86  void skipInts(unsigned N) { Idx += N; }
87 
88  /// Retrieve the global submodule ID its local ID number.
90  getGlobalSubmoduleID(unsigned LocalID) {
91  return Reader->getGlobalSubmoduleID(*F, LocalID);
92  }
93 
94  /// Retrieve the submodule that corresponds to a global submodule ID.
96  return Reader->getSubmodule(GlobalID);
97  }
98 
99  /// Read the record that describes the lexical contents of a DC.
101  return Reader->ReadLexicalDeclContextStorage(*F, F->DeclsCursor, Offset,
102  DC);
103  }
104 
105  /// Read the record that describes the visible contents of a DC.
108  return Reader->ReadVisibleDeclContextStorage(*F, F->DeclsCursor, Offset,
109  ID);
110  }
111 
113  uint64_t Kind = readInt();
114  bool HasExpr = Kind & 0x1;
115  Kind = Kind >> 1;
116  return ExplicitSpecifier(HasExpr ? readExpr() : nullptr,
117  static_cast<ExplicitSpecKind>(Kind));
118  }
119 
120  /// Read information about an exception specification (inherited).
121  //FunctionProtoType::ExceptionSpecInfo
122  //readExceptionSpecInfo(SmallVectorImpl<QualType> &ExceptionStorage);
123 
124  /// Get the global offset corresponding to a local offset.
126  return Reader->getGlobalBitOffset(*F, LocalOffset);
127  }
128 
129  /// Reads a statement.
130  Stmt *readStmt() { return Reader->ReadStmt(*F); }
131  Stmt *readStmtRef() { return readStmt(); /* FIXME: readSubStmt? */ }
132 
133  /// Reads an expression.
134  Expr *readExpr() { return Reader->ReadExpr(*F); }
135 
136  /// Reads a sub-statement operand during statement reading.
137  Stmt *readSubStmt() { return Reader->ReadSubStmt(); }
138 
139  /// Reads a sub-expression operand during statement reading.
140  Expr *readSubExpr() { return Reader->ReadSubExpr(); }
141 
142  /// Reads a declaration with the given local ID in the given module.
143  ///
144  /// \returns The requested declaration, casted to the given return type.
145  template<typename T>
146  T *GetLocalDeclAs(uint32_t LocalID) {
147  return cast_or_null<T>(Reader->GetLocalDecl(*F, LocalID));
148  }
149 
150  /// Reads a TemplateArgumentLocInfo appropriate for the
151  /// given TemplateArgument kind, advancing Idx.
154 
155  /// Reads a TemplateArgumentLoc, advancing Idx.
157 
160 
161  /// Reads a declarator info from the given record, advancing Idx.
163 
164  /// Reads the location information for a type.
165  void readTypeLoc(TypeLoc TL, LocSeq *Seq = nullptr);
166 
167  /// Map a local type ID within a given AST file to a global type ID.
168  serialization::TypeID getGlobalTypeID(unsigned LocalID) const {
169  return Reader->getGlobalTypeID(*F, LocalID);
170  }
171 
174  }
175 
176  /// Read a type from the current position in the record.
178  return Reader->readType(*F, Record, Idx);
179  }
181  return readType();
182  }
183 
184  /// Reads a declaration ID from the given position in this record.
185  ///
186  /// \returns The declaration ID read from the record, adjusted to a global ID.
188  return Reader->ReadDeclID(*F, Record, Idx);
189  }
190 
191  /// Reads a declaration from the given position in a record in the
192  /// given module, advancing Idx.
194  return Reader->ReadDecl(*F, Record, Idx);
195  }
197  return readDecl();
198  }
199 
200  /// Reads a declaration from the given position in the record,
201  /// advancing Idx.
202  ///
203  /// \returns The declaration read from this location, casted to the given
204  /// result type.
205  template<typename T>
206  T *readDeclAs() {
207  return Reader->ReadDeclAs<T>(*F, Record, Idx);
208  }
209 
211  return Reader->readIdentifier(*F, Record, Idx);
212  }
213 
214  /// Read a selector from the Record, advancing Idx.
216  return Reader->ReadSelector(*F, Record, Idx);
217  }
218 
219  /// Read a declaration name, advancing Idx.
220  // DeclarationName readDeclarationName(); (inherited)
223 
224  void readQualifierInfo(QualifierInfo &Info);
225 
226  /// Return a nested name specifier, advancing Idx.
227  // NestedNameSpecifier *readNestedNameSpecifier(); (inherited)
228 
230 
231  /// Read a template name, advancing Idx.
232  // TemplateName readTemplateName(); (inherited)
233 
234  /// Read a template argument, advancing Idx. (inherited)
235  // TemplateArgument readTemplateArgument();
236  using DataStreamBasicReader::readTemplateArgument;
239  if (Canonicalize) {
241  }
242  return Arg;
243  }
244 
245  /// Read a template parameter list, advancing Idx.
247 
248  /// Read a template argument array, advancing Idx.
250  bool Canonicalize = false);
251 
252  /// Read a UnresolvedSet structure, advancing Idx.
254 
255  /// Read a C++ base specifier, advancing Idx.
257 
258  /// Read a CXXCtorInitializer array, advancing Idx.
260 
262  return Reader->ReadCXXTemporary(*F, Record, Idx);
263  }
264 
265  /// Read an OMPTraitInfo object, advancing Idx.
267 
268  /// Read an OpenMP clause, advancing Idx.
270 
271  /// Read an OpenMP children, advancing Idx.
272  void readOMPChildren(OMPChildren *Data);
273 
274  /// Read a source location, advancing Idx.
276  return Reader->ReadSourceLocation(*F, Record, Idx, Seq);
277  }
278 
279  /// Read a source range, advancing Idx.
281  return Reader->ReadSourceRange(*F, Record, Idx, Seq);
282  }
283 
284  /// Read an arbitrary constant value, advancing Idx.
285  // APValue readAPValue(); (inherited)
286 
287  /// Read an integral value, advancing Idx.
288  // llvm::APInt readAPInt(); (inherited)
289 
290  /// Read a signed integral value, advancing Idx.
291  // llvm::APSInt readAPSInt(); (inherited)
292 
293  /// Read a floating-point value, advancing Idx.
294  llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem);
295 
296  /// Read a boolean value, advancing Idx.
297  bool readBool() { return readInt() != 0; }
298 
299  /// Read a 32-bit unsigned value; required to satisfy BasicReader.
300  uint32_t readUInt32() {
301  return uint32_t(readInt());
302  }
303 
304  /// Read a 64-bit unsigned value; required to satisfy BasicReader.
306  return readInt();
307  }
308 
309  /// Read a string, advancing Idx.
311  return Reader->ReadString(Record, Idx);
312  }
313 
314  /// Read a path, advancing Idx.
316  return Reader->ReadPath(*F, Record, Idx);
317  }
318 
319  /// Read a version tuple, advancing Idx.
320  VersionTuple readVersionTuple() {
321  return ASTReader::ReadVersionTuple(Record, Idx);
322  }
323 
324  /// Reads one attribute from the current stream position, advancing Idx.
325  Attr *readAttr();
326 
327  /// Reads attributes from the current stream position, advancing Idx.
328  void readAttributes(AttrVec &Attrs);
329 
330  /// Read an BTFTypeTagAttr object.
331  BTFTypeTagAttr *readBTFTypeTagAttr() {
332  return cast<BTFTypeTagAttr>(readAttr());
333  }
334 
335  /// Reads a token out of a record, advancing Idx.
337  return Reader->ReadToken(*F, Record, Idx);
338  }
339 
340  void recordSwitchCaseID(SwitchCase *SC, unsigned ID) {
341  Reader->RecordSwitchCaseID(SC, ID);
342  }
343 
344  /// Retrieve the switch-case statement with the given ID.
346  return Reader->getSwitchCaseWithID(ID);
347  }
348 };
349 
350 /// Helper class that saves the current stream position and
351 /// then restores it when destroyed.
353  explicit SavedStreamPosition(llvm::BitstreamCursor &Cursor)
354  : Cursor(Cursor), Offset(Cursor.GetCurrentBitNo()) {}
355 
357  if (llvm::Error Err = Cursor.JumpToBit(Offset))
358  llvm::report_fatal_error(
359  llvm::Twine("Cursor should always be able to go back, failed: ") +
360  toString(std::move(Err)));
361  }
362 
363 private:
364  llvm::BitstreamCursor &Cursor;
365  uint64_t Offset;
366 };
367 
368 inline void PCHValidator::Error(const char *Msg) {
369  Reader.Error(Msg);
370 }
371 
372 } // namespace clang
373 
374 #endif
clang::ExplicitSpecifier
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1828
clang::ASTRecordReader::readType
QualType readType()
Read a type from the current position in the record.
Definition: ASTRecordReader.h:177
clang::ASTRecordReader::readSelector
Selector readSelector()
Read a selector from the Record, advancing Idx.
Definition: ASTRecordReader.h:215
clang::ASTRecordReader::getSubmodule
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Definition: ASTRecordReader.h:95
clang::ASTReader::getContext
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTReader.h:2277
clang::ASTRecordReader::getContext
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTRecordReader.h:58
clang::ASTRecordReader::readDeclarationNameLoc
DeclarationNameLoc readDeclarationNameLoc(DeclarationName Name)
Read a declaration name, advancing Idx.
Definition: ASTReader.cpp:8773
AbstractBasicReader.h
clang::DeclarationNameLoc
DeclarationNameLoc - Additional source/type location info for a declaration name.
Definition: DeclarationName.h:659
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1376
llvm::SmallVector< uint64_t, 64 >
clang::ASTReader::ReadSubStmt
Stmt * ReadSubStmt()
Reads a sub-statement operand during statement reading.
Definition: ASTReader.h:2232
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::ASTRecordReader
An object for streaming information from a record.
Definition: ASTRecordReader.h:31
clang::ASTRecordReader::readAttributes
void readAttributes(AttrVec &Attrs)
Reads attributes from the current stream position, advancing Idx.
Definition: ASTReaderDecl.cpp:2927
clang::ASTReader::RecordData
SmallVector< uint64_t, 64 > RecordData
Definition: ASTReader.h:361
clang::ASTReader::ReadSelector
Selector ReadSelector(ModuleFile &M, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.h:2142
clang::OMPTraitInfo
Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...
Definition: OpenMPClause.h:8814
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:731
clang::ASTRecordReader::GetLocalDeclAs
T * GetLocalDeclAs(uint32_t LocalID)
Reads a declaration with the given local ID in the given module.
Definition: ASTRecordReader.h:146
clang::ASTRecordReader::readCXXBaseSpecifier
CXXBaseSpecifier readCXXBaseSpecifier()
Read a C++ base specifier, advancing Idx.
Definition: ASTReader.cpp:8859
clang::serialization::DataStreamBasicReader< ASTRecordReader >::DataStreamBasicReader
DataStreamBasicReader(ASTContext &ctx)
Definition: AbstractBasicReader.h:126
Cursor
Cursor
Definition: SerializedDiagnosticReader.cpp:109
clang::ASTRecordReader::readTypeLoc
void readTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Reads the location information for a type.
Definition: ASTReader.cpp:6831
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:147
clang::ASTRecordReader::getGlobalBitOffset
uint64_t getGlobalBitOffset(uint64_t LocalOffset)
Read information about an exception specification (inherited).
Definition: ASTRecordReader.h:125
clang::ASTReader::readIdentifier
IdentifierInfo * readIdentifier(ModuleFile &M, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.h:2074
clang::ASTReader::ReadVersionTuple
static VersionTuple ReadVersionTuple(const RecordData &Record, unsigned &Idx)
Read a version tuple.
Definition: ASTReader.cpp:9035
clang::ASTRecordReader::readOMPTraitInfo
OMPTraitInfo * readOMPTraitInfo()
Read an OMPTraitInfo object, advancing Idx.
Definition: ASTReader.cpp:12831
clang::ASTRecordReader::readDeclID
serialization::DeclID readDeclID()
Reads a declaration ID from the given position in this record.
Definition: ASTRecordReader.h:187
clang::ASTRecordReader::readVersionTuple
VersionTuple readVersionTuple()
Read a version tuple, advancing Idx.
Definition: ASTRecordReader.h:320
clang::ASTRecordReader::readIdentifier
IdentifierInfo * readIdentifier()
Definition: ASTRecordReader.h:210
llvm::Expected
Definition: LLVM.h:41
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:144
clang::ASTRecordReader::readQualifierInfo
void readQualifierInfo(QualifierInfo &Info)
Definition: ASTReader.cpp:8806
clang::ASTRecordReader::readTemplateArgument
TemplateArgument readTemplateArgument(bool Canonicalize)
Definition: ASTRecordReader.h:237
clang::ASTRecordReader::readTemplateArgumentLoc
TemplateArgumentLoc readTemplateArgumentLoc()
Reads a TemplateArgumentLoc, advancing Idx.
Definition: ASTReader.cpp:7183
Offset
unsigned Offset
Definition: Format.cpp:2574
uint64_t
unsigned long uint64_t
Definition: hlsl_basic_types.h:24
clang::ASTRecordReader::readUInt32
uint32_t readUInt32()
Read a 32-bit unsigned value; required to satisfy BasicReader.
Definition: ASTRecordReader.h:300
clang::serialization::SubmoduleID
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
Definition: ASTBitCodes.h:171
clang::ASTReader::GetLocalDecl
Decl * GetLocalDecl(ModuleFile &F, uint32_t LocalID)
Reads a declaration with the given local ID in the given module.
Definition: ASTReader.h:1864
clang::ASTRecordReader::readTypeSourceInfo
TypeSourceInfo * readTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
Definition: ASTReader.cpp:6838
clang::Module
Describes a module or submodule.
Definition: Module.h:96
clang::serialization::ModuleFile::DeclsCursor
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
Definition: ModuleFile.h:431
clang::ASTRecordReader::readVisibleDeclContextStorage
bool readVisibleDeclContextStorage(uint64_t Offset, serialization::DeclID ID)
Read the record that describes the visible contents of a DC.
Definition: ASTRecordReader.h:106
clang::OMPChildren
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
Definition: OpenMPClause.h:8893
clang::ASTReader::getGlobalTypeID
serialization::TypeID getGlobalTypeID(ModuleFile &F, unsigned LocalID) const
Map a local type ID within a given AST file into a global type ID.
Definition: ASTReader.cpp:7133
clang::ASTReader::ReadSourceLocation
SourceLocation ReadSourceLocation(ModuleFile &ModuleFile, SourceLocation::UIntTy Raw, LocSeq *Seq=nullptr) const
Read a source location from raw form.
Definition: ASTReader.h:2167
clang::OMPClause
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:55
clang::ASTRecordReader::readSourceRange
SourceRange readSourceRange(LocSeq *Seq=nullptr)
Read a source range, advancing Idx.
Definition: ASTRecordReader.h:280
clang::ASTRecordReader::readIntArray
ArrayRef< uint64_t > readIntArray(unsigned Len)
Definition: ASTRecordReader.h:76
clang::threadSafety::sx::toString
std::string toString(const til::SExpr *E)
Definition: ThreadSafetyCommon.h:90
clang::SavedStreamPosition::SavedStreamPosition
SavedStreamPosition(llvm::BitstreamCursor &Cursor)
Definition: ASTRecordReader.h:353
clang::ASTReader::getGlobalSubmoduleID
serialization::SubmoduleID getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID)
Retrieve the global submodule ID given a module and its local ID number.
Definition: ASTReader.cpp:8630
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:208
clang::ASTRecordReader::readSubExpr
Expr * readSubExpr()
Reads a sub-expression operand during statement reading.
Definition: ASTRecordReader.h:140
clang::ASTRecordReader::readBTFTypeTagAttr
BTFTypeTagAttr * readBTFTypeTagAttr()
Read an BTFTypeTagAttr object.
Definition: ASTRecordReader.h:331
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
clang::ASTRecordReader::readString
std::string readString()
Read a string, advancing Idx.
Definition: ASTRecordReader.h:310
clang::ASTRecordReader::readToken
Token readToken()
Reads a token out of a record, advancing Idx.
Definition: ASTRecordReader.h:336
clang::ASTRecordReader::readNestedNameSpecifierLoc
NestedNameSpecifierLoc readNestedNameSpecifierLoc()
Return a nested name specifier, advancing Idx.
Definition: ASTReader.cpp:8939
clang::ASTReader::getSubmodule
Module * getSubmodule(serialization::SubmoduleID GlobalID)
Retrieve the submodule that corresponds to a global submodule ID.
Definition: ASTReader.cpp:8645
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
clang::ASTRecordReader::readOMPChildren
void readOMPChildren(OMPChildren *Data)
Read an OpenMP children, advancing Idx.
Definition: ASTReader.cpp:12850
ASTContext.h
clang::ASTRecordReader::readStmtRef
Stmt * readStmtRef()
Definition: ASTRecordReader.h:131
clang::serialization::TypeID
uint32_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:85
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::ASTRecordReader::readStmt
Stmt * readStmt()
Reads a statement.
Definition: ASTRecordReader.h:130
clang::CXXTemporary
Represents a C++ temporary.
Definition: ExprCXX.h:1380
clang::ASTRecordReader::readSubStmt
Stmt * readSubStmt()
Reads a sub-statement operand during statement reading.
Definition: ASTRecordReader.h:137
clang::ASTRecordReader::readTemplateArgumentList
void readTemplateArgumentList(SmallVectorImpl< TemplateArgument > &TemplArgs, bool Canonicalize=false)
Read a template argument array, advancing Idx.
Definition: ASTReader.cpp:8838
clang::SwitchCase
Definition: Stmt.h:1526
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
clang::LazyASTUnresolvedSet
An UnresolvedSet-like class that might not have been loaded from the external AST source yet.
Definition: ASTUnresolvedSet.h:93
clang::ASTRecordReader::readDecl
Decl * readDecl()
Reads a declaration from the given position in a record in the given module, advancing Idx.
Definition: ASTRecordReader.h:193
clang::ASTReader::ReadString
static std::string ReadString(const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9013
clang::serialization::ModuleFile::isModule
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
Definition: ModuleFile.h:505
clang::ASTReader::ReadSubExpr
Expr * ReadSubExpr()
Reads a sub-expression operand during statement reading.
Definition: ASTReaderStmt.cpp:2681
clang::ASTReader::ReadToken
Token ReadToken(ModuleFile &M, const RecordDataImpl &Record, unsigned &Idx)
Reads a token out of a record.
Definition: ASTReader.cpp:1670
clang::ASTReader::RecordDataImpl
SmallVectorImpl< uint64_t > RecordDataImpl
Definition: ASTReader.h:362
clang::ASTRecordReader::operator[]
const uint64_t & operator[](size_t N)
An arbitrary index in this record.
Definition: ASTRecordReader.h:67
clang::ASTReader::readType
QualType readType(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Read a type from the current position in the given record, which was read from the given AST file.
Definition: ASTReader.h:1828
clang::ASTRecordReader::readQualType
QualType readQualType()
Definition: ASTRecordReader.h:180
clang::ExplicitSpecKind
ExplicitSpecKind
Define the meaning of possible values of the kind in ExplicitSpecifier.
Definition: Specifiers.h:25
clang::ASTRecordReader::size
size_t size() const
The length of this record.
Definition: ASTRecordReader.h:64
clang::ASTRecordReader::readOMPClause
OMPClause * readOMPClause()
Read an OpenMP clause, advancing Idx.
Definition: ASTReader.cpp:11490
clang::ASTRecordReader::readTemplateArgumentLocInfo
TemplateArgumentLocInfo readTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind)
Reads a TemplateArgumentLocInfo appropriate for the given TemplateArgument kind, advancing Idx.
Definition: ASTReader.cpp:7152
clang::SavedStreamPosition::~SavedStreamPosition
~SavedStreamPosition()
Definition: ASTRecordReader.h:356
clang::ASTReader::ReadSourceRange
SourceRange ReadSourceRange(ModuleFile &F, const RecordData &Record, unsigned &Idx, LocSeq *Seq=nullptr)
Read a source range.
Definition: ASTReader.cpp:9000
clang::ASTRecordReader::getGlobalSubmoduleID
serialization::SubmoduleID getGlobalSubmoduleID(unsigned LocalID)
Retrieve the global submodule ID its local ID number.
Definition: ASTRecordReader.h:90
clang::ASTRecordReader::recordSwitchCaseID
void recordSwitchCaseID(SwitchCase *SC, unsigned ID)
Definition: ASTRecordReader.h:340
clang::ASTRecordReader::getIdx
unsigned getIdx() const
The current position in this record.
Definition: ASTRecordReader.h:61
clang::ASTRecordReader::readExplicitSpec
ExplicitSpecifier readExplicitSpec()
Definition: ASTRecordReader.h:112
clang::SourceLocationSequence
Serialized encoding of a sequence of SourceLocations.
Definition: SourceLocationEncoding.h:87
clang::ASTRecordReader::readRecord
Expected< unsigned > readRecord(llvm::BitstreamCursor &Cursor, unsigned AbbrevID)
Reads a record with id AbbrevID from Cursor, resetting the internal state.
Definition: ASTReader.cpp:11459
llvm::ArrayRef
Definition: LLVM.h:34
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::ASTReader::RecordSwitchCaseID
void RecordSwitchCaseID(SwitchCase *SC, unsigned ID)
Record that the given ID maps to the given switch-case statement.
Definition: ASTReader.cpp:9070
clang::TypeLoc
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
clang::ASTRecordReader::getSwitchCaseWithID
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Definition: ASTRecordReader.h:345
clang::Qualifiers::fromOpaqueValue
static Qualifiers fromOpaqueValue(unsigned opaque)
Definition: Type.h:253
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::ASTRecordReader::readExpr
Expr * readExpr()
Reads an expression.
Definition: ASTRecordReader.h:134
clang::ASTRecordReader::peekInt
uint64_t peekInt()
Returns the current value in this record, without advancing.
Definition: ASTRecordReader.h:83
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::ASTReader
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:341
clang::SavedStreamPosition
Helper class that saves the current stream position and then restores it when destroyed.
Definition: ASTRecordReader.h:352
clang::ASTRecordReader::readTemplateParameterList
TemplateParameterList * readTemplateParameterList()
Read a template parameter list, advancing Idx.
Definition: ASTReader.cpp:8819
clang::ASTRecordReader::readDeclRef
Decl * readDeclRef()
Definition: ASTRecordReader.h:196
clang::Builtin::ID
ID
Definition: Builtins.h:52
clang
Definition: CalledOnceCheck.h:17
clang::ASTRecordReader::readAttr
Attr * readAttr()
Reads one attribute from the current stream position, advancing Idx.
Definition: ASTReaderDecl.cpp:2896
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:752
clang::ASTRecordReader::readCXXTemporary
CXXTemporary * readCXXTemporary()
Definition: ASTRecordReader.h:261
clang::ASTRecordReader::readSourceLocation
SourceLocation readSourceLocation(LocSeq *Seq=nullptr)
Read a source location, advancing Idx.
Definition: ASTRecordReader.h:275
clang::ASTRecordReader::readLexicalDeclContextStorage
bool readLexicalDeclContextStorage(uint64_t Offset, DeclContext *DC)
Read the record that describes the lexical contents of a DC.
Definition: ASTRecordReader.h:100
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:69
clang::TemplateArgument::ArgKind
ArgKind
The kind of template argument we're storing.
Definition: TemplateBase.h:64
ASTReader.h
SourceLocationEncoding.h
clang::ASTRecordReader::skipInts
void skipInts(unsigned N)
Skips the specified number of values.
Definition: ASTRecordReader.h:86
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::ASTReader::ReadStmt
Stmt * ReadStmt(ModuleFile &F)
Reads a statement.
Definition: ASTReaderStmt.cpp:2663
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:41
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6530
clang::ASTRecordReader::ASTRecordReader
ASTRecordReader(ASTReader &Reader, ModuleFile &F)
Construct an ASTRecordReader that uses the default encoding scheme.
Definition: ASTRecordReader.h:46
clang::ASTReader::ReadDeclAs
T * ReadDeclAs(ModuleFile &F, const RecordData &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:1904
clang::ASTRecordReader::readPath
std::string readPath()
Read a path, advancing Idx.
Definition: ASTRecordReader.h:315
clang::ASTReader::ReadCXXTemporary
CXXTemporary * ReadCXXTemporary(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9047
clang::ASTRecordReader::readDeclAs
T * readDeclAs()
Reads a declaration from the given position in the record, advancing Idx.
Definition: ASTRecordReader.h:206
clang::ASTRecordReader::readCXXCtorInitializers
CXXCtorInitializer ** readCXXCtorInitializers()
Read a CXXCtorInitializer array, advancing Idx.
Definition: ASTReader.cpp:8874
clang::ASTReader::ReadExpr
Expr * ReadExpr(ModuleFile &F)
Reads an expression.
Definition: ASTReaderStmt.cpp:2677
clang::ASTRecordReader::readUnresolvedSet
void readUnresolvedSet(LazyASTUnresolvedSet &Set)
Read a UnresolvedSet structure, advancing Idx.
Definition: ASTReader.cpp:8848
clang::ASTContext::getCanonicalTemplateArgument
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
Definition: ASTContext.cpp:6592
clang::ASTRecordReader::readQualifiers
Qualifiers readQualifiers()
Definition: ASTRecordReader.h:172
clang::ASTTemplateArgumentListInfo
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:612
clang::QualifierInfo
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
Definition: Decl.h:699
llvm::SmallVectorImpl
Definition: Randstruct.h:18
clang::ASTRecordReader::readInt
uint64_t readInt()
Returns the current value in this record, and advances to the next value.
Definition: ASTRecordReader.h:74
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::ASTRecordReader::readDeclarationNameInfo
DeclarationNameInfo readDeclarationNameInfo()
Definition: ASTReader.cpp:8798
clang::serialization::DeclID
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2205
Token.h
clang::ASTReader::getSwitchCaseWithID
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Definition: ASTReader.cpp:9077
clang::ASTRecordReader::readASTTemplateArgumentListInfo
const ASTTemplateArgumentListInfo * readASTTemplateArgumentListInfo()
Definition: ASTReader.cpp:7194
clang::ASTReader::ReadDeclID
serialization::DeclID ReadDeclID(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Reads a declaration ID from the given position in a record in the given module.
Definition: ASTReader.cpp:7512
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:767
clang::ASTReader::ReadDecl
Decl * ReadDecl(ModuleFile &F, const RecordData &R, unsigned &I)
Reads a declaration from the given position in a record in the given module.
Definition: ASTReader.h:1894
clang::ASTRecordReader::readUInt64
uint64_t readUInt64()
Read a 64-bit unsigned value; required to satisfy BasicReader.
Definition: ASTRecordReader.h:305
clang::ASTRecordReader::isModule
bool isModule() const
Is this a module file for a module (rather than a PCH or similar).
Definition: ASTRecordReader.h:55
clang::serialization::ModuleFile
Information about a module that has been loaded by the ASTReader.
Definition: ModuleFile.h:111
clang::ASTRecordReader::back
uint64_t back()
Returns the last value in this record.
Definition: ASTRecordReader.h:70
clang::TemplateArgumentLocInfo
Location information for a TemplateArgument.
Definition: TemplateBase.h:405
clang::ASTRecordReader::readBool
bool readBool()
Read a boolean value, advancing Idx.
Definition: ASTRecordReader.h:297
clang::ASTReader::ReadPath
std::string ReadPath(ModuleFile &F, const RecordData &Record, unsigned &Idx)
Definition: ASTReader.cpp:9020
clang::ASTRecordReader::getGlobalTypeID
serialization::TypeID getGlobalTypeID(unsigned LocalID) const
Map a local type ID within a given AST file to a global type ID.
Definition: ASTRecordReader.h:168
clang::ASTRecordReader::readAPFloat
llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem)
Read an arbitrary constant value, advancing Idx.
Definition: ASTReader.cpp:9008
clang::serialization::DataStreamBasicReader
DataStreamBasicReader provides convenience implementations for many BasicReader methods based on the ...
Definition: AbstractBasicReader.h:123