Restructured serialization code for decls to make it cleaner, easier to

understand, and batched the emission owned subobjects (using
BatchEmitOwnedPtr) to get a smaller output bitcode size.


git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@44033 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 188 insertions, 114 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;
 }