clang  10.0.0svn
ASTWriter.h
Go to the documentation of this file.
1 //===- ASTWriter.h - AST File Writer ----------------------------*- 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 ASTWriter class, which writes an AST file
10 // containing a serialized representation of a translation unit.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_SERIALIZATION_ASTWRITER_H
15 #define LLVM_CLANG_SERIALIZATION_ASTWRITER_H
16 
18 #include "clang/AST/Decl.h"
21 #include "clang/AST/OpenMPClause.h"
22 #include "clang/AST/TemplateBase.h"
23 #include "clang/AST/TemplateName.h"
24 #include "clang/AST/Type.h"
25 #include "clang/AST/TypeLoc.h"
26 #include "clang/Basic/LLVM.h"
32 #include "llvm/ADT/ArrayRef.h"
33 #include "llvm/ADT/DenseMap.h"
34 #include "llvm/ADT/DenseSet.h"
35 #include "llvm/ADT/MapVector.h"
36 #include "llvm/ADT/SetVector.h"
37 #include "llvm/ADT/SmallVector.h"
38 #include "llvm/ADT/StringRef.h"
39 #include "llvm/Bitstream/BitstreamWriter.h"
40 #include <cassert>
41 #include <cstddef>
42 #include <cstdint>
43 #include <ctime>
44 #include <memory>
45 #include <queue>
46 #include <string>
47 #include <utility>
48 #include <vector>
49 
50 namespace llvm {
51 
52 class APFloat;
53 class APInt;
54 class APSInt;
55 
56 } // namespace llvm
57 
58 namespace clang {
59 
60 class ASTContext;
61 class ASTReader;
62 class ASTUnresolvedSet;
63 class Attr;
64 class CXXBaseSpecifier;
65 class CXXCtorInitializer;
66 class CXXRecordDecl;
67 class CXXTemporary;
68 class FileEntry;
69 class FPOptions;
70 class FunctionDecl;
71 class HeaderSearch;
72 class HeaderSearchOptions;
73 class IdentifierResolver;
74 class LangOptions;
75 class MacroDefinitionRecord;
76 class MacroInfo;
77 class Module;
78 class InMemoryModuleCache;
79 class ModuleFileExtension;
80 class ModuleFileExtensionWriter;
81 class NamedDecl;
82 class NestedNameSpecifier;
83 class ObjCInterfaceDecl;
84 class PreprocessingRecord;
85 class Preprocessor;
86 struct QualifierInfo;
87 class RecordDecl;
88 class Sema;
89 class SourceManager;
90 class Stmt;
91 struct StoredDeclsList;
92 class SwitchCase;
93 class TemplateParameterList;
94 class Token;
95 class TypeSourceInfo;
96 
97 /// Writes an AST file containing the contents of a translation unit.
98 ///
99 /// The ASTWriter class produces a bitstream containing the serialized
100 /// representation of a given abstract syntax tree and its supporting
101 /// data structures. This bitstream can be de-serialized via an
102 /// instance of the ASTReader class.
104  public ASTMutationListener {
105 public:
106  friend class ASTDeclWriter;
107  friend class ASTRecordWriter;
108  friend class ASTStmtWriter;
109  friend class ASTTypeWriter;
110 
114 
115 private:
116  /// Map that provides the ID numbers of each type within the
117  /// output stream, plus those deserialized from a chained PCH.
118  ///
119  /// The ID numbers of types are consecutive (in order of discovery)
120  /// and start at 1. 0 is reserved for NULL. When types are actually
121  /// stored in the stream, the ID number is shifted by 2 bits to
122  /// allow for the const/volatile qualifiers.
123  ///
124  /// Keys in the map never have const/volatile qualifiers.
125  using TypeIdxMap = llvm::DenseMap<QualType, serialization::TypeIdx,
127 
128  /// The bitstream writer used to emit this precompiled header.
129  llvm::BitstreamWriter &Stream;
130 
131  /// The buffer associated with the bitstream.
132  const SmallVectorImpl<char> &Buffer;
133 
134  /// The PCM manager which manages memory buffers for pcm files.
135  InMemoryModuleCache &ModuleCache;
136 
137  /// The ASTContext we're writing.
138  ASTContext *Context = nullptr;
139 
140  /// The preprocessor we're writing.
141  Preprocessor *PP = nullptr;
142 
143  /// The reader of existing AST files, if we're chaining.
144  ASTReader *Chain = nullptr;
145 
146  /// The module we're currently writing, if any.
147  Module *WritingModule = nullptr;
148 
149  /// The base directory for any relative paths we emit.
150  std::string BaseDirectory;
151 
152  /// Indicates whether timestamps should be written to the produced
153  /// module file. This is the case for files implicitly written to the
154  /// module cache, where we need the timestamps to determine if the module
155  /// file is up to date, but not otherwise.
156  bool IncludeTimestamps;
157 
158  /// Indicates when the AST writing is actively performing
159  /// serialization, rather than just queueing updates.
160  bool WritingAST = false;
161 
162  /// Indicates that we are done serializing the collection of decls
163  /// and types to emit.
164  bool DoneWritingDeclsAndTypes = false;
165 
166  /// Indicates that the AST contained compiler errors.
167  bool ASTHasCompilerErrors = false;
168 
169  /// Mapping from input file entries to the index into the
170  /// offset table where information about that input file is stored.
171  llvm::DenseMap<const FileEntry *, uint32_t> InputFileIDs;
172 
173  /// Stores a declaration or a type to be written to the AST file.
174  class DeclOrType {
175  public:
176  DeclOrType(Decl *D) : Stored(D), IsType(false) {}
177  DeclOrType(QualType T) : Stored(T.getAsOpaquePtr()), IsType(true) {}
178 
179  bool isType() const { return IsType; }
180  bool isDecl() const { return !IsType; }
181 
182  QualType getType() const {
183  assert(isType() && "Not a type!");
184  return QualType::getFromOpaquePtr(Stored);
185  }
186 
187  Decl *getDecl() const {
188  assert(isDecl() && "Not a decl!");
189  return static_cast<Decl *>(Stored);
190  }
191 
192  private:
193  void *Stored;
194  bool IsType;
195  };
196 
197  /// The declarations and types to emit.
198  std::queue<DeclOrType> DeclTypesToEmit;
199 
200  /// The first ID number we can use for our own declarations.
202 
203  /// The decl ID that will be assigned to the next new decl.
204  serialization::DeclID NextDeclID = FirstDeclID;
205 
206  /// Map that provides the ID numbers of each declaration within
207  /// the output stream, as well as those deserialized from a chained PCH.
208  ///
209  /// The ID numbers of declarations are consecutive (in order of
210  /// discovery) and start at 2. 1 is reserved for the translation
211  /// unit, while 0 is reserved for NULL.
212  llvm::DenseMap<const Decl *, serialization::DeclID> DeclIDs;
213 
214  /// Offset of each declaration in the bitstream, indexed by
215  /// the declaration's ID.
216  std::vector<serialization::DeclOffset> DeclOffsets;
217 
218  /// Sorted (by file offset) vector of pairs of file offset/DeclID.
219  using LocDeclIDsTy =
221  struct DeclIDInFileInfo {
222  LocDeclIDsTy DeclIDs;
223 
224  /// Set when the DeclIDs vectors from all files are joined, this
225  /// indicates the index that this particular vector has in the global one.
226  unsigned FirstDeclIndex;
227  };
228  using FileDeclIDsTy = llvm::DenseMap<FileID, DeclIDInFileInfo *>;
229 
230  /// Map from file SLocEntries to info about the file-level declarations
231  /// that it contains.
232  FileDeclIDsTy FileDeclIDs;
233 
234  void associateDeclWithFile(const Decl *D, serialization::DeclID);
235 
236  /// The first ID number we can use for our own types.
238 
239  /// The type ID that will be assigned to the next new type.
240  serialization::TypeID NextTypeID = FirstTypeID;
241 
242  /// Map that provides the ID numbers of each type within the
243  /// output stream, plus those deserialized from a chained PCH.
244  ///
245  /// The ID numbers of types are consecutive (in order of discovery)
246  /// and start at 1. 0 is reserved for NULL. When types are actually
247  /// stored in the stream, the ID number is shifted by 2 bits to
248  /// allow for the const/volatile qualifiers.
249  ///
250  /// Keys in the map never have const/volatile qualifiers.
251  TypeIdxMap TypeIdxs;
252 
253  /// Offset of each type in the bitstream, indexed by
254  /// the type's ID.
255  std::vector<uint32_t> TypeOffsets;
256 
257  /// The first ID number we can use for our own identifiers.
259 
260  /// The identifier ID that will be assigned to the next new identifier.
261  serialization::IdentID NextIdentID = FirstIdentID;
262 
263  /// Map that provides the ID numbers of each identifier in
264  /// the output stream.
265  ///
266  /// The ID numbers for identifiers are consecutive (in order of
267  /// discovery), starting at 1. An ID of zero refers to a NULL
268  /// IdentifierInfo.
269  llvm::MapVector<const IdentifierInfo *, serialization::IdentID> IdentifierIDs;
270 
271  /// The first ID number we can use for our own macros.
273 
274  /// The identifier ID that will be assigned to the next new identifier.
275  serialization::MacroID NextMacroID = FirstMacroID;
276 
277  /// Map that provides the ID numbers of each macro.
278  llvm::DenseMap<MacroInfo *, serialization::MacroID> MacroIDs;
279 
280  struct MacroInfoToEmitData {
281  const IdentifierInfo *Name;
282  MacroInfo *MI;
284  };
285 
286  /// The macro infos to emit.
287  std::vector<MacroInfoToEmitData> MacroInfosToEmit;
288 
289  llvm::DenseMap<const IdentifierInfo *, uint64_t> IdentMacroDirectivesOffsetMap;
290 
291  /// @name FlushStmt Caches
292  /// @{
293 
294  /// Set of parent Stmts for the currently serializing sub-stmt.
295  llvm::DenseSet<Stmt *> ParentStmts;
296 
297  /// Offsets of sub-stmts already serialized. The offset points
298  /// just after the stmt record.
299  llvm::DenseMap<Stmt *, uint64_t> SubStmtEntries;
300 
301  /// @}
302 
303  /// Offsets of each of the identifier IDs into the identifier
304  /// table.
305  std::vector<uint32_t> IdentifierOffsets;
306 
307  /// The first ID number we can use for our own submodules.
308  serialization::SubmoduleID FirstSubmoduleID =
310 
311  /// The submodule ID that will be assigned to the next new submodule.
312  serialization::SubmoduleID NextSubmoduleID = FirstSubmoduleID;
313 
314  /// The first ID number we can use for our own selectors.
315  serialization::SelectorID FirstSelectorID =
317 
318  /// The selector ID that will be assigned to the next new selector.
319  serialization::SelectorID NextSelectorID = FirstSelectorID;
320 
321  /// Map that provides the ID numbers of each Selector.
322  llvm::MapVector<Selector, serialization::SelectorID> SelectorIDs;
323 
324  /// Offset of each selector within the method pool/selector
325  /// table, indexed by the Selector ID (-1).
326  std::vector<uint32_t> SelectorOffsets;
327 
328  /// Mapping from macro definitions (as they occur in the preprocessing
329  /// record) to the macro IDs.
330  llvm::DenseMap<const MacroDefinitionRecord *,
331  serialization::PreprocessedEntityID> MacroDefinitions;
332 
333  /// Cache of indices of anonymous declarations within their lexical
334  /// contexts.
335  llvm::DenseMap<const Decl *, unsigned> AnonymousDeclarationNumbers;
336 
337  /// An update to a Decl.
338  class DeclUpdate {
339  /// A DeclUpdateKind.
340  unsigned Kind;
341  union {
342  const Decl *Dcl;
343  void *Type;
344  unsigned Loc;
345  unsigned Val;
346  Module *Mod;
347  const Attr *Attribute;
348  };
349 
350  public:
351  DeclUpdate(unsigned Kind) : Kind(Kind), Dcl(nullptr) {}
352  DeclUpdate(unsigned Kind, const Decl *Dcl) : Kind(Kind), Dcl(Dcl) {}
353  DeclUpdate(unsigned Kind, QualType Type)
354  : Kind(Kind), Type(Type.getAsOpaquePtr()) {}
355  DeclUpdate(unsigned Kind, SourceLocation Loc)
356  : Kind(Kind), Loc(Loc.getRawEncoding()) {}
357  DeclUpdate(unsigned Kind, unsigned Val) : Kind(Kind), Val(Val) {}
358  DeclUpdate(unsigned Kind, Module *M) : Kind(Kind), Mod(M) {}
359  DeclUpdate(unsigned Kind, const Attr *Attribute)
360  : Kind(Kind), Attribute(Attribute) {}
361 
362  unsigned getKind() const { return Kind; }
363  const Decl *getDecl() const { return Dcl; }
364  QualType getType() const { return QualType::getFromOpaquePtr(Type); }
365 
366  SourceLocation getLoc() const {
367  return SourceLocation::getFromRawEncoding(Loc);
368  }
369 
370  unsigned getNumber() const { return Val; }
371  Module *getModule() const { return Mod; }
372  const Attr *getAttr() const { return Attribute; }
373  };
374 
376  using DeclUpdateMap = llvm::MapVector<const Decl *, UpdateRecord>;
377 
378  /// Mapping from declarations that came from a chained PCH to the
379  /// record containing modifications to them.
380  DeclUpdateMap DeclUpdates;
381 
382  using FirstLatestDeclMap = llvm::DenseMap<Decl *, Decl *>;
383 
384  /// Map of first declarations from a chained PCH that point to the
385  /// most recent declarations in another PCH.
386  FirstLatestDeclMap FirstLatestDecls;
387 
388  /// Declarations encountered that might be external
389  /// definitions.
390  ///
391  /// We keep track of external definitions and other 'interesting' declarations
392  /// as we are emitting declarations to the AST file. The AST file contains a
393  /// separate record for these declarations, which are provided to the AST
394  /// consumer by the AST reader. This is behavior is required to properly cope with,
395  /// e.g., tentative variable definitions that occur within
396  /// headers. The declarations themselves are stored as declaration
397  /// IDs, since they will be written out to an EAGERLY_DESERIALIZED_DECLS
398  /// record.
399  SmallVector<uint64_t, 16> EagerlyDeserializedDecls;
400  SmallVector<uint64_t, 16> ModularCodegenDecls;
401 
402  /// DeclContexts that have received extensions since their serialized
403  /// form.
404  ///
405  /// For namespaces, when we're chaining and encountering a namespace, we check
406  /// if its primary namespace comes from the chain. If it does, we add the
407  /// primary to this set, so that we can write out lexical content updates for
408  /// it.
410 
411  /// Keeps track of declarations that we must emit, even though we're
412  /// not guaranteed to be able to find them by walking the AST starting at the
413  /// translation unit.
414  SmallVector<const Decl *, 16> DeclsToEmitEvenIfUnreferenced;
415 
416  /// The set of Objective-C class that have categories we
417  /// should serialize.
418  llvm::SetVector<ObjCInterfaceDecl *> ObjCClassesWithCategories;
419 
420  /// The set of declarations that may have redeclaration chains that
421  /// need to be serialized.
423 
424  /// A cache of the first local declaration for "interesting"
425  /// redeclaration chains.
426  llvm::DenseMap<const Decl *, const Decl *> FirstLocalDeclCache;
427 
428  /// Mapping from SwitchCase statements to IDs.
429  llvm::DenseMap<SwitchCase *, unsigned> SwitchCaseIDs;
430 
431  /// The number of statements written to the AST file.
432  unsigned NumStatements = 0;
433 
434  /// The number of macros written to the AST file.
435  unsigned NumMacros = 0;
436 
437  /// The number of lexical declcontexts written to the AST
438  /// file.
439  unsigned NumLexicalDeclContexts = 0;
440 
441  /// The number of visible declcontexts written to the AST
442  /// file.
443  unsigned NumVisibleDeclContexts = 0;
444 
445  /// A mapping from each known submodule to its ID number, which will
446  /// be a positive integer.
447  llvm::DenseMap<Module *, unsigned> SubmoduleIDs;
448 
449  /// A list of the module file extension writers.
450  std::vector<std::unique_ptr<ModuleFileExtensionWriter>>
451  ModuleFileExtensionWriters;
452 
453  /// Retrieve or create a submodule ID for this module.
454  unsigned getSubmoduleID(Module *Mod);
455 
456  /// Write the given subexpression to the bitstream.
457  void WriteSubStmt(Stmt *S);
458 
459  void WriteBlockInfoBlock();
460  void WriteControlBlock(Preprocessor &PP, ASTContext &Context,
461  StringRef isysroot, const std::string &OutputFile);
462 
463  /// Write out the signature and diagnostic options, and return the signature.
464  ASTFileSignature writeUnhashedControlBlock(Preprocessor &PP,
465  ASTContext &Context);
466 
467  /// Calculate hash of the pcm content.
468  static ASTFileSignature createSignature(StringRef Bytes);
469 
470  void WriteInputFiles(SourceManager &SourceMgr, HeaderSearchOptions &HSOpts,
471  bool Modules);
472  void WriteSourceManagerBlock(SourceManager &SourceMgr,
473  const Preprocessor &PP);
474  void WritePreprocessor(const Preprocessor &PP, bool IsModule);
475  void WriteHeaderSearch(const HeaderSearch &HS);
476  void WritePreprocessorDetail(PreprocessingRecord &PPRec);
477  void WriteSubmodules(Module *WritingModule);
478 
479  void WritePragmaDiagnosticMappings(const DiagnosticsEngine &Diag,
480  bool isModule);
481 
482  unsigned TypeExtQualAbbrev = 0;
483  unsigned TypeFunctionProtoAbbrev = 0;
484  void WriteTypeAbbrevs();
485  void WriteType(QualType T);
486 
487  bool isLookupResultExternal(StoredDeclsList &Result, DeclContext *DC);
488  bool isLookupResultEntirelyExternal(StoredDeclsList &Result, DeclContext *DC);
489 
490  void GenerateNameLookupTable(const DeclContext *DC,
491  llvm::SmallVectorImpl<char> &LookupTable);
492  uint64_t WriteDeclContextLexicalBlock(ASTContext &Context, DeclContext *DC);
493  uint64_t WriteDeclContextVisibleBlock(ASTContext &Context, DeclContext *DC);
494  void WriteTypeDeclOffsets();
495  void WriteFileDeclIDsMap();
496  void WriteComments();
497  void WriteSelectors(Sema &SemaRef);
498  void WriteReferencedSelectorsPool(Sema &SemaRef);
499  void WriteIdentifierTable(Preprocessor &PP, IdentifierResolver &IdResolver,
500  bool IsModule);
501  void WriteDeclUpdatesBlocks(RecordDataImpl &OffsetsRecord);
502  void WriteDeclContextVisibleUpdate(const DeclContext *DC);
503  void WriteFPPragmaOptions(const FPOptions &Opts);
504  void WriteOpenCLExtensions(Sema &SemaRef);
505  void WriteOpenCLExtensionTypes(Sema &SemaRef);
506  void WriteOpenCLExtensionDecls(Sema &SemaRef);
507  void WriteCUDAPragmas(Sema &SemaRef);
508  void WriteObjCCategories();
509  void WriteLateParsedTemplates(Sema &SemaRef);
510  void WriteOptimizePragmaOptions(Sema &SemaRef);
511  void WriteMSStructPragmaOptions(Sema &SemaRef);
512  void WriteMSPointersToMembersPragmaOptions(Sema &SemaRef);
513  void WritePackPragmaOptions(Sema &SemaRef);
514  void WriteModuleFileExtension(Sema &SemaRef,
515  ModuleFileExtensionWriter &Writer);
516 
517  unsigned DeclParmVarAbbrev = 0;
518  unsigned DeclContextLexicalAbbrev = 0;
519  unsigned DeclContextVisibleLookupAbbrev = 0;
520  unsigned UpdateVisibleAbbrev = 0;
521  unsigned DeclRecordAbbrev = 0;
522  unsigned DeclTypedefAbbrev = 0;
523  unsigned DeclVarAbbrev = 0;
524  unsigned DeclFieldAbbrev = 0;
525  unsigned DeclEnumAbbrev = 0;
526  unsigned DeclObjCIvarAbbrev = 0;
527  unsigned DeclCXXMethodAbbrev = 0;
528 
529  unsigned DeclRefExprAbbrev = 0;
530  unsigned CharacterLiteralAbbrev = 0;
531  unsigned IntegerLiteralAbbrev = 0;
532  unsigned ExprImplicitCastAbbrev = 0;
533 
534  void WriteDeclAbbrevs();
535  void WriteDecl(ASTContext &Context, Decl *D);
536 
537  ASTFileSignature WriteASTCore(Sema &SemaRef, StringRef isysroot,
538  const std::string &OutputFile,
539  Module *WritingModule);
540 
541 public:
542  /// Create a new precompiled header writer that outputs to
543  /// the given bitstream.
544  ASTWriter(llvm::BitstreamWriter &Stream, SmallVectorImpl<char> &Buffer,
545  InMemoryModuleCache &ModuleCache,
546  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
547  bool IncludeTimestamps = true);
548  ~ASTWriter() override;
549 
550  const LangOptions &getLangOpts() const;
551 
552  /// Get a timestamp for output into the AST file. The actual timestamp
553  /// of the specified file may be ignored if we have been instructed to not
554  /// include timestamps in the output file.
555  time_t getTimestampForOutput(const FileEntry *E) const;
556 
557  /// Write a precompiled header for the given semantic analysis.
558  ///
559  /// \param SemaRef a reference to the semantic analysis object that processed
560  /// the AST to be written into the precompiled header.
561  ///
562  /// \param WritingModule The module that we are writing. If null, we are
563  /// writing a precompiled header.
564  ///
565  /// \param isysroot if non-empty, write a relocatable file whose headers
566  /// are relative to the given system root. If we're writing a module, its
567  /// build directory will be used in preference to this if both are available.
568  ///
569  /// \return the module signature, which eventually will be a hash of
570  /// the module but currently is merely a random 32-bit number.
571  ASTFileSignature WriteAST(Sema &SemaRef, const std::string &OutputFile,
572  Module *WritingModule, StringRef isysroot,
573  bool hasErrors = false,
574  bool ShouldCacheASTInMemory = false);
575 
576  /// Emit a token.
577  void AddToken(const Token &Tok, RecordDataImpl &Record);
578 
579  /// Emit a source location.
580  void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record);
581 
582  /// Emit a source range.
583  void AddSourceRange(SourceRange Range, RecordDataImpl &Record);
584 
585  /// Emit a reference to an identifier.
586  void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record);
587 
588  /// Get the unique number used to refer to the given selector.
589  serialization::SelectorID getSelectorRef(Selector Sel);
590 
591  /// Get the unique number used to refer to the given identifier.
592  serialization::IdentID getIdentifierRef(const IdentifierInfo *II);
593 
594  /// Get the unique number used to refer to the given macro.
595  serialization::MacroID getMacroRef(MacroInfo *MI, const IdentifierInfo *Name);
596 
597  /// Determine the ID of an already-emitted macro.
598  serialization::MacroID getMacroID(MacroInfo *MI);
599 
600  uint64_t getMacroDirectivesOffset(const IdentifierInfo *Name);
601 
602  /// Emit a reference to a type.
603  void AddTypeRef(QualType T, RecordDataImpl &Record);
604 
605  /// Force a type to be emitted and get its ID.
606  serialization::TypeID GetOrCreateTypeID(QualType T);
607 
608  /// Determine the type ID of an already-emitted type.
609  serialization::TypeID getTypeID(QualType T) const;
610 
611  /// Find the first local declaration of a given local redeclarable
612  /// decl.
613  const Decl *getFirstLocalDecl(const Decl *D);
614 
615  /// Is this a local declaration (that is, one that will be written to
616  /// our AST file)? This is the case for declarations that are neither imported
617  /// from another AST file nor predefined.
618  bool IsLocalDecl(const Decl *D) {
619  if (D->isFromASTFile())
620  return false;
621  auto I = DeclIDs.find(D);
622  return (I == DeclIDs.end() ||
624  };
625 
626  /// Emit a reference to a declaration.
627  void AddDeclRef(const Decl *D, RecordDataImpl &Record);
628 
629  /// Force a declaration to be emitted and get its ID.
630  serialization::DeclID GetDeclRef(const Decl *D);
631 
632  /// Determine the declaration ID of an already-emitted
633  /// declaration.
634  serialization::DeclID getDeclID(const Decl *D);
635 
636  unsigned getAnonymousDeclarationNumber(const NamedDecl *D);
637 
638  /// Add a string to the given record.
639  void AddString(StringRef Str, RecordDataImpl &Record);
640 
641  /// Convert a path from this build process into one that is appropriate
642  /// for emission in the module file.
643  bool PreparePathForOutput(SmallVectorImpl<char> &Path);
644 
645  /// Add a path to the given record.
646  void AddPath(StringRef Path, RecordDataImpl &Record);
647 
648  /// Emit the current record with the given path as a blob.
649  void EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record,
650  StringRef Path);
651 
652  /// Add a version tuple to the given record
653  void AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record);
654 
655  /// Retrieve or create a submodule ID for this module, or return 0 if
656  /// the submodule is neither local (a submodle of the currently-written module)
657  /// nor from an imported module.
658  unsigned getLocalOrImportedSubmoduleID(Module *Mod);
659 
660  /// Note that the identifier II occurs at the given offset
661  /// within the identifier table.
662  void SetIdentifierOffset(const IdentifierInfo *II, uint32_t Offset);
663 
664  /// Note that the selector Sel occurs at the given offset
665  /// within the method pool/selector table.
666  void SetSelectorOffset(Selector Sel, uint32_t Offset);
667 
668  /// Record an ID for the given switch-case statement.
669  unsigned RecordSwitchCaseID(SwitchCase *S);
670 
671  /// Retrieve the ID for the given switch-case statement.
672  unsigned getSwitchCaseID(SwitchCase *S);
673 
674  void ClearSwitchCaseIDs();
675 
676  unsigned getTypeExtQualAbbrev() const {
677  return TypeExtQualAbbrev;
678  }
679 
680  unsigned getTypeFunctionProtoAbbrev() const {
681  return TypeFunctionProtoAbbrev;
682  }
683 
684  unsigned getDeclParmVarAbbrev() const { return DeclParmVarAbbrev; }
685  unsigned getDeclRecordAbbrev() const { return DeclRecordAbbrev; }
686  unsigned getDeclTypedefAbbrev() const { return DeclTypedefAbbrev; }
687  unsigned getDeclVarAbbrev() const { return DeclVarAbbrev; }
688  unsigned getDeclFieldAbbrev() const { return DeclFieldAbbrev; }
689  unsigned getDeclEnumAbbrev() const { return DeclEnumAbbrev; }
690  unsigned getDeclObjCIvarAbbrev() const { return DeclObjCIvarAbbrev; }
691  unsigned getDeclCXXMethodAbbrev() const { return DeclCXXMethodAbbrev; }
692 
693  unsigned getDeclRefExprAbbrev() const { return DeclRefExprAbbrev; }
694  unsigned getCharacterLiteralAbbrev() const { return CharacterLiteralAbbrev; }
695  unsigned getIntegerLiteralAbbrev() const { return IntegerLiteralAbbrev; }
696  unsigned getExprImplicitCastAbbrev() const { return ExprImplicitCastAbbrev; }
697 
698  bool hasChain() const { return Chain; }
699  ASTReader *getChain() const { return Chain; }
700 
701 private:
702  // ASTDeserializationListener implementation
703  void ReaderInitialized(ASTReader *Reader) override;
704  void IdentifierRead(serialization::IdentID ID, IdentifierInfo *II) override;
705  void MacroRead(serialization::MacroID ID, MacroInfo *MI) override;
706  void TypeRead(serialization::TypeIdx Idx, QualType T) override;
707  void SelectorRead(serialization::SelectorID ID, Selector Sel) override;
708  void MacroDefinitionRead(serialization::PreprocessedEntityID ID,
709  MacroDefinitionRecord *MD) override;
710  void ModuleRead(serialization::SubmoduleID ID, Module *Mod) override;
711 
712  // ASTMutationListener implementation.
713  void CompletedTagDefinition(const TagDecl *D) override;
714  void AddedVisibleDecl(const DeclContext *DC, const Decl *D) override;
715  void AddedCXXImplicitMember(const CXXRecordDecl *RD, const Decl *D) override;
716  void AddedCXXTemplateSpecialization(
717  const ClassTemplateDecl *TD,
718  const ClassTemplateSpecializationDecl *D) override;
719  void AddedCXXTemplateSpecialization(
720  const VarTemplateDecl *TD,
721  const VarTemplateSpecializationDecl *D) override;
722  void AddedCXXTemplateSpecialization(const FunctionTemplateDecl *TD,
723  const FunctionDecl *D) override;
724  void ResolvedExceptionSpec(const FunctionDecl *FD) override;
725  void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType) override;
726  void ResolvedOperatorDelete(const CXXDestructorDecl *DD,
727  const FunctionDecl *Delete,
728  Expr *ThisArg) override;
729  void CompletedImplicitDefinition(const FunctionDecl *D) override;
730  void InstantiationRequested(const ValueDecl *D) override;
731  void VariableDefinitionInstantiated(const VarDecl *D) override;
732  void FunctionDefinitionInstantiated(const FunctionDecl *D) override;
733  void DefaultArgumentInstantiated(const ParmVarDecl *D) override;
734  void DefaultMemberInitializerInstantiated(const FieldDecl *D) override;
735  void AddedObjCCategoryToInterface(const ObjCCategoryDecl *CatD,
736  const ObjCInterfaceDecl *IFD) override;
737  void DeclarationMarkedUsed(const Decl *D) override;
738  void DeclarationMarkedOpenMPThreadPrivate(const Decl *D) override;
739  void DeclarationMarkedOpenMPDeclareTarget(const Decl *D,
740  const Attr *Attr) override;
741  void DeclarationMarkedOpenMPAllocate(const Decl *D, const Attr *A) override;
742  void RedefinedHiddenDefinition(const NamedDecl *D, Module *M) override;
743  void AddedAttributeToRecord(const Attr *Attr,
744  const RecordDecl *Record) override;
745 };
746 
747 /// An object for streaming information to a record.
749  ASTWriter *Writer;
751 
752  /// Statements that we've encountered while serializing a
753  /// declaration or type.
754  SmallVector<Stmt *, 16> StmtsToEmit;
755 
756  /// Indices of record elements that describe offsets within the
757  /// bitcode. These will be converted to offsets relative to the current
758  /// record when emitted.
759  SmallVector<unsigned, 8> OffsetIndices;
760 
761  /// Flush all of the statements and expressions that have
762  /// been added to the queue via AddStmt().
763  void FlushStmts();
764  void FlushSubStmts();
765 
766  void PrepareToEmit(uint64_t MyOffset) {
767  // Convert offsets into relative form.
768  for (unsigned I : OffsetIndices) {
769  auto &StoredOffset = (*Record)[I];
770  assert(StoredOffset < MyOffset && "invalid offset");
771  if (StoredOffset)
772  StoredOffset = MyOffset - StoredOffset;
773  }
774  OffsetIndices.clear();
775  }
776 
777 public:
778  /// Construct a ASTRecordWriter that uses the default encoding scheme.
780  : Writer(&Writer), Record(&Record) {}
781 
782  /// Construct a ASTRecordWriter that uses the same encoding scheme as another
783  /// ASTRecordWriter.
785  : Writer(Parent.Writer), Record(&Record) {}
786 
787  /// Copying an ASTRecordWriter is almost certainly a bug.
788  ASTRecordWriter(const ASTRecordWriter &) = delete;
789  ASTRecordWriter &operator=(const ASTRecordWriter &) = delete;
790 
791  /// Extract the underlying record storage.
792  ASTWriter::RecordDataImpl &getRecordData() const { return *Record; }
793 
794  /// Minimal vector-like interface.
795  /// @{
796  void push_back(uint64_t N) { Record->push_back(N); }
797  template<typename InputIterator>
798  void append(InputIterator begin, InputIterator end) {
799  Record->append(begin, end);
800  }
801  bool empty() const { return Record->empty(); }
802  size_t size() const { return Record->size(); }
803  uint64_t &operator[](size_t N) { return (*Record)[N]; }
804  /// @}
805 
806  /// Emit the record to the stream, followed by its substatements, and
807  /// return its offset.
808  // FIXME: Allow record producers to suggest Abbrevs.
809  uint64_t Emit(unsigned Code, unsigned Abbrev = 0) {
810  uint64_t Offset = Writer->Stream.GetCurrentBitNo();
811  PrepareToEmit(Offset);
812  Writer->Stream.EmitRecord(Code, *Record, Abbrev);
813  FlushStmts();
814  return Offset;
815  }
816 
817  /// Emit the record to the stream, preceded by its substatements.
818  uint64_t EmitStmt(unsigned Code, unsigned Abbrev = 0) {
819  FlushSubStmts();
820  PrepareToEmit(Writer->Stream.GetCurrentBitNo());
821  Writer->Stream.EmitRecord(Code, *Record, Abbrev);
822  return Writer->Stream.GetCurrentBitNo();
823  }
824 
825  /// Add a bit offset into the record. This will be converted into an
826  /// offset relative to the current record when emitted.
827  void AddOffset(uint64_t BitOffset) {
828  OffsetIndices.push_back(Record->size());
829  Record->push_back(BitOffset);
830  }
831 
832  /// Add the given statement or expression to the queue of
833  /// statements to emit.
834  ///
835  /// This routine should be used when emitting types and declarations
836  /// that have expressions as part of their formulation. Once the
837  /// type or declaration has been written, Emit() will write
838  /// the corresponding statements just after the record.
839  void AddStmt(Stmt *S) {
840  StmtsToEmit.push_back(S);
841  }
842 
843  /// Add a definition for the given function to the queue of statements
844  /// to emit.
845  void AddFunctionDefinition(const FunctionDecl *FD);
846 
847  /// Emit a source location.
849  return Writer->AddSourceLocation(Loc, *Record);
850  }
851 
852  /// Emit a source range.
854  return Writer->AddSourceRange(Range, *Record);
855  }
856 
857  /// Emit an integral value.
858  void AddAPInt(const llvm::APInt &Value);
859 
860  /// Emit a signed integral value.
861  void AddAPSInt(const llvm::APSInt &Value);
862 
863  /// Emit a floating-point value.
864  void AddAPFloat(const llvm::APFloat &Value);
865 
866  /// Emit an APvalue.
867  void AddAPValue(const APValue &Value);
868 
869  /// Emit a reference to an identifier.
871  return Writer->AddIdentifierRef(II, *Record);
872  }
873 
874  /// Emit a Selector (which is a smart pointer reference).
875  void AddSelectorRef(Selector S);
876 
877  /// Emit a CXXTemporary.
878  void AddCXXTemporary(const CXXTemporary *Temp);
879 
880  /// Emit a C++ base specifier.
881  void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base);
882 
883  /// Emit a set of C++ base specifiers.
884  void AddCXXBaseSpecifiers(ArrayRef<CXXBaseSpecifier> Bases);
885 
886  /// Emit a reference to a type.
888  return Writer->AddTypeRef(T, *Record);
889  }
890 
891  /// Emits a reference to a declarator info.
892  void AddTypeSourceInfo(TypeSourceInfo *TInfo);
893 
894  /// Emits source location information for a type. Does not emit the type.
895  void AddTypeLoc(TypeLoc TL);
896 
897  /// Emits a template argument location info.
898  void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
899  const TemplateArgumentLocInfo &Arg);
900 
901  /// Emits a template argument location.
902  void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg);
903 
904  /// Emits an AST template argument list info.
905  void AddASTTemplateArgumentListInfo(
906  const ASTTemplateArgumentListInfo *ASTTemplArgList);
907 
908  /// Emit a reference to a declaration.
909  void AddDeclRef(const Decl *D) {
910  return Writer->AddDeclRef(D, *Record);
911  }
912 
913  /// Emit a declaration name.
914  void AddDeclarationName(DeclarationName Name);
915 
916  void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
917  DeclarationName Name);
918  void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
919 
920  void AddQualifierInfo(const QualifierInfo &Info);
921 
922  /// Emit a nested name specifier.
923  void AddNestedNameSpecifier(NestedNameSpecifier *NNS);
924 
925  /// Emit a nested name specifier with source-location information.
926  void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
927 
928  /// Emit a template name.
929  void AddTemplateName(TemplateName Name);
930 
931  /// Emit a template argument.
932  void AddTemplateArgument(const TemplateArgument &Arg);
933 
934  /// Emit a template parameter list.
935  void AddTemplateParameterList(const TemplateParameterList *TemplateParams);
936 
937  /// Emit a template argument list.
938  void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs);
939 
940  /// Emit a UnresolvedSet structure.
941  void AddUnresolvedSet(const ASTUnresolvedSet &Set);
942 
943  /// Emit a CXXCtorInitializer array.
944  void AddCXXCtorInitializers(ArrayRef<CXXCtorInitializer *> CtorInits);
945 
946  void AddCXXDefinitionData(const CXXRecordDecl *D);
947 
948  /// Emit a string.
949  void AddString(StringRef Str) {
950  return Writer->AddString(Str, *Record);
951  }
952 
953  /// Emit a path.
954  void AddPath(StringRef Path) {
955  return Writer->AddPath(Path, *Record);
956  }
957 
958  /// Emit a version tuple.
959  void AddVersionTuple(const VersionTuple &Version) {
960  return Writer->AddVersionTuple(Version, *Record);
961  }
962 
963  // Emit an attribute.
964  void AddAttr(const Attr *A);
965 
966  /// Emit a list of attributes.
967  void AddAttributes(ArrayRef<const Attr*> Attrs);
968 };
969 
970 /// AST and semantic-analysis consumer that generates a
971 /// precompiled header from the parsed source code.
972 class PCHGenerator : public SemaConsumer {
973  const Preprocessor &PP;
974  std::string OutputFile;
975  std::string isysroot;
976  Sema *SemaPtr;
977  std::shared_ptr<PCHBuffer> Buffer;
978  llvm::BitstreamWriter Stream;
979  ASTWriter Writer;
980  bool AllowASTWithErrors;
981  bool ShouldCacheASTInMemory;
982 
983 protected:
984  ASTWriter &getWriter() { return Writer; }
985  const ASTWriter &getWriter() const { return Writer; }
986  SmallVectorImpl<char> &getPCH() const { return Buffer->Data; }
987 
988 public:
989  PCHGenerator(const Preprocessor &PP, InMemoryModuleCache &ModuleCache,
990  StringRef OutputFile, StringRef isysroot,
991  std::shared_ptr<PCHBuffer> Buffer,
992  ArrayRef<std::shared_ptr<ModuleFileExtension>> Extensions,
993  bool AllowASTWithErrors = false, bool IncludeTimestamps = true,
994  bool ShouldCacheASTInMemory = false);
995  ~PCHGenerator() override;
996 
997  void InitializeSema(Sema &S) override { SemaPtr = &S; }
998  void HandleTranslationUnit(ASTContext &Ctx) override;
999  ASTMutationListener *GetASTMutationListener() override;
1000  ASTDeserializationListener *GetASTDeserializationListener() override;
1001  bool hasEmittedPCH() const { return Buffer->IsComplete; }
1002 };
1003 
1004 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
1005  ASTRecordWriter &Record;
1006 
1007 public:
1008  OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {}
1009 #define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *S);
1010 #include "clang/Basic/OpenMPKinds.def"
1011  void writeClause(OMPClause *C);
1012  void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
1013  void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
1014 };
1015 
1016 } // namespace clang
1017 
1018 #endif // LLVM_CLANG_SERIALIZATION_ASTWRITER_H
unsigned getDeclEnumAbbrev() const
Definition: ASTWriter.h:689
Represents a function declaration or definition.
Definition: Decl.h:1748
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Smart pointer class that efficiently represents Objective-C method names.
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
A (possibly-)qualified type.
Definition: Type.h:643
Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion...
Definition: Dominators.h:30
A structure for putting "fast"-unqualified QualTypes into a DenseMap.
Definition: ASTBitCodes.h:114
const unsigned NUM_PREDEF_TYPE_IDS
The number of predefined type IDs that are reserved for the PREDEF_TYPE_* constants.
Definition: ASTBitCodes.h:1028
Stmt - This represents one statement.
Definition: Stmt.h:66
C Language Family Type Representation.
void InitializeSema(Sema &S) override
Initialize the semantic consumer with the Sema instance being used to perform semantic analysis on th...
Definition: ASTWriter.h:997
const unsigned int NUM_PREDEF_SELECTOR_IDS
The number of predefined selector IDs.
Definition: ASTBitCodes.h:156
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
uint64_t & operator[](size_t N)
Definition: ASTWriter.h:803
The base class of the type hierarchy.
Definition: Type.h:1433
Declaration of a variable template.
A container of type source information.
Definition: Decl.h:86
Floating point control options.
Definition: LangOptions.h:307
void AddTypeRef(QualType T, RecordDataImpl &Record)
Emit a reference to a type.
Definition: ASTWriter.cpp:5584
unsigned getDeclRefExprAbbrev() const
Definition: ASTWriter.h:693
uint64_t Emit(unsigned Code, unsigned Abbrev=0)
Emit the record to the stream, followed by its substatements, and return its offset.
Definition: ASTWriter.h:809
Represents a variable declaration or definition.
Definition: Decl.h:812
const unsigned int NUM_PREDEF_DECL_IDS
The number of declaration IDs that are predefined.
Definition: ASTBitCodes.h:1279
Represents a variable template specialization, which refers to a variable template with a given set o...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:603
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:67
SmallVectorImpl< char > & getPCH() const
Definition: ASTWriter.h:986
Represents a parameter to a function.
Definition: Decl.h:1564
const ASTWriter & getWriter() const
Definition: ASTWriter.h:985
void AddString(StringRef Str)
Emit a string.
Definition: ASTWriter.h:949
void AddSourceRange(SourceRange Range)
Emit a source range.
Definition: ASTWriter.h:853
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
Definition: ASTWriter.cpp:5458
bool hasEmittedPCH() const
Definition: ASTWriter.h:1001
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
Represents a struct/union/class.
Definition: Decl.h:3626
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
ASTRecordWriter(ASTRecordWriter &Parent, ASTWriter::RecordDataImpl &Record)
Construct a ASTRecordWriter that uses the same encoding scheme as another ASTRecordWriter.
Definition: ASTWriter.h:784
void AddTypeRef(QualType T)
Emit a reference to a type.
Definition: ASTWriter.h:887
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
A C++ nested-name-specifier augmented with source location information.
Record the location of a macro definition.
Represents a member of a struct/union/class.
Definition: Decl.h:2607
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
ASTReader * getChain() const
Definition: ASTWriter.h:699
uint32_t MacroID
An ID number that refers to a macro in an AST file.
Definition: ASTBitCodes.h:140
The signature of a module, which is a hash of the AST content.
Definition: Module.h:54
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
Describes a module or submodule.
Definition: Module.h:64
unsigned getDeclFieldAbbrev() const
Definition: ASTWriter.h:688
void AddIdentifierRef(const IdentifierInfo *II)
Emit a reference to an identifier.
Definition: ASTWriter.h:870
An abstract interface that should be implemented by clients that read ASTs and then require further s...
Definition: SemaConsumer.h:25
ASTWriter::RecordDataImpl & getRecordData() const
Extract the underlying record storage.
Definition: ASTWriter.h:792
void append(InputIterator begin, InputIterator end)
Definition: ASTWriter.h:798
unsigned getIntegerLiteralAbbrev() const
Definition: ASTWriter.h:695
A record of the steps taken while preprocessing a source file, including the various preprocessing di...
const FormatToken & Tok
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
void AddSourceRange(SourceRange Range, RecordDataImpl &Record)
Emit a source range.
Definition: ASTWriter.cpp:5383
bool hasChain() const
Definition: ASTWriter.h:698
unsigned getCharacterLiteralAbbrev() const
Definition: ASTWriter.h:694
void * getAsOpaquePtr() const
Definition: Type.h:688
Represents an ObjC class declaration.
Definition: DeclObjC.h:1171
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:158
unsigned getTypeFunctionProtoAbbrev() const
Definition: ASTWriter.h:680
NodeId Parent
Definition: ASTDiff.cpp:191
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
void AddPath(StringRef Path, RecordDataImpl &Record)
Add a path to the given record.
Definition: ASTWriter.cpp:4570
unsigned Offset
Definition: Format.cpp:1714
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
This represents one expression.
Definition: Expr.h:108
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2838
ArgKind
The kind of template argument we&#39;re storing.
Definition: TemplateBase.h:53
unsigned getDeclRecordAbbrev() const
Definition: ASTWriter.h:685
IdentifierResolver - Keeps track of shadowed decls on enclosing scopes.
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
OMPClauseWriter(ASTRecordWriter &Record)
Definition: ASTWriter.h:1008
unsigned getDeclTypedefAbbrev() const
Definition: ASTWriter.h:686
Represents a C++ template name within the type system.
Definition: TemplateName.h:187
Defines the clang::TypeLoc interface and its subclasses.
void AddString(StringRef Str, RecordDataImpl &Record)
Add a string to the given record.
Definition: ASTWriter.cpp:4547
void AddPath(StringRef Path)
Emit a path.
Definition: ASTWriter.h:954
void AddDeclRef(const Decl *D)
Emit a reference to a declaration.
Definition: ASTWriter.h:909
void AddStmt(Stmt *S)
Add the given statement or expression to the queue of statements to emit.
Definition: ASTWriter.h:839
bool empty() const
Definition: ASTWriter.h:801
Abstract base class that writes a module file extension block into a module file. ...
This file defines OpenMP AST classes for clauses.
In-memory cache for modules.
void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record)
Emit a source location.
Definition: ASTWriter.cpp:5378
void push_back(uint64_t N)
Minimal vector-like interface.
Definition: ASTWriter.h:796
const unsigned int NUM_PREDEF_IDENT_IDS
The number of predefined identifier IDs.
Definition: ASTBitCodes.h:137
uint32_t SubmoduleID
An ID number that refers to a submodule in a module file.
Definition: ASTBitCodes.h:171
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
Definition: Decl.h:661
Kind
Encodes a location in the source.
unsigned getDeclVarAbbrev() const
Definition: ASTWriter.h:687
Represents a C++ temporary.
Definition: ExprCXX.h:1250
void AddOffset(uint64_t BitOffset)
Add a bit offset into the record.
Definition: ASTWriter.h:827
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3097
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2279
unsigned getDeclCXXMethodAbbrev() const
Definition: ASTWriter.h:691
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:702
uint32_t TypeID
An ID number that refers to a type in an AST file.
Definition: ASTBitCodes.h:85
void AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record)
Add a version tuple to the given record.
Definition: ASTWriter.cpp:4583
void AddSourceLocation(SourceLocation Loc)
Emit a source location.
Definition: ASTWriter.h:848
void AddDeclRef(const Decl *D, RecordDataImpl &Record)
Emit a reference to a declaration.
Definition: ASTWriter.cpp:5624
An array of decls optimized for the common case of only containing one entry.
uint32_t PreprocessedEntityID
An ID number that refers to an entity in the detailed preprocessing record.
Definition: ASTBitCodes.h:168
unsigned getExprImplicitCastAbbrev() const
Definition: ASTWriter.h:696
unsigned getTypeExtQualAbbrev() const
Definition: ASTWriter.h:676
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
Represents a template argument.
Definition: TemplateBase.h:50
uint32_t SelectorID
An ID number that refers to an ObjC selector in an AST file.
Definition: ASTBitCodes.h:153
Dataflow Directional Tag Classes.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
The name of a declaration.
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
unsigned getDeclParmVarAbbrev() const
Definition: ASTWriter.h:684
uint32_t DeclID
An ID number that refers to a declaration in an AST file.
Definition: ASTBitCodes.h:68
void AddVersionTuple(const VersionTuple &Version)
Emit a version tuple.
Definition: ASTWriter.h:959
bool IsLocalDecl(const Decl *D)
Is this a local declaration (that is, one that will be written to our AST file)? This is the case for...
Definition: ASTWriter.h:618
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
uint32_t IdentID
An ID number that refers to an identifier in an AST file.
Definition: ASTBitCodes.h:134
An UnresolvedSet-like class which uses the ASTContext&#39;s allocator.
const unsigned int NUM_PREDEF_MACRO_IDS
The number of predefined macro IDs.
Definition: ASTBitCodes.h:150
uint64_t EmitStmt(unsigned Code, unsigned Abbrev=0)
Emit the record to the stream, preceded by its substatements.
Definition: ASTWriter.h:818
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:76
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
A template argument list.
Definition: DeclTemplate.h:214
Defines the clang::SourceLocation class and associated facilities.
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
An object for streaming information to a record.
Definition: ASTWriter.h:748
Location information for a TemplateArgument.
Definition: TemplateBase.h:392
Declaration of a class template.
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:103
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:944
size_t size() const
Definition: ASTWriter.h:802
AST and semantic-analysis consumer that generates a precompiled header from the parsed source code...
Definition: ASTWriter.h:972
A trivial tuple used to represent a source range.
This represents a decl that may have a name.
Definition: Decl.h:248
ASTWriter & getWriter()
Definition: ASTWriter.h:984
unsigned getDeclObjCIvarAbbrev() const
Definition: ASTWriter.h:690
ASTRecordWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
Construct a ASTRecordWriter that uses the default encoding scheme.
Definition: ASTWriter.h:779
This class handles loading and caching of source files into memory.
Declaration of a template function.
A type index; the type ID with the qualifier bits removed.
Definition: ASTBitCodes.h:88
Attr - This represents one attribute.
Definition: Attr.h:43
const unsigned int NUM_PREDEF_SUBMODULE_IDS
The number of predefined submodule IDs.
Definition: ASTBitCodes.h:174
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:124