diff options
| -rw-r--r-- | AST/DeclSerialization.cpp | 302 | ||||
| -rw-r--r-- | include/clang/AST/Decl.h | 156 |
2 files changed, 262 insertions, 196 deletions
diff --git a/AST/DeclSerialization.cpp b/AST/DeclSerialization.cpp index 9600e30380..71706e3e51 100644 --- a/AST/DeclSerialization.cpp +++ b/AST/DeclSerialization.cpp @@ -16,39 +16,23 @@ #include "llvm/Bitcode/Serialize.h" #include "llvm/Bitcode/Deserialize.h" +using llvm::Serializer; +using llvm::Deserializer; +using llvm::SerializedPtrID; + using namespace clang; -void Decl::Emit(llvm::Serializer& S) const { - S.EmitInt(getKind()); +//===----------------------------------------------------------------------===// +// Decl Serialization: Dispatch code to handle specialized decl types. +//===----------------------------------------------------------------------===// - switch (getKind()) { - default: - assert (false && "Not implemented."); - break; - - case BlockVar: - cast<BlockVarDecl>(this)->Emit(S); - break; - - case FileVar: - cast<FileVarDecl>(this)->Emit(S); - break; - - case ParmVar: - cast<ParmVarDecl>(this)->Emit(S); - break; - - case Function: - cast<FunctionDecl>(this)->Emit(S); - break; - - case Typedef: - cast<TypedefDecl>(this)->Emit(S); - break; - } +void Decl::Emit(Serializer& S) const { + S.EmitInt(getKind()); + EmitImpl(S); } -Decl* Decl::Materialize(llvm::Deserializer& D) { +Decl* Decl::Create(Deserializer& D) { + Kind k = static_cast<Kind>(D.ReadInt()); switch (k) { @@ -57,149 +41,239 @@ Decl* Decl::Materialize(llvm::Deserializer& D) { break; case BlockVar: - return BlockVarDecl::Materialize(D); + return BlockVarDecl::CreateImpl(D); case FileVar: - return FileVarDecl::Materialize(D); + return FileVarDecl::CreateImpl(D); case ParmVar: - return ParmVarDecl::Materialize(D); + return ParmVarDecl::CreateImpl(D); case Function: - return FunctionDecl::Materialize(D); + return FunctionDecl::CreateImpl(D); case Typedef: - return TypedefDecl::Materialize(D); + return TypedefDecl::CreateImpl(D); } } -void NamedDecl::InternalEmit(llvm::Serializer& S) const { - S.EmitPtr(Identifier); +//===----------------------------------------------------------------------===// +// Common serialization logic for subclasses of Decl. +//===----------------------------------------------------------------------===// + +void Decl::EmitInRec(Serializer& S) const { + S.Emit(getLocation()); // From Decl. } -void NamedDecl::InternalRead(llvm::Deserializer& D) { - D.ReadPtr(Identifier); +void Decl::ReadInRec(Deserializer& D) { + Loc = SourceLocation::ReadVal(D); // From Decl. } -void ScopedDecl::InternalEmit(llvm::Serializer& S) const { - NamedDecl::InternalEmit(S); - S.EmitPtr(Next); - S.EmitOwnedPtr<Decl>(NextDeclarator); +//===----------------------------------------------------------------------===// +// Common serialization logic for subclasses of NamedDecl. +//===----------------------------------------------------------------------===// + +void NamedDecl::EmitInRec(Serializer& S) const { + Decl::EmitInRec(S); + S.EmitPtr(getIdentifier()); // From NamedDecl. } -void ScopedDecl::InternalRead(llvm::Deserializer& D) { - NamedDecl::InternalRead(D); - D.ReadPtr(Next); - NextDeclarator = cast_or_null<ScopedDecl>(D.ReadOwnedPtr<Decl>()); +void NamedDecl::ReadInRec(Deserializer& D) { + Decl::ReadInRec(D); + D.ReadPtr(Identifier); // From NamedDecl. } -void ValueDecl::InternalEmit(llvm::Serializer& S) const { - S.Emit(DeclType); - ScopedDecl::InternalEmit(S); +//===----------------------------------------------------------------------===// +// Common serialization logic for subclasses of ScopedDecl. +//===----------------------------------------------------------------------===// + +void ScopedDecl::EmitInRec(Serializer& S) const { + NamedDecl::EmitInRec(S); + S.EmitPtr(getNext()); // From ScopedDecl. } -void ValueDecl::InternalRead(llvm::Deserializer& D) { - D.Read(DeclType); - ScopedDecl::InternalRead(D); +void ScopedDecl::ReadInRec(Deserializer& D) { + NamedDecl::ReadInRec(D); + D.ReadPtr(Next); // From ScopedDecl. } + + //===------------------------------------------------------------===// + // NOTE: Not all subclasses of ScopedDecl will use the "OutRec" // + // methods. This is because owned pointers are usually "batched" // + // together for efficiency. // + //===------------------------------------------------------------===// -void VarDecl::InternalEmit(llvm::Serializer& S) const { - S.EmitInt(SClass); - S.EmitInt(objcDeclQualifier); - ValueDecl::InternalEmit(S); - S.EmitOwnedPtr(Init); +void ScopedDecl::EmitOutRec(Serializer& S) const { + S.EmitOwnedPtr(getNextDeclarator()); // From ScopedDecl. } -void VarDecl::InternalRead(llvm::Deserializer& D) { - SClass = D.ReadInt(); - objcDeclQualifier = static_cast<ObjcDeclQualifier>(D.ReadInt()); - ValueDecl::InternalRead(D); - D.ReadOwnedPtr(Init); +void ScopedDecl::ReadOutRec(Deserializer& D) { + NextDeclarator = + cast_or_null<ScopedDecl>(D.ReadOwnedPtr<Decl>()); // From ScopedDecl. } +//===----------------------------------------------------------------------===// +// Common serialization logic for subclasses of ValueDecl. +//===----------------------------------------------------------------------===// -void BlockVarDecl::Emit(llvm::Serializer& S) const { - S.Emit(getLocation()); - VarDecl::InternalEmit(S); +void ValueDecl::EmitInRec(Serializer& S) const { + ScopedDecl::EmitInRec(S); + S.Emit(getType()); // From ValueDecl. } -BlockVarDecl* BlockVarDecl::Materialize(llvm::Deserializer& D) { - SourceLocation L = SourceLocation::ReadVal(D); - BlockVarDecl* decl = new BlockVarDecl(L,NULL,QualType(),None,NULL); - decl->VarDecl::InternalRead(D); - return decl; +void ValueDecl::ReadInRec(Deserializer& D) { + ScopedDecl::ReadInRec(D); + DeclType = QualType::ReadVal(D); // From ValueDecl. } -void FileVarDecl::Emit(llvm::Serializer& S) const { - S.Emit(getLocation()); - VarDecl::InternalEmit(S); +//===----------------------------------------------------------------------===// +// Common serialization logic for subclasses of VarDecl. +//===----------------------------------------------------------------------===// + +void VarDecl::EmitInRec(Serializer& S) const { + ValueDecl::EmitInRec(S); + S.EmitInt(getStorageClass()); // From VarDecl. + S.EmitInt(getObjcDeclQualifier()); // From VarDecl. } -FileVarDecl* FileVarDecl::Materialize(llvm::Deserializer& D) { - SourceLocation L = SourceLocation::ReadVal(D); - FileVarDecl* decl = new FileVarDecl(L,NULL,QualType(),None,NULL); - decl->VarDecl::InternalRead(D); - return decl; +void VarDecl::ReadInRec(Deserializer& D) { + ValueDecl::ReadInRec(D); + SClass = static_cast<StorageClass>(D.ReadInt()); // From VarDecl. + objcDeclQualifier = static_cast<ObjcDeclQualifier>(D.ReadInt()); // VarDecl. } -void ParmVarDecl::Emit(llvm::Serializer& S) const { - S.Emit(getLocation()); - VarDecl::InternalEmit(S); + //===------------------------------------------------------------===// + // NOTE: VarDecl has its own "OutRec" methods that doesn't use // + // the one define in ScopedDecl. This is to batch emit the // + // owned pointers, which results in a smaller output. + //===------------------------------------------------------------===// + +void VarDecl::EmitOutRec(Serializer& S) const { + // Emit these last because they will create records of their own. + S.BatchEmitOwnedPtrs(getInit(), // From VarDecl. + getNextDeclarator()); // From ScopedDecl. } -ParmVarDecl* ParmVarDecl::Materialize(llvm::Deserializer& D) { - SourceLocation L = SourceLocation::ReadVal(D); - ParmVarDecl* decl = new ParmVarDecl(L,NULL,QualType(),None,NULL); - decl->VarDecl::InternalRead(D); +void VarDecl::ReadOutRec(Deserializer& D) { + Decl* next_declarator; + + D.BatchReadOwnedPtrs(Init, // From VarDecl. + next_declarator); // From ScopedDecl. + + setNextDeclarator(cast_or_null<ScopedDecl>(next_declarator)); +} + + +void VarDecl::EmitImpl(Serializer& S) const { + VarDecl::EmitInRec(S); + VarDecl::EmitOutRec(S); +} + +void VarDecl::ReadImpl(Deserializer& D) { + ReadInRec(D); + ReadOutRec(D); +} + +//===----------------------------------------------------------------------===// +// BlockVarDecl Serialization. +//===----------------------------------------------------------------------===// + +BlockVarDecl* BlockVarDecl::CreateImpl(Deserializer& D) { + BlockVarDecl* decl = + new BlockVarDecl(SourceLocation(),NULL,QualType(),None,NULL); + + decl->VarDecl::ReadImpl(D); + + return decl; +} + +//===----------------------------------------------------------------------===// +// FileVarDecl Serialization. +//===----------------------------------------------------------------------===// + +FileVarDecl* FileVarDecl::CreateImpl(Deserializer& D) { + FileVarDecl* decl = + new FileVarDecl(SourceLocation(),NULL,QualType(),None,NULL); + + decl->VarDecl::ReadImpl(D); + return decl; } -void FunctionDecl::Emit(llvm::Serializer& S) const { - S.Emit(getLocation()); - S.EmitInt(SClass); - S.EmitBool(IsInline); +//===----------------------------------------------------------------------===// +// ParmDecl Serialization. +//===----------------------------------------------------------------------===// + +ParmVarDecl* ParmVarDecl::CreateImpl(Deserializer& D) { + ParmVarDecl* decl = + new ParmVarDecl(SourceLocation(),NULL,QualType(),None,NULL); + + decl->VarDecl::ReadImpl(D); - ValueDecl::InternalEmit(S); + return decl; +} - unsigned NumParams = getNumParams(); - S.EmitInt(NumParams); +//===----------------------------------------------------------------------===// +// FunctionDecl Serialization. +//===----------------------------------------------------------------------===// + +void FunctionDecl::EmitImpl(Serializer& S) const { + S.EmitInt(SClass); // From FunctionDecl. + S.EmitBool(IsInline); // From FunctionDecl. + ValueDecl::EmitInRec(S); + S.EmitPtr(DeclChain); - for (unsigned i = 0 ; i < NumParams; ++i) - S.EmitOwnedPtr(ParamInfo[i]); + // NOTE: We do not need to serialize out the number of parameters, because + // that is encoded in the type (accessed via getNumParams()). - S.EmitOwnedPtr(Body); + S.BatchEmitOwnedPtrs(getNumParams(),&ParamInfo[0], // From FunctionDecl. + Body, // From FunctionDecl. + getNextDeclarator()); // From ScopedDecl. } -FunctionDecl* FunctionDecl::Materialize(llvm::Deserializer& D) { - SourceLocation L = SourceLocation::ReadVal(D); +FunctionDecl* FunctionDecl::CreateImpl(Deserializer& D) { StorageClass SClass = static_cast<StorageClass>(D.ReadInt()); bool IsInline = D.ReadBool(); - - FunctionDecl* decl = new FunctionDecl(L,NULL,QualType(),SClass,IsInline); - decl->ValueDecl::InternalRead(D); - - unsigned NumParams = D.ReadInt(); - decl->ParamInfo = NumParams ? new ParmVarDecl*[NumParams] : NULL; + FunctionDecl* decl = + new FunctionDecl(SourceLocation(),NULL,QualType(),SClass,IsInline); - for (unsigned i = 0 ; i < NumParams; ++i) - D.ReadOwnedPtr(decl->ParamInfo[i]); - - D.ReadOwnedPtr(decl->Body); + decl->ValueDecl::ReadInRec(D); + D.ReadPtr(decl->DeclChain); + + decl->ParamInfo = decl->getNumParams() + ? new ParmVarDecl*[decl->getNumParams()] + : NULL; + + Decl* next_declarator; + + D.BatchReadOwnedPtrs(decl->getNumParams(), + reinterpret_cast<Decl**>(&decl->ParamInfo[0]), // FunctionDecl. + decl->Body, // From FunctionDecl. + next_declarator); // From ScopedDecl. + + decl->setNextDeclarator(cast_or_null<ScopedDecl>(next_declarator)); return decl; } -void TypedefDecl::Emit(llvm::Serializer& S) const { - S.Emit(getLocation()); +//===----------------------------------------------------------------------===// +// TypedefDecl Serialization. +//===----------------------------------------------------------------------===// + +void TypedefDecl::EmitImpl(Serializer& S) const { S.Emit(UnderlyingType); - InternalEmit(S); + ScopedDecl::EmitInRec(S); + ScopedDecl::EmitOutRec(S); } -TypedefDecl* TypedefDecl::Materialize(llvm::Deserializer& D) { - SourceLocation L = SourceLocation::ReadVal(D); - TypedefDecl* decl = new TypedefDecl(L,NULL,QualType(),NULL); - D.Read(decl->UnderlyingType); - decl->InternalRead(D); +TypedefDecl* TypedefDecl::CreateImpl(Deserializer& D) { + QualType T = QualType::ReadVal(D); + + TypedefDecl* decl = new TypedefDecl(SourceLocation(),NULL,T,NULL); + + decl->ScopedDecl::ReadInRec(D); + decl->ScopedDecl::ReadOutRec(D); + return decl; } diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h index d38187645c..c3017f9521 100644 --- a/include/clang/AST/Decl.h +++ b/include/clang/AST/Decl.h @@ -108,7 +108,7 @@ public: private: /// Loc - The location that this decl. SourceLocation Loc; - + /// DeclKind - This indicates which class this is. Kind DeclKind : 8; @@ -163,9 +163,23 @@ public: /// Emit - Serialize this Decl to Bitcode. void Emit(llvm::Serializer& S) const; + + /// Create - Deserialize a Decl from Bitcode. + static Decl* Create(llvm::Deserializer& D); - /// Materialize - Deserialize a Decl from Bitcode. - static Decl* Materialize(llvm::Deserializer& D); + /// Materialize - Deserialize a Decl from Bitcode. (DEPRECATED) + static Decl* Materialize(llvm::Deserializer& D) { return Create(D); } + +protected: + /// EmitImpl - Provides the subclass-specific serialization logic for + /// serializing out a decl. + virtual void EmitImpl(llvm::Serializer& S) const { + // FIXME: This will eventually be a pure virtual function. + assert (false && "Not implemented."); + } + + void EmitInRec(llvm::Serializer& S) const; + void ReadInRec(llvm::Deserializer& D); }; /// NamedDecl - This represents a decl with an identifier for a name. Many @@ -180,22 +194,20 @@ public: IdentifierInfo *getIdentifier() const { return Identifier; } const char *getName() const; - - + static bool classof(const Decl *D) { return D->getKind() >= NamedFirst && D->getKind() <= NamedLast; } static bool classof(const NamedDecl *D) { return true; } - + protected: - void InternalEmit(llvm::Serializer& S) const; - void InternalRead(llvm::Deserializer& D); + void EmitInRec(llvm::Serializer& S) const; + void ReadInRec(llvm::Deserializer& D); }; /// ScopedDecl - Represent lexically scoped names, used for all ValueDecl's /// and TypeDecl's. class ScopedDecl : public NamedDecl { - /// NextDeclarator - If this decl was part of a multi-declarator declaration, /// such as "int X, Y, *Z;" this indicates Decl for the next declarator. ScopedDecl *NextDeclarator; @@ -205,9 +217,11 @@ class ScopedDecl : public NamedDecl { /// Decls are relinked onto a containing decl object. /// ScopedDecl *Next; + protected: ScopedDecl(Kind DK, SourceLocation L, IdentifierInfo *Id,ScopedDecl *PrevDecl) : NamedDecl(DK, L, Id), NextDeclarator(PrevDecl), Next(0) {} + public: ScopedDecl *getNext() const { return Next; } void setNext(ScopedDecl *N) { Next = N; } @@ -224,10 +238,13 @@ public: return D->getKind() >= ScopedFirst && D->getKind() <= ScopedLast; } static bool classof(const ScopedDecl *D) { return true; } - + protected: - void InternalEmit(llvm::Serializer& S) const; - void InternalRead(llvm::Deserializer& D); + void EmitInRec(llvm::Serializer& S) const; + void ReadInRec(llvm::Deserializer& D); + + void EmitOutRec(llvm::Serializer& S) const; + void ReadOutRec(llvm::Deserializer& D); }; /// ValueDecl - Represent the declaration of a variable (in which case it is @@ -248,10 +265,10 @@ public: return D->getKind() >= ValueFirst && D->getKind() <= ValueLast; } static bool classof(const ValueDecl *D) { return true; } - + protected: - void InternalEmit(llvm::Serializer& S) const; - void InternalRead(llvm::Deserializer& D); + void EmitInRec(llvm::Serializer& S) const; + void ReadInRec(llvm::Deserializer& D); }; /// VarDecl - An instance of this class is created to represent a variable @@ -323,8 +340,17 @@ private: friend class StmtIteratorBase; protected: - void InternalEmit(llvm::Serializer& S) const; - void InternalRead(llvm::Deserializer& D); + void EmitInRec(llvm::Serializer& S) const; + void ReadInRec(llvm::Deserializer& D); + + void EmitOutRec(llvm::Serializer& S) const; + void ReadOutRec(llvm::Deserializer& D); + + /// EmitImpl - Serialize this VarDecl. Called by Decl::Emit. + virtual void EmitImpl(llvm::Serializer& S) const; + + /// ReadImpl - Deserialize this VarDecl. Called by subclasses. + virtual void ReadImpl(llvm::Deserializer& S); }; /// BlockVarDecl - Represent a local variable declaration. @@ -338,11 +364,11 @@ public: static bool classof(const Decl *D) { return D->getKind() == BlockVar; } static bool classof(const BlockVarDecl *D) { return true; } - /// Emit - Serialize this BlockVarDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a BlockVarDecl from Bitcode. - static BlockVarDecl* Materialize(llvm::Deserializer& D); +protected: + /// CreateImpl - Deserialize a BlockVarDecl. Called by Decl::Create. + static BlockVarDecl* CreateImpl(llvm::Deserializer& D); + + friend Decl* Decl::Create(llvm::Deserializer& D); }; /// FileVarDecl - Represent a file scoped variable declaration. This @@ -358,12 +384,12 @@ public: // Implement isa/cast/dyncast/etc. static bool classof(const Decl *D) { return D->getKind() == FileVar; } static bool classof(const FileVarDecl *D) { return true; } - - /// Emit - Serialize this FileVarDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a FileVarDecl from Bitcode. - static FileVarDecl* Materialize(llvm::Deserializer& D); + +protected: + /// CreateImpl - Deserialize a FileVarDecl. Called by Decl::Create. + static FileVarDecl* CreateImpl(llvm::Deserializer& D); + + friend Decl* Decl::Create(llvm::Deserializer& D); }; /// ParmVarDecl - Represent a parameter to a function. @@ -377,11 +403,11 @@ public: static bool classof(const Decl *D) { return D->getKind() == ParmVar; } static bool classof(const ParmVarDecl *D) { return true; } - /// Emit - Serialize this ParmVarDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a ParmVarDecl from Bitcode. - static ParmVarDecl* Materialize(llvm::Deserializer& D); +protected: + /// CreateImpl - Deserialize a ParmVarDecl. Called by Decl::Create. + static ParmVarDecl* CreateImpl(llvm::Deserializer& D); + + friend Decl* Decl::Create(llvm::Deserializer& D); }; /// FunctionDecl - An instance of this class is created to represent a function @@ -424,6 +450,7 @@ public: // Implement isa/cast/dyncast/etc. static bool classof(const Decl *D) { return D->getKind() == Function; } static bool classof(const FunctionDecl *D) { return true; } + private: /// ParamInfo - new[]'d array of pointers to VarDecls for the formal /// parameters of this function. This is null if a prototype or if there are @@ -440,12 +467,14 @@ private: StorageClass SClass : 2; bool IsInline : 1; -public: - /// Emit - Serialize this FunctionDecl to Bitcode. - void Emit(llvm::Serializer& S) const; +protected: + /// EmitImpl - Serialize this FunctionDecl. Called by Decl::Emit. + virtual void EmitImpl(llvm::Serializer& S) const; - /// Materialize - Deserialize a FunctionDecl from Bitcode. - static FunctionDecl* Materialize(llvm::Deserializer& D); + /// CreateImpl - Deserialize a FunctionDecl. Called by Decl::Create. + static FunctionDecl* CreateImpl(llvm::Deserializer& D); + + friend Decl* Decl::Create(llvm::Deserializer& D); }; @@ -472,13 +501,6 @@ public: return D->getKind() >= FieldFirst && D->getKind() <= FieldLast; } static bool classof(const FieldDecl *D) { return true; } - -public: - /// Emit - Serialize this FieldDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a FieldDecl from Bitcode. - static FieldDecl* Materialize(llvm::Deserializer& D); }; /// EnumConstantDecl - An instance of this object exists for each enum constant @@ -505,12 +527,6 @@ public: static bool classof(const EnumConstantDecl *D) { return true; } friend class StmtIteratorBase; - - /// Emit - Serialize this EnumConstantDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a EnumConstantDecl from Bitcode. - static EnumConstantDecl* Materialize(llvm::Deserializer& D); }; @@ -531,12 +547,6 @@ public: return D->getKind() >= TypeFirst && D->getKind() <= TypeLast; } static bool classof(const TypeDecl *D) { return true; } - - /// Emit - Serialize this TypeDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a TypeDecl from Bitcode. - static TypeDecl* Materialize(llvm::Deserializer& D); }; @@ -553,12 +563,15 @@ public: // Implement isa/cast/dyncast/etc. static bool classof(const Decl *D) { return D->getKind() == Typedef; } static bool classof(const TypedefDecl *D) { return true; } + +protected: + /// EmitImpl - Serialize this TypedefDecl. Called by Decl::Emit. + virtual void EmitImpl(llvm::Serializer& S) const; - /// Emit - Serialize this TypedefDecl to Bitcode. - void Emit(llvm::Serializer& S) const; + /// CreateImpl - Deserialize a TypedefDecl. Called by Decl::Create. + static TypedefDecl* CreateImpl(llvm::Deserializer& D); - /// Materialize - Deserialize a TypedefDecl from Bitcode. - static TypedefDecl* Materialize(llvm::Deserializer& D); + friend Decl* Decl::Create(llvm::Deserializer& D); }; @@ -596,13 +609,6 @@ public: static bool classof(const TagDecl *D) { return true; } protected: void setDefinition(bool V) { IsDefinition = V; } - -public: - /// Emit - Serialize this TagDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a TagDecl from Bitcode. - static TagDecl* Materialize(llvm::Deserializer& D); }; /// EnumDecl - Represents an enum. As an extension, we allow forward-declared @@ -644,13 +650,6 @@ public: static bool classof(const Decl *D) { return D->getKind() == Enum; } static bool classof(const EnumDecl *D) { return true; } - -public: - /// Emit - Serialize this EnumDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a EnumDecl from Bitcode. - static EnumDecl* Materialize(llvm::Deserializer& D); }; @@ -698,13 +697,6 @@ public: return D->getKind() >= RecordFirst && D->getKind() <= RecordLast; } static bool classof(const RecordDecl *D) { return true; } - -public: - /// Emit - Serialize this RecordDecl to Bitcode. - void Emit(llvm::Serializer& S) const; - - /// Materialize - Deserialize a RecordDecl from Bitcode. - static RecordDecl* Materialize(llvm::Deserializer& D); }; } // end namespace clang |