"Fossies" - the Fresh Open Source Software Archive

Member "cfe-9.0.0.src/include/clang/Serialization/ASTWriter.h" (3 Jul 2019, 37422 Bytes) of package /linux/misc/cfe-9.0.0.src.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. See also the latest Fossies "Diffs" side-by-side code changes report for "ASTWriter.h": 8.0.1_vs_9.0.0.

    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 
   17 #include "clang/AST/ASTMutationListener.h"
   18 #include "clang/AST/Decl.h"
   19 #include "clang/AST/DeclarationName.h"
   20 #include "clang/AST/NestedNameSpecifier.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"
   27 #include "clang/Basic/SourceLocation.h"
   28 #include "clang/Sema/SemaConsumer.h"
   29 #include "clang/Serialization/ASTBitCodes.h"
   30 #include "clang/Serialization/ASTDeserializationListener.h"
   31 #include "clang/Serialization/PCHContainerOperations.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.
  103 class ASTWriter : public ASTDeserializationListener,
  104                   public ASTMutationListener {
  105 public:
  106   friend class ASTDeclWriter;
  107   friend class ASTRecordWriter;
  108   friend class ASTStmtWriter;
  109   friend class ASTTypeWriter;
  110 
  111   using RecordData = SmallVector<uint64_t, 64>;
  112   using RecordDataImpl = SmallVectorImpl<uint64_t>;
  113   using RecordDataRef = ArrayRef<uint64_t>;
  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,
  126                                     serialization::UnsafeQualTypeDenseMapInfo>;
  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.
  201   serialization::DeclID FirstDeclID = serialization::NUM_PREDEF_DECL_IDS;
  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 =
  220       SmallVector<std::pair<unsigned, serialization::DeclID>, 64>;
  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.
  237   serialization::TypeID FirstTypeID = serialization::NUM_PREDEF_TYPE_IDS;
  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.
  258   serialization::IdentID FirstIdentID = serialization::NUM_PREDEF_IDENT_IDS;
  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.
  272   serialization::MacroID FirstMacroID = serialization::NUM_PREDEF_MACRO_IDS;
  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;
  283     serialization::MacroID ID;
  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 =
  309       serialization::NUM_PREDEF_SUBMODULE_IDS;
  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 =
  316       serialization::NUM_PREDEF_SELECTOR_IDS;
  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 
  375   using UpdateRecord = SmallVector<DeclUpdate, 1>;
  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.
  409   llvm::SmallSetVector<const DeclContext *, 16> UpdatedDeclContexts;
  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.
  422   llvm::SmallVector<const Decl *, 16> Redeclarations;
  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() ||
  623             I->second >= serialization::NUM_PREDEF_DECL_IDS);
  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.
  748 class ASTRecordWriter {
  749   ASTWriter *Writer;
  750   ASTWriter::RecordDataImpl *Record;
  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.
  779   ASTRecordWriter(ASTWriter &Writer, ASTWriter::RecordDataImpl &Record)
  780       : Writer(&Writer), Record(&Record) {}
  781 
  782   /// Construct a ASTRecordWriter that uses the same encoding scheme as another
  783   /// ASTRecordWriter.
  784   ASTRecordWriter(ASTRecordWriter &Parent, ASTWriter::RecordDataImpl &Record)
  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.
  848   void AddSourceLocation(SourceLocation Loc) {
  849     return Writer->AddSourceLocation(Loc, *Record);
  850   }
  851 
  852   /// Emit a source range.
  853   void AddSourceRange(SourceRange 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.
  870   void AddIdentifierRef(const IdentifierInfo *II) {
  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.
  887   void AddTypeRef(QualType T) {
  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