Started work on new serialization approach within ASTContext to

serialize Type objects in the order they are serialized in the Types
vector.  We also now rely on the methods within ASTContext to unique
Type objects and handle the actual creation of Type objects (these are
now called by the deserialization code).  This approach solves some
hairy issues with ownership of objects and allows us to naturally
handle recursive types.

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

diff --git a/AST/ASTContext.cpp b/AST/ASTContext.cpp
index 982ef05a06653a667b0f886870340b9f08cf6af2..ef444b48f461f61da145c621ff0708e9ec685fd4 100644 (file)
--- a/AST/ASTContext.cpp
+++ b/AST/ASTContext.cpp
@@ -1377,7 +1377,50 @@ void ASTContext::Emit(llvm::Serializer& S) const {
 
   // Emit the size of the type vector so that we can reserve that size
   // when we reconstitute the ASTContext object.
-  S.Emit(Types.size());
+  S.EmitInt(Types.size());
+  
+  for (std::vector<Type*>::const_iterator I=Types.begin(), E=Types.end();
+         I!=E; ++I) {
+    
+    Type* t = *I;    
+    Type::TypeClass k = t->getTypeClass();
+    
+    S.EmitInt(k);
+    
+    switch (k) {
+      default:
+        assert (false && "Serialization for type not supported.");
+        break;
+      
+      case Type::Builtin:
+        break;
+        
+      case Type::Complex:
+        S.Emit(cast<ComplexType>(t)->getElementType());
+        break;
+        
+      case Type::Pointer:
+        S.Emit(cast<PointerType>(t)->getPointeeType());
+        break;
+        
+      case Type::FunctionProto: {
+        FunctionTypeProto& FT = *cast<FunctionTypeProto>(t);
+        
+        S.Emit(FT.getResultType());
+        S.Emit(FT.isVariadic());
+        S.Emit(FT.getNumArgs());
+
+        for (FunctionTypeProto::arg_type_iterator
+              I=FT.arg_type_begin(), E=FT.arg_type_end(); I!=E; ++I)
+          S.Emit(*I);
+
+        break;
+      }
+    }
+    
+    S.EmitPtr(t);
+  }
+  
   
   // Emit pointers to builtin types.  Although these objects will be
   // reconsituted automatically when ASTContext is created, any pointers to them
@@ -1385,6 +1428,8 @@ void ASTContext::Emit(llvm::Serializer& S) const {
   // with the Serializer anyway as pointed-to-objects, even if we won't 
   // serialize them out using EmitOwnedPtr.  This "registration" will then
   // be used by the Deserializer to backpatch references to the builtins.
+#if 0
+  {
   EmitBuiltin(S,VoidTy);
   EmitBuiltin(S,BoolTy);
   EmitBuiltin(S,CharTy);
@@ -1450,6 +1495,8 @@ void ASTContext::Emit(llvm::Serializer& S) const {
   // FIXME: EmitSet(ObjcQualifiedInterfaceTypes,S);
   
   S.Emit(BuiltinVaListType);
+  }
+#endif
 // FIXME:  S.Emit(ObjcIdType);
 // FIXME:  S.EmitPtr(IdStructType);
 // FIXME:  S.Emit(ObjcProtoType);
@@ -1470,7 +1517,60 @@ ASTContext* ASTContext::Materialize(llvm::Deserializer& D) {
   
   ASTContext* A = new ASTContext(SM,t,idents,sels,size_reserve);
   
+  for (unsigned i = 0; i < size_reserve; ++i) {
+    Type::TypeClass K = static_cast<Type::TypeClass>(D.ReadInt());
+    
+    switch (K) {
+      default:
+        assert (false && "Deserializaton for type not supported.");
+        break;
+        
+      case Type::Builtin:
+        assert (i < A->Types.size());
+        assert (isa<BuiltinType>(A->Types[i]));
+        D.RegisterPtr(A->Types[i]);
+        break;
+        
+      case Type::Complex: {
+        QualType ElementType;
+        D.Read(ElementType);
+        D.RegisterPtr(A->getComplexType(ElementType).getTypePtr());
+        break;
+      }
+        
+      case Type::Pointer: {
+        QualType PointeeType;
+        D.Read(PointeeType);
+        D.RegisterPtr(A->getPointerType(PointeeType).getTypePtr());
+        break;
+      }
+        
+      case Type::FunctionProto: {
+        QualType ResultType;
+        D.Read(ResultType);
+        
+        bool isVariadic = D.ReadBool();
+        
+        unsigned NumArgs = D.ReadInt();        
+        llvm::SmallVector<QualType,15> Args;
+        for (unsigned j = 0; j < NumArgs; ++j) { 
+          QualType Q;
+          D.Read(Q);
+          Args.push_back(Q);
+        }
+
+        D.RegisterPtr(A->getFunctionType(ResultType,&*Args.begin(),
+                                         NumArgs,isVariadic).getTypePtr());
+                       
+        break;
+      }
+
+    }
+  }
+  
   // Register the addresses of the BuiltinTypes with the Deserializer.
+#if 0
+  {
   RegisterBuiltin(D,A->VoidTy);
   RegisterBuiltin(D,A->BoolTy);
   RegisterBuiltin(D,A->CharTy);
@@ -1503,8 +1603,13 @@ ASTContext* ASTContext::Materialize(llvm::Deserializer& D) {
   ReadSet(A->FunctionTypeNoProtos, A->Types, D);
   ReadSet(A->FunctionTypeProtos, A->Types, D);
   // ReadSet(A->ObjcQualifiedInterfaceTypes,D);
+
+
   
   D.Read(A->BuiltinVaListType);
+  }
+#endif
+  
 // FIXME:  D.Read(A->ObjcIdType);
 // FIXME:  D.ReadPtr(A->IdStructType);
 // FIXME:  D.Read(A->ObjcProtoType);