clang  15.0.0git
ASTRecordWriter.h
Go to the documentation of this file.
1 //===- ASTRecordWriter.h - Helper classes for writing 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 the ASTRecordWriter class, a helper class useful
10 // when serializing AST.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_SERIALIZATION_ASTRECORDWRITER_H
15 #define LLVM_CLANG_SERIALIZATION_ASTRECORDWRITER_H
16 
18 #include "clang/AST/OpenMPClause.h"
21 
22 namespace clang {
23 
24 class TypeLoc;
25 
26 /// An object for streaming information to a record.
28  : public serialization::DataStreamBasicWriter<ASTRecordWriter> {
30 
31  ASTWriter *Writer;
33 
34  /// Statements that we've encountered while serializing a
35  /// declaration or type.
36  SmallVector<Stmt *, 16> StmtsToEmit;
37 
38  /// Indices of record elements that describe offsets within the
39  /// bitcode. These will be converted to offsets relative to the current
40  /// record when emitted.
41  SmallVector<unsigned, 8> OffsetIndices;
42 
43  /// Flush all of the statements and expressions that have
44  /// been added to the queue via AddStmt().
45  void FlushStmts();
46  void FlushSubStmts();
47 
48  void PrepareToEmit(uint64_t MyOffset) {
49  // Convert offsets into relative form.
50  for (unsigned I : OffsetIndices) {
51  auto &StoredOffset = (*Record)[I];
52  assert(StoredOffset < MyOffset && "invalid offset");
53  if (StoredOffset)
54  StoredOffset = MyOffset - StoredOffset;
55  }
56  OffsetIndices.clear();
57  }
58 
59 public:
60  /// Construct a ASTRecordWriter that uses the default encoding scheme.
62  : DataStreamBasicWriter(W.getASTContext()), Writer(&W), Record(&Record) {}
63 
64  /// Construct a ASTRecordWriter that uses the same encoding scheme as another
65  /// ASTRecordWriter.
67  : DataStreamBasicWriter(Parent.getASTContext()), Writer(Parent.Writer),
68  Record(&Record) {}
69 
70  /// Copying an ASTRecordWriter is almost certainly a bug.
71  ASTRecordWriter(const ASTRecordWriter &) = delete;
72  ASTRecordWriter &operator=(const ASTRecordWriter &) = delete;
73 
74  /// Extract the underlying record storage.
75  ASTWriter::RecordDataImpl &getRecordData() const { return *Record; }
76 
77  /// Minimal vector-like interface.
78  /// @{
79  void push_back(uint64_t N) { Record->push_back(N); }
80  template<typename InputIterator>
81  void append(InputIterator begin, InputIterator end) {
82  Record->append(begin, end);
83  }
84  bool empty() const { return Record->empty(); }
85  size_t size() const { return Record->size(); }
86  uint64_t &operator[](size_t N) { return (*Record)[N]; }
87  /// @}
88 
89  /// Emit the record to the stream, followed by its substatements, and
90  /// return its offset.
91  // FIXME: Allow record producers to suggest Abbrevs.
92  uint64_t Emit(unsigned Code, unsigned Abbrev = 0) {
93  uint64_t Offset = Writer->Stream.GetCurrentBitNo();
94  PrepareToEmit(Offset);
95  Writer->Stream.EmitRecord(Code, *Record, Abbrev);
96  FlushStmts();
97  return Offset;
98  }
99 
100  /// Emit the record to the stream, preceded by its substatements.
101  uint64_t EmitStmt(unsigned Code, unsigned Abbrev = 0) {
102  FlushSubStmts();
103  PrepareToEmit(Writer->Stream.GetCurrentBitNo());
104  Writer->Stream.EmitRecord(Code, *Record, Abbrev);
105  return Writer->Stream.GetCurrentBitNo();
106  }
107 
108  /// Add a bit offset into the record. This will be converted into an
109  /// offset relative to the current record when emitted.
110  void AddOffset(uint64_t BitOffset) {
111  OffsetIndices.push_back(Record->size());
112  Record->push_back(BitOffset);
113  }
114 
115  /// Add the given statement or expression to the queue of
116  /// statements to emit.
117  ///
118  /// This routine should be used when emitting types and declarations
119  /// that have expressions as part of their formulation. Once the
120  /// type or declaration has been written, Emit() will write
121  /// the corresponding statements just after the record.
122  void AddStmt(Stmt *S) {
123  StmtsToEmit.push_back(S);
124  }
125  void writeStmtRef(const Stmt *S) {
126  AddStmt(const_cast<Stmt*>(S));
127  }
128 
129  /// Write an BTFTypeTagAttr object.
130  void writeBTFTypeTagAttr(const BTFTypeTagAttr *A) { AddAttr(A); }
131 
132  /// Add a definition for the given function to the queue of statements
133  /// to emit.
134  void AddFunctionDefinition(const FunctionDecl *FD);
135 
136  /// Emit a source location.
137  void AddSourceLocation(SourceLocation Loc, LocSeq *Seq = nullptr) {
138  return Writer->AddSourceLocation(Loc, *Record, Seq);
139  }
141  AddSourceLocation(Loc);
142  }
143 
144  /// Emit a source range.
145  void AddSourceRange(SourceRange Range, LocSeq *Seq = nullptr) {
146  return Writer->AddSourceRange(Range, *Record, Seq);
147  }
148 
149  void writeBool(bool Value) {
150  Record->push_back(Value);
151  }
152 
153  void writeUInt32(uint32_t Value) {
154  Record->push_back(Value);
155  }
156 
158  Record->push_back(Value);
159  }
160 
161  /// Emit an integral value.
162  void AddAPInt(const llvm::APInt &Value) {
163  writeAPInt(Value);
164  }
165 
166  /// Emit a signed integral value.
167  void AddAPSInt(const llvm::APSInt &Value) {
169  }
170 
171  /// Emit a floating-point value.
172  void AddAPFloat(const llvm::APFloat &Value);
173 
174  /// Emit an APvalue.
175  void AddAPValue(const APValue &Value) { writeAPValue(Value); }
176 
177  /// Emit a reference to an identifier.
179  return Writer->AddIdentifierRef(II, *Record);
180  }
181  void writeIdentifier(const IdentifierInfo *II) {
182  AddIdentifierRef(II);
183  }
184 
185  /// Emit a Selector (which is a smart pointer reference).
186  void AddSelectorRef(Selector S);
188  AddSelectorRef(sel);
189  }
190 
191  /// Emit a CXXTemporary.
192  void AddCXXTemporary(const CXXTemporary *Temp);
193 
194  /// Emit a C++ base specifier.
196 
197  /// Emit a set of C++ base specifiers.
199 
200  /// Emit a reference to a type.
202  return Writer->AddTypeRef(T, *Record);
203  }
205  AddTypeRef(T);
206  }
207 
208  /// Emits a reference to a declarator info.
209  void AddTypeSourceInfo(TypeSourceInfo *TInfo);
210 
211  /// Emits source location information for a type. Does not emit the type.
212  void AddTypeLoc(TypeLoc TL, LocSeq *Seq = nullptr);
213 
214  /// Emits a template argument location info.
216  const TemplateArgumentLocInfo &Arg);
217 
218  /// Emits a template argument location.
220 
221  /// Emits an AST template argument list info.
223  const ASTTemplateArgumentListInfo *ASTTemplArgList);
224 
225  /// Emit a reference to a declaration.
226  void AddDeclRef(const Decl *D) {
227  return Writer->AddDeclRef(D, *Record);
228  }
229  void writeDeclRef(const Decl *D) {
230  AddDeclRef(D);
231  }
232 
233  /// Emit a declaration name.
235  writeDeclarationName(Name);
236  }
237 
238  void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
239  DeclarationName Name);
240  void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
241 
242  void AddQualifierInfo(const QualifierInfo &Info);
243 
244  /// Emit a nested name specifier.
247  }
248 
249  /// Emit a nested name specifier with source-location information.
251 
252  /// Emit a template name.
254  writeTemplateName(Name);
255  }
256 
257  /// Emit a template argument.
259  writeTemplateArgument(Arg);
260  }
261 
262  /// Emit a template parameter list.
263  void AddTemplateParameterList(const TemplateParameterList *TemplateParams);
264 
265  /// Emit a template argument list.
266  void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs);
267 
268  /// Emit a UnresolvedSet structure.
269  void AddUnresolvedSet(const ASTUnresolvedSet &Set);
270 
271  /// Emit a CXXCtorInitializer array.
273 
274  void AddCXXDefinitionData(const CXXRecordDecl *D);
275 
276  /// Emit information about the initializer of a VarDecl.
277  void AddVarDeclInit(const VarDecl *VD);
278 
279  /// Write an OMPTraitInfo object.
280  void writeOMPTraitInfo(const OMPTraitInfo *TI);
281 
282  void writeOMPClause(OMPClause *C);
283 
284  /// Writes data related to the OpenMP directives.
285  void writeOMPChildren(OMPChildren *Data);
286 
287  /// Emit a string.
288  void AddString(StringRef Str) {
289  return Writer->AddString(Str, *Record);
290  }
291 
292  /// Emit a path.
293  void AddPath(StringRef Path) {
294  return Writer->AddPath(Path, *Record);
295  }
296 
297  /// Emit a version tuple.
298  void AddVersionTuple(const VersionTuple &Version) {
299  return Writer->AddVersionTuple(Version, *Record);
300  }
301 
302  // Emit an attribute.
303  void AddAttr(const Attr *A);
304 
305  /// Emit a list of attributes.
307 };
308 
309 } // end namespace clang
310 
311 #endif
clang::ASTRecordWriter::AddTemplateName
void AddTemplateName(TemplateName Name)
Emit a template name.
Definition: ASTRecordWriter.h:253
clang::ASTRecordWriter::AddFunctionDefinition
void AddFunctionDefinition(const FunctionDecl *FD)
Add a definition for the given function to the queue of statements to emit.
Definition: ASTWriterDecl.cpp:2449
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::DeclarationNameLoc
DeclarationNameLoc - Additional source/type location info for a declaration name.
Definition: DeclarationName.h:659
clang::ASTRecordWriter::AddASTTemplateArgumentListInfo
void AddASTTemplateArgumentListInfo(const ASTTemplateArgumentListInfo *ASTTemplArgList)
Emits an AST template argument list info.
Definition: ASTWriter.cpp:5635
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::ASTRecordWriter::AddIdentifierRef
void AddIdentifierRef(const IdentifierInfo *II)
Emit a reference to an identifier.
Definition: ASTRecordWriter.h:178
clang::ASTRecordWriter::operator=
ASTRecordWriter & operator=(const ASTRecordWriter &)=delete
clang::ASTRecordWriter::AddCXXCtorInitializers
void AddCXXCtorInitializers(ArrayRef< CXXCtorInitializer * > CtorInits)
Emit a CXXCtorInitializer array.
Definition: ASTWriter.cpp:5720
clang::ASTRecordWriter::push_back
void push_back(uint64_t N)
Minimal vector-like interface.
Definition: ASTRecordWriter.h:79
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::NestedNameSpecifier
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Definition: NestedNameSpecifier.h:50
clang::ASTRecordWriter::AddQualifierInfo
void AddQualifierInfo(const QualifierInfo &Info)
Definition: ASTWriter.cpp:5547
clang::ASTRecordWriter::writeIdentifier
void writeIdentifier(const IdentifierInfo *II)
Definition: ASTRecordWriter.h:181
clang::serialization::DataStreamBasicWriter
DataStreamBasicWriter provides convenience implementations for many BasicWriter methods based on the ...
Definition: AbstractBasicWriter.h:122
clang::ASTRecordWriter::writeQualType
void writeQualType(QualType T)
Definition: ASTRecordWriter.h:204
clang::ASTRecordWriter::writeOMPChildren
void writeOMPChildren(OMPChildren *Data)
Writes data related to the OpenMP directives.
Definition: ASTWriter.cpp:6937
clang::ASTRecordWriter::AddDeclarationName
void AddDeclarationName(DeclarationName Name)
Emit a declaration name.
Definition: ASTRecordWriter.h:234
clang::ASTRecordWriter::AddAttributes
void AddAttributes(ArrayRef< const Attr * > Attrs)
Emit a list of attributes.
Definition: ASTWriter.cpp:4365
clang::ASTRecordWriter::writeOMPTraitInfo
void writeOMPTraitInfo(const OMPTraitInfo *TI)
Write an OMPTraitInfo object.
Definition: ASTWriter.cpp:6920
clang::ASTRecordWriter::AddTemplateParameterList
void AddTemplateParameterList(const TemplateParameterList *TemplateParams)
Emit a template parameter list.
Definition: ASTWriter.cpp:5608
ASTWriter.h
clang::ASTRecordWriter::AddTypeSourceInfo
void AddTypeSourceInfo(TypeSourceInfo *TInfo)
Emits a reference to a declarator info.
Definition: ASTWriter.cpp:5352
clang::ASTRecordWriter::getRecordData
ASTWriter::RecordDataImpl & getRecordData() const
Extract the underlying record storage.
Definition: ASTRecordWriter.h:75
clang::ASTRecordWriter::AddCXXBaseSpecifiers
void AddCXXBaseSpecifiers(ArrayRef< CXXBaseSpecifier > Bases)
Emit a set of C++ base specifiers.
Definition: ASTWriter.cpp:5680
clang::ASTRecordWriter::AddAPInt
void AddAPInt(const llvm::APInt &Value)
Emit an integral value.
Definition: ASTRecordWriter.h:162
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:144
clang::ASTWriter::AddSourceLocation
void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record, LocSeq *Seq=nullptr)
Emit a source location.
Definition: ASTWriter.cpp:5227
clang::ASTRecordWriter::writeSourceLocation
void writeSourceLocation(SourceLocation Loc)
Definition: ASTRecordWriter.h:140
clang::ASTRecordWriter::AddSourceLocation
void AddSourceLocation(SourceLocation Loc, LocSeq *Seq=nullptr)
Emit a source location.
Definition: ASTRecordWriter.h:137
Offset
unsigned Offset
Definition: Format.cpp:2574
clang::ASTRecordWriter::AddPath
void AddPath(StringRef Path)
Emit a path.
Definition: ASTRecordWriter.h:293
uint64_t
unsigned long uint64_t
Definition: hlsl_basic_types.h:24
clang::ASTRecordWriter::AddTypeRef
void AddTypeRef(QualType T)
Emit a reference to a type.
Definition: ASTRecordWriter.h:201
clang::ASTWriter::AddIdentifierRef
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
Definition: ASTWriter.cpp:5242
APSInt
llvm::APSInt APSInt
Definition: ByteCodeEmitter.cpp:19
clang::ASTRecordWriter::AddStmt
void AddStmt(Stmt *S)
Add the given statement or expression to the queue of statements to emit.
Definition: ASTRecordWriter.h:122
clang::ASTRecordWriter::AddTemplateArgumentList
void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs)
Emit a template argument list.
Definition: ASTWriter.cpp:5627
clang::ASTUnresolvedSet
An UnresolvedSet-like class which uses the ASTContext's allocator.
Definition: ASTUnresolvedSet.h:29
clang::OMPChildren
Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) a...
Definition: OpenMPClause.h:8893
clang::OMPClause
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:55
clang::ASTWriter::AddVersionTuple
void AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record)
Add a version tuple to the given record.
Definition: ASTWriter.cpp:4420
clang::ASTWriter::AddDeclRef
void AddDeclRef(const Decl *D, RecordDataImpl &Record)
Emit a reference to a declaration.
Definition: ASTWriter.cpp:5409
clang::ASTRecordWriter::AddNestedNameSpecifierLoc
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS)
Emit a nested name specifier with source-location information.
Definition: ASTWriter.cpp:5554
clang::ASTRecordWriter::AddCXXDefinitionData
void AddCXXDefinitionData(const CXXRecordDecl *D)
Definition: ASTWriter.cpp:5725
clang::ASTRecordWriter::AddDeclarationNameLoc
void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name)
Definition: ASTWriter.cpp:5513
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
clang::serialization::DataStreamBasicWriter< ASTRecordWriter >::writeAPSInt
void writeAPSInt(const llvm::APSInt &value)
Definition: AbstractBasicWriter.h:156
clang::ASTRecordWriter::writeBTFTypeTagAttr
void writeBTFTypeTagAttr(const BTFTypeTagAttr *A)
Write an BTFTypeTagAttr object.
Definition: ASTRecordWriter.h:130
clang::ASTRecordWriter::writeOMPClause
void writeOMPClause(OMPClause *C)
Definition: ASTWriter.cpp:6191
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::ASTRecordWriter::size
size_t size() const
Definition: ASTRecordWriter.h:85
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::ASTRecordWriter::empty
bool empty() const
Definition: ASTRecordWriter.h:84
clang::CXXTemporary
Represents a C++ temporary.
Definition: ExprCXX.h:1380
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
Base
clang::ASTWriter
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:85
clang::ASTRecordWriter::AddUnresolvedSet
void AddUnresolvedSet(const ASTUnresolvedSet &Set)
Emit a UnresolvedSet structure.
Definition: ASTWriter.cpp:5646
clang::ASTRecordWriter::writeUInt32
void writeUInt32(uint32_t Value)
Definition: ASTRecordWriter.h:153
clang::ASTRecordWriter::AddVarDeclInit
void AddVarDeclInit(const VarDecl *VD)
Emit information about the initializer of a VarDecl.
Definition: ASTWriter.cpp:5795
clang::ASTRecordWriter::writeBool
void writeBool(bool Value)
Definition: ASTRecordWriter.h:149
clang::ASTRecordWriter::AddAPValue
void AddAPValue(const APValue &Value)
Emit an APvalue.
Definition: ASTRecordWriter.h:175
clang::ASTRecordWriter::writeStmtRef
void writeStmtRef(const Stmt *S)
Definition: ASTRecordWriter.h:125
clang::ASTRecordWriter::writeUInt64
void writeUInt64(uint64_t Value)
Definition: ASTRecordWriter.h:157
clang::ASTRecordWriter::AddCXXTemporary
void AddCXXTemporary(const CXXTemporary *Temp)
Emit a CXXTemporary.
Definition: ASTWriter.cpp:5307
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
clang::serialization::DataStreamBasicWriter< ASTRecordWriter >::writeAPInt
void writeAPInt(const llvm::APInt &value)
Definition: AbstractBasicWriter.h:161
clang::ASTRecordWriter::AddSelectorRef
void AddSelectorRef(Selector S)
Emit a Selector (which is a smart pointer reference).
Definition: ASTWriter.cpp:5284
clang::ASTRecordWriter::append
void append(InputIterator begin, InputIterator end)
Definition: ASTRecordWriter.h:81
clang::TemplateName
Represents a C++ template name within the type system.
Definition: TemplateName.h:192
clang::ASTRecordWriter::writeDeclRef
void writeDeclRef(const Decl *D)
Definition: ASTRecordWriter.h:229
clang::SourceLocationSequence
Serialized encoding of a sequence of SourceLocations.
Definition: SourceLocationEncoding.h:87
llvm::ArrayRef
Definition: LLVM.h:34
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::ASTRecordWriter::AddDeclarationNameInfo
void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo)
Definition: ASTWriter.cpp:5540
OpenMPClause.h
clang::TypeLoc
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
clang::ASTRecordWriter::AddTemplateArgumentLocInfo
void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind, const TemplateArgumentLocInfo &Arg)
Emits a template argument location info.
Definition: ASTWriter.cpp:5311
clang::ASTRecordWriter::writeSelector
void writeSelector(Selector sel)
Definition: ASTRecordWriter.h:187
clang::ASTRecordWriter::EmitStmt
uint64_t EmitStmt(unsigned Code, unsigned Abbrev=0)
Emit the record to the stream, preceded by its substatements.
Definition: ASTRecordWriter.h:101
clang::ASTRecordWriter::AddAPFloat
void AddAPFloat(const llvm::APFloat &Value)
Emit a floating-point value.
Definition: ASTWriter.cpp:5238
clang::ASTRecordWriter::AddSourceRange
void AddSourceRange(SourceRange Range, LocSeq *Seq=nullptr)
Emit a source range.
Definition: ASTRecordWriter.h:145
clang::TemplateArgumentList
A template argument list.
Definition: DeclTemplate.h:237
clang::ASTRecordWriter
An object for streaming information to a record.
Definition: ASTRecordWriter.h:27
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::ASTRecordWriter::AddDeclRef
void AddDeclRef(const Decl *D)
Emit a reference to a declaration.
Definition: ASTRecordWriter.h:226
clang
Definition: CalledOnceCheck.h:17
clang::ASTRecordWriter::Emit
uint64_t Emit(unsigned Code, unsigned Abbrev=0)
Emit the record to the stream, followed by its substatements, and return its offset.
Definition: ASTRecordWriter.h:92
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:752
clang::ASTRecordWriter::AddTemplateArgument
void AddTemplateArgument(const TemplateArgument &Arg)
Emit a template argument.
Definition: ASTRecordWriter.h:258
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:70
clang::TemplateArgument::ArgKind
ArgKind
The kind of template argument we're storing.
Definition: TemplateBase.h:64
clang::ASTRecordWriter::AddCXXBaseSpecifier
void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base)
Emit a C++ base specifier.
Definition: ASTWriter.cpp:5656
clang::ASTRecordWriter::ASTRecordWriter
ASTRecordWriter(ASTWriter &W, ASTWriter::RecordDataImpl &Record)
Construct a ASTRecordWriter that uses the default encoding scheme.
Definition: ASTRecordWriter.h:61
SourceLocationEncoding.h
clang::ASTRecordWriter::AddAttr
void AddAttr(const Attr *A)
Definition: ASTWriter.cpp:4347
clang::ASTWriter::AddTypeRef
void AddTypeRef(QualType T, RecordDataImpl &Record)
Emit a reference to a type.
Definition: ASTWriter.cpp:5369
clang::ASTRecordWriter::AddAPSInt
void AddAPSInt(const llvm::APSInt &Value)
Emit a signed integral value.
Definition: ASTRecordWriter.h:167
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::Attr
Attr - This represents one attribute.
Definition: Attr.h:41
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6530
clang::ASTRecordWriter::AddNestedNameSpecifier
void AddNestedNameSpecifier(NestedNameSpecifier *NNS)
Emit a nested name specifier.
Definition: ASTRecordWriter.h:245
clang::ASTRecordWriter::AddOffset
void AddOffset(uint64_t BitOffset)
Add a bit offset into the record.
Definition: ASTRecordWriter.h:110
Parent
NodeId Parent
Definition: ASTDiff.cpp:192
clang::ASTWriter::AddSourceRange
void AddSourceRange(SourceRange Range, RecordDataImpl &Record, LocSeq *Seq=nullptr)
Emit a source range.
Definition: ASTWriter.cpp:5232
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
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::ASTWriter::AddPath
void AddPath(StringRef Path, RecordDataImpl &Record)
Add a path to the given record.
Definition: ASTWriter.cpp:4407
AbstractBasicWriter.h
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:767
clang::ASTRecordWriter::ASTRecordWriter
ASTRecordWriter(ASTRecordWriter &Parent, ASTWriter::RecordDataImpl &Record)
Construct a ASTRecordWriter that uses the same encoding scheme as another ASTRecordWriter.
Definition: ASTRecordWriter.h:66
clang::ASTRecordWriter::AddTypeLoc
void AddTypeLoc(TypeLoc TL, LocSeq *Seq=nullptr)
Emits source location information for a type. Does not emit the type.
Definition: ASTWriter.cpp:5362
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1872
clang::serialization::DataStreamBasicWriter< ASTRecordWriter >::DataStreamBasicWriter
DataStreamBasicWriter(ASTContext &ctx)
Definition: AbstractBasicWriter.h:125
clang::TemplateArgumentLocInfo
Location information for a TemplateArgument.
Definition: TemplateBase.h:405
clang::ASTRecordWriter::AddVersionTuple
void AddVersionTuple(const VersionTuple &Version)
Emit a version tuple.
Definition: ASTRecordWriter.h:298
clang::ASTWriter::AddString
void AddString(StringRef Str, RecordDataImpl &Record)
Add a string to the given record.
Definition: ASTWriter.cpp:4384
clang::serialization::DataStreamBasicWriter< ASTRecordWriter >::writeNestedNameSpecifier
void writeNestedNameSpecifier(NestedNameSpecifier *NNS)
Definition: AbstractBasicWriter.h:228
clang::ASTRecordWriter::AddTemplateArgumentLoc
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg)
Emits a template argument location.
Definition: ASTWriter.cpp:5339
clang::ASTRecordWriter::AddString
void AddString(StringRef Str)
Emit a string.
Definition: ASTRecordWriter.h:288
clang::ASTRecordWriter::operator[]
uint64_t & operator[](size_t N)
Definition: ASTRecordWriter.h:86