granicus.if.org Git - clang/blob - AST/TypeSerialization.cpp

   1 //===--- TypeSerialization.cpp - Serialization of Decls ---------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This files defines methods that implement bitcode serialization for Types.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/Type.h"
  15 #include "clang/AST/Expr.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "llvm/Bitcode/Serialize.h"
  18 #include "llvm/Bitcode/Deserialize.h"
  19
  20 using namespace clang;
  21 using llvm::Serializer;
  22 using llvm::Deserializer;
  23 using llvm::SerializedPtrID;
  24
  25
  26 void QualType::Emit(Serializer& S) const {
  27   S.EmitPtr(getTypePtr());
  28   S.EmitInt(getQualifiers());
  29 }
  30
  31 QualType QualType::ReadVal(Deserializer& D) {
  32   QualType Q;
  33   D.ReadUIntPtr(Q.ThePtr,false);
  34   Q.ThePtr |= D.ReadInt();
  35   return Q;
  36 }
  37
  38 void QualType::ReadBackpatch(Deserializer& D) {
  39   D.ReadUIntPtr(ThePtr,true);
  40   ThePtr |= D.ReadInt();
  41 }
  42
  43 //===----------------------------------------------------------------------===//
  44 // Type Serialization: Dispatch code to handle specific types.
  45 //===----------------------------------------------------------------------===//
  46
  47 void Type::Emit(Serializer& S) const {
  48   S.EmitInt(getTypeClass());
  49   S.EmitPtr(this);
  50
  51   if (!isa<BuiltinType>(this))
  52     EmitImpl(S);
  53 }
  54
  55 void Type::EmitImpl(Serializer& S) const {
  56   assert (false && "Serializization for type not supported.");
  57 }
  58
  59 void Type::Create(ASTContext& Context, unsigned i, Deserializer& D) {
  60   Type::TypeClass K = static_cast<Type::TypeClass>(D.ReadInt());
  61   SerializedPtrID PtrID = D.ReadPtrID();
  62
  63   switch (K) {
  64     default:
  65       assert (false && "Deserialization for type not supported.");
  66       break;
  67
  68     case Type::Builtin:
  69       assert (i < Context.getTypes().size());
  70       assert (isa<BuiltinType>(Context.getTypes()[i]));
  71       D.RegisterPtr(PtrID,Context.getTypes()[i]);
  72       break;
  73
  74     case Type::ASQual:
  75       D.RegisterPtr(PtrID,ASQualType::CreateImpl(Context,D));
  76       break;
  77
  78     case Type::Complex:
  79       D.RegisterPtr(PtrID,ComplexType::CreateImpl(Context,D));
  80       break;
  81
  82     case Type::ConstantArray:
  83       D.RegisterPtr(PtrID,ConstantArrayType::CreateImpl(Context,D));
  84       break;
  85
  86     case Type::FunctionNoProto:
  87       D.RegisterPtr(PtrID,FunctionTypeNoProto::CreateImpl(Context,D));
  88       break;
  89
  90     case Type::FunctionProto:
  91       D.RegisterPtr(PtrID,FunctionTypeProto::CreateImpl(Context,D));
  92       break;
  93
  94     case Type::IncompleteArray:
  95       D.RegisterPtr(PtrID,IncompleteArrayType::CreateImpl(Context,D));
  96       break;
  97
  98     case Type::Pointer:
  99       D.RegisterPtr(PtrID,PointerType::CreateImpl(Context,D));
 100       break;
 101
 102     case Type::Tagged:
 103       D.RegisterPtr(PtrID,TagType::CreateImpl(Context,D));
 104       break;
 105
 106     case Type::TypeName:
 107       D.RegisterPtr(PtrID,TypedefType::CreateImpl(Context,D));
 108       break;
 109
 110     case Type::VariableArray:
 111       D.RegisterPtr(PtrID,VariableArrayType::CreateImpl(Context,D));
 112       break;
 113   }
 114 }
 115
 116 //===----------------------------------------------------------------------===//
 117 // ASQualType
 118 //===----------------------------------------------------------------------===//
 119
 120 void ASQualType::EmitImpl(Serializer& S) const {
 121   S.Emit(getBaseType());
 122   S.EmitInt(getAddressSpace());
 123 }
 124
 125 Type* ASQualType::CreateImpl(ASTContext& Context, Deserializer& D) {
 126   QualType BaseTy = QualType::ReadVal(D);
 127   unsigned AddressSpace = D.ReadInt();
 128   return Context.getASQualType(BaseTy, AddressSpace).getTypePtr();
 129 }
 130
 131 //===----------------------------------------------------------------------===//
 132 // ComplexType
 133 //===----------------------------------------------------------------------===//
 134
 135 void ComplexType::EmitImpl(Serializer& S) const {
 136   S.Emit(getElementType());
 137 }
 138
 139 Type* ComplexType::CreateImpl(ASTContext& Context, Deserializer& D) {
 140   return Context.getComplexType(QualType::ReadVal(D)).getTypePtr();
 141 }
 142
 143 //===----------------------------------------------------------------------===//
 144 // ConstantArray
 145 //===----------------------------------------------------------------------===//
 146
 147 void ConstantArrayType::EmitImpl(Serializer& S) const {
 148   S.Emit(getElementType());
 149   S.EmitInt(getSizeModifier());
 150   S.EmitInt(getIndexTypeQualifier());
 151   S.Emit(Size);
 152 }
 153
 154 Type* ConstantArrayType::CreateImpl(ASTContext& Context, Deserializer& D) {
 155   QualType ElTy = QualType::ReadVal(D);
 156   ArraySizeModifier am = static_cast<ArraySizeModifier>(D.ReadInt());
 157   unsigned ITQ = D.ReadInt();
 158
 159   llvm::APInt Size;
 160   D.Read(Size);
 161
 162   return Context.getConstantArrayType(ElTy,Size,am,ITQ).getTypePtr();
 163 }
 164
 165 //===----------------------------------------------------------------------===//
 166 // FunctionTypeNoProto
 167 //===----------------------------------------------------------------------===//
 168
 169 void FunctionTypeNoProto::EmitImpl(Serializer& S) const {
 170   S.Emit(getResultType());
 171 }
 172
 173 Type* FunctionTypeNoProto::CreateImpl(ASTContext& Context, Deserializer& D) {
 174   return Context.getFunctionTypeNoProto(QualType::ReadVal(D)).getTypePtr();
 175 }
 176
 177 //===----------------------------------------------------------------------===//
 178 // FunctionTypeProto
 179 //===----------------------------------------------------------------------===//
 180
 181 void FunctionTypeProto::EmitImpl(Serializer& S) const {
 182   S.Emit(getResultType());
 183   S.EmitBool(isVariadic());
 184   S.EmitInt(getNumArgs());
 185
 186   for (arg_type_iterator I=arg_type_begin(), E=arg_type_end(); I!=E; ++I)
 187     S.Emit(*I);
 188 }
 189
 190 Type* FunctionTypeProto::CreateImpl(ASTContext& Context, Deserializer& D) {
 191   QualType ResultType = QualType::ReadVal(D);
 192   bool isVariadic = D.ReadBool();
 193   unsigned NumArgs = D.ReadInt();
 194
 195   llvm::SmallVector<QualType,15> Args;
 196
 197   for (unsigned j = 0; j < NumArgs; ++j)
 198     Args.push_back(QualType::ReadVal(D));
 199
 200   return Context.getFunctionType(ResultType,&*Args.begin(),
 201                                  NumArgs,isVariadic).getTypePtr();
 202 }
 203
 204 //===----------------------------------------------------------------------===//
 205 // PointerType
 206 //===----------------------------------------------------------------------===//
 207
 208 void PointerType::EmitImpl(Serializer& S) const {
 209   S.Emit(getPointeeType());
 210 }
 211
 212 Type* PointerType::CreateImpl(ASTContext& Context, Deserializer& D) {
 213   return Context.getPointerType(QualType::ReadVal(D)).getTypePtr();
 214 }
 215
 216 //===----------------------------------------------------------------------===//
 217 // TagType
 218 //===----------------------------------------------------------------------===//
 219
 220 void TagType::EmitImpl(Serializer& S) const {
 221   S.EmitOwnedPtr(getDecl());
 222 }
 223
 224 Type* TagType::CreateImpl(ASTContext& Context, Deserializer& D) {
 225   std::vector<Type*>& Types =
 226     const_cast<std::vector<Type*>&>(Context.getTypes());
 227
 228   TagType* T = new TagType(NULL,QualType());
 229   Types.push_back(T);
 230
 231   // Deserialize the decl.
 232   T->decl = cast<TagDecl>(D.ReadOwnedPtr<Decl>());
 233
 234   return T;
 235 }
 236
 237 //===----------------------------------------------------------------------===//
 238 // TypedefType
 239 //===----------------------------------------------------------------------===//
 240
 241 void TypedefType::EmitImpl(Serializer& S) const {
 242   S.Emit(QualType((Type*)this,0).getCanonicalType());
 243   S.EmitPtr(Decl);
 244 }
 245
 246 Type* TypedefType::CreateImpl(ASTContext& Context, Deserializer& D) {
 247   std::vector<Type*>& Types =
 248     const_cast<std::vector<Type*>&>(Context.getTypes());
 249
 250   TypedefType* T = new TypedefType(Type::TypeName, NULL,QualType::ReadVal(D));
 251   Types.push_back(T);
 252
 253   D.ReadPtr(T->Decl); // May be backpatched.
 254   return T;
 255 }
 256
 257 //===----------------------------------------------------------------------===//
 258 // VariableArrayType
 259 //===----------------------------------------------------------------------===//
 260
 261 void VariableArrayType::EmitImpl(Serializer& S) const {
 262   S.Emit(getElementType());
 263   S.EmitInt(getSizeModifier());
 264   S.EmitInt(getIndexTypeQualifier());
 265   S.EmitOwnedPtr(SizeExpr);
 266 }
 267
 268 Type* VariableArrayType::CreateImpl(ASTContext& Context, Deserializer& D) {
 269   QualType ElTy = QualType::ReadVal(D);
 270   ArraySizeModifier am = static_cast<ArraySizeModifier>(D.ReadInt());
 271   unsigned ITQ = D.ReadInt();
 272   Expr* SizeExpr = D.ReadOwnedPtr<Expr>();
 273
 274   return Context.getVariableArrayType(ElTy,SizeExpr,am,ITQ).getTypePtr();
 275 }
 276
 277 //===----------------------------------------------------------------------===//
 278 // IncompleteArrayType
 279 //===----------------------------------------------------------------------===//
 280
 281 void IncompleteArrayType::EmitImpl(Serializer& S) const {
 282   S.Emit(getElementType());
 283   S.EmitInt(getSizeModifier());
 284   S.EmitInt(getIndexTypeQualifier());
 285 }
 286
 287 Type* IncompleteArrayType::CreateImpl(ASTContext& Context, Deserializer& D) {
 288   QualType ElTy = QualType::ReadVal(D);
 289   ArraySizeModifier am = static_cast<ArraySizeModifier>(D.ReadInt());
 290   unsigned ITQ = D.ReadInt();
 291
 292   return Context.getIncompleteArrayType(ElTy,am,ITQ).getTypePtr();
 293 }