Home | History | Annotate | Line # | Download | only in Serialization 
      1 //===- ASTRecordWriter.h - Helper classes for writing AST -------*- C++ -*-===//
      2 //
      3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
      4 // See https://llvm.org/LICENSE.txt for license information.
      5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
      6 //
      7 //===----------------------------------------------------------------------===//
      8 //
      9 //  This file defines the ASTRecordWriter class, a helper class useful
     10 //  when serializing AST.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #ifndef LLVM_CLANG_SERIALIZATION_ASTRECORDWRITER_H
     15 #define LLVM_CLANG_SERIALIZATION_ASTRECORDWRITER_H
     16 
     17 #include "clang/AST/AbstractBasicWriter.h"
     18 #include "clang/AST/OpenMPClause.h"
     19 #include "clang/Serialization/ASTWriter.h"
     20 
     21 namespace clang {
     22 
     23 class TypeLoc;
     24 
     25 /// An object for streaming information to a record.
     26 class ASTRecordWriter
     27     : public serialization::DataStreamBasicWriter<ASTRecordWriter> {
     28   ASTWriter *Writer;
     29   ASTWriter::RecordDataImpl *Record;
     30 
     31   /// Statements that we've encountered while serializing a
     32   /// declaration or type.
     33   SmallVector<Stmt *, 16> StmtsToEmit;
     34 
     35   /// Indices of record elements that describe offsets within the
     36   /// bitcode. These will be converted to offsets relative to the current
     37   /// record when emitted.
     38   SmallVector<unsigned, 8> OffsetIndices;
     39 
     40   /// Flush all of the statements and expressions that have
     41   /// been added to the queue via AddStmt().
     42   void FlushStmts();
     43   void FlushSubStmts();
     44 
     45   void PrepareToEmit(uint64_t MyOffset) {
     46     // Convert offsets into relative form.
     47     for (unsigned I : OffsetIndices) {
     48       auto &StoredOffset = (*Record)[I];
     49       assert(StoredOffset < MyOffset && "invalid offset");
     50       if (StoredOffset)
     51         StoredOffset = MyOffset - StoredOffset;
     52     }
     53     OffsetIndices.clear();
     54   }
     55 
     56 public:
     57   /// Construct a ASTRecordWriter that uses the default encoding scheme.
     58   ASTRecordWriter(ASTWriter &W, ASTWriter::RecordDataImpl &Record)
     59       : DataStreamBasicWriter(W.getASTContext()), Writer(&W), Record(&Record) {}
     60 
     61   /// Construct a ASTRecordWriter that uses the same encoding scheme as another
     62   /// ASTRecordWriter.
     63   ASTRecordWriter(ASTRecordWriter &Parent, ASTWriter::RecordDataImpl &Record)
     64       : DataStreamBasicWriter(Parent.getASTContext()), Writer(Parent.Writer),
     65         Record(&Record) {}
     66 
     67   /// Copying an ASTRecordWriter is almost certainly a bug.
     68   ASTRecordWriter(const ASTRecordWriter &) = delete;
     69   ASTRecordWriter &operator=(const ASTRecordWriter &) = delete;
     70 
     71   /// Extract the underlying record storage.
     72   ASTWriter::RecordDataImpl &getRecordData() const { return *Record; }
     73 
     74   /// Minimal vector-like interface.
     75   /// @{
     76   void push_back(uint64_t N) { Record->push_back(N); }
     77   template<typename InputIterator>
     78   void append(InputIterator begin, InputIterator end) {
     79     Record->append(begin, end);
     80   }
     81   bool empty() const { return Record->empty(); }
     82   size_t size() const { return Record->size(); }
     83   uint64_t &operator[](size_t N) { return (*Record)[N]; }
     84   /// @}
     85 
     86   /// Emit the record to the stream, followed by its substatements, and
     87   /// return its offset.
     88   // FIXME: Allow record producers to suggest Abbrevs.
     89   uint64_t Emit(unsigned Code, unsigned Abbrev = 0) {
     90     uint64_t Offset = Writer->Stream.GetCurrentBitNo();
     91     PrepareToEmit(Offset);
     92     Writer->Stream.EmitRecord(Code, *Record, Abbrev);
     93     FlushStmts();
     94     return Offset;
     95   }
     96 
     97   /// Emit the record to the stream, preceded by its substatements.
     98   uint64_t EmitStmt(unsigned Code, unsigned Abbrev = 0) {
     99     FlushSubStmts();
    100     PrepareToEmit(Writer->Stream.GetCurrentBitNo());
    101     Writer->Stream.EmitRecord(Code, *Record, Abbrev);
    102     return Writer->Stream.GetCurrentBitNo();
    103   }
    104 
    105   /// Add a bit offset into the record. This will be converted into an
    106   /// offset relative to the current record when emitted.
    107   void AddOffset(uint64_t BitOffset) {
    108     OffsetIndices.push_back(Record->size());
    109     Record->push_back(BitOffset);
    110   }
    111 
    112   /// Add the given statement or expression to the queue of
    113   /// statements to emit.
    114   ///
    115   /// This routine should be used when emitting types and declarations
    116   /// that have expressions as part of their formulation. Once the
    117   /// type or declaration has been written, Emit() will write
    118   /// the corresponding statements just after the record.
    119   void AddStmt(Stmt *S) {
    120     StmtsToEmit.push_back(S);
    121   }
    122   void writeStmtRef(const Stmt *S) {
    123     AddStmt(const_cast<Stmt*>(S));
    124   }
    125 
    126   /// Add a definition for the given function to the queue of statements
    127   /// to emit.
    128   void AddFunctionDefinition(const FunctionDecl *FD);
    129 
    130   /// Emit a source location.
    131   void AddSourceLocation(SourceLocation Loc) {
    132     return Writer->AddSourceLocation(Loc, *Record);
    133   }
    134   void writeSourceLocation(SourceLocation Loc) {
    135     AddSourceLocation(Loc);
    136   }
    137 
    138   /// Emit a source range.
    139   void AddSourceRange(SourceRange Range) {
    140     return Writer->AddSourceRange(Range, *Record);
    141   }
    142 
    143   void writeBool(bool Value) {
    144     Record->push_back(Value);
    145   }
    146 
    147   void writeUInt32(uint32_t Value) {
    148     Record->push_back(Value);
    149   }
    150 
    151   void writeUInt64(uint64_t Value) {
    152     Record->push_back(Value);
    153   }
    154 
    155   /// Emit an integral value.
    156   void AddAPInt(const llvm::APInt &Value) {
    157     writeAPInt(Value);
    158   }
    159 
    160   /// Emit a signed integral value.
    161   void AddAPSInt(const llvm::APSInt &Value) {
    162     writeAPSInt(Value);
    163   }
    164 
    165   /// Emit a floating-point value.
    166   void AddAPFloat(const llvm::APFloat &Value);
    167 
    168   /// Emit an APvalue.
    169   void AddAPValue(const APValue &Value) { writeAPValue(Value); }
    170 
    171   /// Emit a reference to an identifier.
    172   void AddIdentifierRef(const IdentifierInfo *II) {
    173     return Writer->AddIdentifierRef(II, *Record);
    174   }
    175   void writeIdentifier(const IdentifierInfo *II) {
    176     AddIdentifierRef(II);
    177   }
    178 
    179   /// Emit a Selector (which is a smart pointer reference).
    180   void AddSelectorRef(Selector S);
    181   void writeSelector(Selector sel) {
    182     AddSelectorRef(sel);
    183   }
    184 
    185   /// Emit a CXXTemporary.
    186   void AddCXXTemporary(const CXXTemporary *Temp);
    187 
    188   /// Emit a C++ base specifier.
    189   void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base);
    190 
    191   /// Emit a set of C++ base specifiers.
    192   void AddCXXBaseSpecifiers(ArrayRef<CXXBaseSpecifier> Bases);
    193 
    194   /// Emit a reference to a type.
    195   void AddTypeRef(QualType T) {
    196     return Writer->AddTypeRef(T, *Record);
    197   }
    198   void writeQualType(QualType T) {
    199     AddTypeRef(T);
    200   }
    201 
    202   /// Emits a reference to a declarator info.
    203   void AddTypeSourceInfo(TypeSourceInfo *TInfo);
    204 
    205   /// Emits source location information for a type. Does not emit the type.
    206   void AddTypeLoc(TypeLoc TL);
    207 
    208   /// Emits a template argument location info.
    209   void AddTemplateArgumentLocInfo(TemplateArgument::ArgKind Kind,
    210                                   const TemplateArgumentLocInfo &Arg);
    211 
    212   /// Emits a template argument location.
    213   void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg);
    214 
    215   /// Emits an AST template argument list info.
    216   void AddASTTemplateArgumentListInfo(
    217       const ASTTemplateArgumentListInfo *ASTTemplArgList);
    218 
    219   /// Emit a reference to a declaration.
    220   void AddDeclRef(const Decl *D) {
    221     return Writer->AddDeclRef(D, *Record);
    222   }
    223   void writeDeclRef(const Decl *D) {
    224     AddDeclRef(D);
    225   }
    226 
    227   /// Emit a declaration name.
    228   void AddDeclarationName(DeclarationName Name) {
    229     writeDeclarationName(Name);
    230   }
    231 
    232   void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc,
    233                              DeclarationName Name);
    234   void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo);
    235 
    236   void AddQualifierInfo(const QualifierInfo &Info);
    237 
    238   /// Emit a nested name specifier.
    239   void AddNestedNameSpecifier(NestedNameSpecifier *NNS) {
    240     writeNestedNameSpecifier(NNS);
    241   }
    242 
    243   /// Emit a nested name specifier with source-location information.
    244   void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
    245 
    246   /// Emit a template name.
    247   void AddTemplateName(TemplateName Name) {
    248     writeTemplateName(Name);
    249   }
    250 
    251   /// Emit a template argument.
    252   void AddTemplateArgument(const TemplateArgument &Arg) {
    253     writeTemplateArgument(Arg);
    254   }
    255 
    256   /// Emit a template parameter list.
    257   void AddTemplateParameterList(const TemplateParameterList *TemplateParams);
    258 
    259   /// Emit a template argument list.
    260   void AddTemplateArgumentList(const TemplateArgumentList *TemplateArgs);
    261 
    262   /// Emit a UnresolvedSet structure.
    263   void AddUnresolvedSet(const ASTUnresolvedSet &Set);
    264 
    265   /// Emit a CXXCtorInitializer array.
    266   void AddCXXCtorInitializers(ArrayRef<CXXCtorInitializer *> CtorInits);
    267 
    268   void AddCXXDefinitionData(const CXXRecordDecl *D);
    269 
    270   /// Emit information about the initializer of a VarDecl.
    271   void AddVarDeclInit(const VarDecl *VD);
    272 
    273   /// Write an OMPTraitInfo object.
    274   void writeOMPTraitInfo(const OMPTraitInfo *TI);
    275 
    276   void writeOMPClause(OMPClause *C);
    277 
    278   /// Writes data related to the OpenMP directives.
    279   void writeOMPChildren(OMPChildren *Data);
    280 
    281   /// Emit a string.
    282   void AddString(StringRef Str) {
    283     return Writer->AddString(Str, *Record);
    284   }
    285 
    286   /// Emit a path.
    287   void AddPath(StringRef Path) {
    288     return Writer->AddPath(Path, *Record);
    289   }
    290 
    291   /// Emit a version tuple.
    292   void AddVersionTuple(const VersionTuple &Version) {
    293     return Writer->AddVersionTuple(Version, *Record);
    294   }
    295 
    296   // Emit an attribute.
    297   void AddAttr(const Attr *A);
    298 
    299   /// Emit a list of attributes.
    300   void AddAttributes(ArrayRef<const Attr*> Attrs);
    301 };
    302 
    303 } // end namespace clang
    304 
    305 #endif
    306