Make a major restructuring of the clang tree: introduce a top-level

lib dir and move all the libraries into it.  This follows the main
llvm tree, and allows the libraries to be built in parallel.  The
top level now enforces that all the libs are built before Driver,
but we don't care what order the libs are built in.  This speeds
up parallel builds, particularly incremental ones.

llvm-svn: 48402

1 files changed, 1001 insertions, 0 deletions

diff --git a/clang/lib/AST/StmtSerialization.cpp b/clang/lib/AST/StmtSerialization.cpp
new file mode 100644
index 00000000000..433e8e27026
--- /dev/null
+++ b/clang/lib/AST/StmtSerialization.cpp
@@ -0,0 +1,1001 @@
+//===--- StmtSerialization.cpp - Serialization of Statements --------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the type-specific methods for serializing statements
+// and expressions.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/Expr.h"
+#include "llvm/Bitcode/Serialize.h"
+#include "llvm/Bitcode/Deserialize.h"
+
+using namespace clang;
+using llvm::Serializer;
+using llvm::Deserializer;
+
+void Stmt::Emit(Serializer& S) const {
+  S.FlushRecord();
+  S.EmitInt(getStmtClass());
+  EmitImpl(S);
+  S.FlushRecord();
+}  
+
+Stmt* Stmt::Create(Deserializer& D) {
+  StmtClass SC = static_cast<StmtClass>(D.ReadInt());
+  
+  switch (SC) {
+    default:  
+      assert (false && "Not implemented.");
+      return NULL;
+    
+    case AddrLabelExprClass:
+      return AddrLabelExpr::CreateImpl(D);
+      
+    case ArraySubscriptExprClass:
+      return ArraySubscriptExpr::CreateImpl(D);
+      
+    case AsmStmtClass:
+      return AsmStmt::CreateImpl(D);
+      
+    case BinaryOperatorClass:
+      return BinaryOperator::CreateImpl(D);
+      
+    case BreakStmtClass:
+      return BreakStmt::CreateImpl(D);
+     
+    case CallExprClass:
+      return CallExpr::CreateImpl(D);
+      
+    case CaseStmtClass:
+      return CaseStmt::CreateImpl(D);
+    
+    case CastExprClass:
+      return CastExpr::CreateImpl(D);
+      
+    case CharacterLiteralClass:
+      return CharacterLiteral::CreateImpl(D);
+      
+    case CompoundAssignOperatorClass:
+      return CompoundAssignOperator::CreateImpl(D);
+      
+    case CompoundLiteralExprClass:
+      return CompoundLiteralExpr::CreateImpl(D);
+      
+    case CompoundStmtClass:
+      return CompoundStmt::CreateImpl(D);
+    
+    case ConditionalOperatorClass:
+      return ConditionalOperator::CreateImpl(D);
+      
+    case ContinueStmtClass:
+      return ContinueStmt::CreateImpl(D);
+      
+    case DeclRefExprClass:
+      return DeclRefExpr::CreateImpl(D);
+      
+    case DeclStmtClass:
+      return DeclStmt::CreateImpl(D);
+      
+    case DefaultStmtClass:
+      return DefaultStmt::CreateImpl(D);
+    
+    case DoStmtClass:
+      return DoStmt::CreateImpl(D);
+      
+    case FloatingLiteralClass:
+      return FloatingLiteral::CreateImpl(D);
+
+    case ForStmtClass:
+      return ForStmt::CreateImpl(D);
+    
+    case GotoStmtClass:
+      return GotoStmt::CreateImpl(D);
+      
+    case IfStmtClass:
+      return IfStmt::CreateImpl(D);
+    
+    case ImaginaryLiteralClass:
+      return ImaginaryLiteral::CreateImpl(D);
+      
+    case ImplicitCastExprClass:
+      return ImplicitCastExpr::CreateImpl(D);
+      
+    case IndirectGotoStmtClass:
+      return IndirectGotoStmt::CreateImpl(D);
+      
+    case InitListExprClass:
+      return InitListExpr::CreateImpl(D);
+      
+    case IntegerLiteralClass:
+      return IntegerLiteral::CreateImpl(D);
+      
+    case LabelStmtClass:
+      return LabelStmt::CreateImpl(D);
+      
+    case MemberExprClass:
+      return MemberExpr::CreateImpl(D);
+      
+    case NullStmtClass:
+      return NullStmt::CreateImpl(D);
+      
+    case ParenExprClass:
+      return ParenExpr::CreateImpl(D);
+      
+    case PreDefinedExprClass:
+      return PreDefinedExpr::CreateImpl(D);
+      
+    case ReturnStmtClass:
+      return ReturnStmt::CreateImpl(D);
+    
+    case SizeOfAlignOfTypeExprClass:
+      return SizeOfAlignOfTypeExpr::CreateImpl(D);
+      
+    case StmtExprClass:
+      return StmtExpr::CreateImpl(D);
+      
+    case StringLiteralClass:
+      return StringLiteral::CreateImpl(D);
+      
+    case SwitchStmtClass:
+      return SwitchStmt::CreateImpl(D);
+      
+    case UnaryOperatorClass:
+      return UnaryOperator::CreateImpl(D);
+      
+    case WhileStmtClass:
+      return WhileStmt::CreateImpl(D);
+      
+    //==--------------------------------------==//
+    //    Objective C
+    //==--------------------------------------==//
+    
+    case ObjCAtCatchStmtClass:
+      return ObjCAtCatchStmt::CreateImpl(D);
+      
+    case ObjCAtFinallyStmtClass:
+      return ObjCAtFinallyStmt::CreateImpl(D);
+    
+    case ObjCAtSynchronizedStmtClass:
+      return ObjCAtSynchronizedStmt::CreateImpl(D);
+      
+    case ObjCAtThrowStmtClass:
+      return ObjCAtThrowStmt::CreateImpl(D);
+      
+    case ObjCAtTryStmtClass:
+      return ObjCAtTryStmt::CreateImpl(D);
+    
+    case ObjCEncodeExprClass:
+      return ObjCEncodeExpr::CreateImpl(D);
+      
+    case ObjCForCollectionStmtClass:
+      return ObjCForCollectionStmt::CreateImpl(D);
+      
+    case ObjCIvarRefExprClass:
+      return ObjCIvarRefExpr::CreateImpl(D);
+      
+    case ObjCSelectorExprClass:
+      return ObjCSelectorExpr::CreateImpl(D);
+      
+    case ObjCStringLiteralClass:
+      return ObjCStringLiteral::CreateImpl(D);
+  }
+}
+
+//===----------------------------------------------------------------------===//
+//   C Serialization
+//===----------------------------------------------------------------------===//
+
+void AddrLabelExpr::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(AmpAmpLoc);
+  S.Emit(LabelLoc);
+  S.EmitPtr(Label);
+}
+
+AddrLabelExpr* AddrLabelExpr::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  SourceLocation AALoc = SourceLocation::ReadVal(D);
+  SourceLocation LLoc = SourceLocation::ReadVal(D);
+  AddrLabelExpr* expr = new AddrLabelExpr(AALoc,LLoc,NULL,t);
+  D.ReadPtr(expr->Label); // Pointer may be backpatched.
+  return expr;
+}
+
+void ArraySubscriptExpr::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(RBracketLoc);
+  S.BatchEmitOwnedPtrs(getLHS(),getRHS());
+}
+
+ArraySubscriptExpr* ArraySubscriptExpr::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  SourceLocation L = SourceLocation::ReadVal(D);
+  Expr *LHS, *RHS;
+  D.BatchReadOwnedPtrs(LHS,RHS);
+  return new ArraySubscriptExpr(LHS,RHS,t,L);  
+}
+
+void AsmStmt::EmitImpl(Serializer& S) const {
+  S.Emit(AsmLoc);
+  
+  getAsmString()->EmitImpl(S);
+  S.Emit(RParenLoc);  
+
+  S.EmitBool(IsVolatile);
+  S.EmitBool(IsSimple);
+  S.EmitInt(NumOutputs);
+  S.EmitInt(NumInputs);
+
+  unsigned size = NumOutputs + NumInputs;
+
+  for (unsigned i = 0; i < size; ++i)
+    S.EmitCStr(Names[i].c_str());
+  
+  for (unsigned i = 0; i < size; ++i)
+    Constraints[i]->EmitImpl(S);
+
+  for (unsigned i = 0; i < size; ++i)
+    S.EmitOwnedPtr(Exprs[i]);
+  
+  S.EmitInt(Clobbers.size());
+  for (unsigned i = 0, e = Clobbers.size(); i != e; ++i)
+    Clobbers[i]->EmitImpl(S);
+}
+
+AsmStmt* AsmStmt::CreateImpl(Deserializer& D) {
+  SourceLocation ALoc = SourceLocation::ReadVal(D);
+  StringLiteral *AsmStr = StringLiteral::CreateImpl(D);
+  SourceLocation PLoc = SourceLocation::ReadVal(D);
+  
+  bool IsVolatile = D.ReadBool();
+  bool IsSimple = D.ReadBool();
+  AsmStmt *Stmt = new AsmStmt(ALoc, IsSimple, IsVolatile, 0, 0, 0, 0, 0,  
+                              AsmStr, 
+                              0, 0, PLoc);  
+
+  Stmt->NumOutputs = D.ReadInt();
+  Stmt->NumInputs = D.ReadInt();
+  
+  unsigned size = Stmt->NumOutputs + Stmt->NumInputs;
+
+  Stmt->Names.reserve(size);
+  for (unsigned i = 0; i < size; ++i) {
+    std::vector<char> data;
+    D.ReadCStr(data, false);
+
+    Stmt->Names.push_back(std::string(data.begin(), data.end()));
+  }    
+
+  Stmt->Constraints.reserve(size);
+  for (unsigned i = 0; i < size; ++i)
+    Stmt->Constraints.push_back(StringLiteral::CreateImpl(D));
+  
+  Stmt->Exprs.reserve(size);
+  for (unsigned i = 0; i < size; ++i)
+    Stmt->Exprs.push_back(D.ReadOwnedPtr<Expr>());
+  
+  unsigned NumClobbers = D.ReadInt();
+  Stmt->Clobbers.reserve(NumClobbers);
+  for (unsigned i = 0; i < NumClobbers; ++i)
+    Stmt->Clobbers.push_back(StringLiteral::CreateImpl(D));
+  
+  return Stmt;
+}
+
+void BinaryOperator::EmitImpl(Serializer& S) const {
+  S.EmitInt(Opc);
+  S.Emit(OpLoc);;
+  S.Emit(getType());
+  S.BatchEmitOwnedPtrs(getLHS(),getRHS());
+}
+
+BinaryOperator* BinaryOperator::CreateImpl(Deserializer& D) {
+  Opcode Opc = static_cast<Opcode>(D.ReadInt());
+  SourceLocation OpLoc = SourceLocation::ReadVal(D);
+  QualType Result = QualType::ReadVal(D);
+  Expr *LHS, *RHS;
+  D.BatchReadOwnedPtrs(LHS,RHS);
+
+  return new BinaryOperator(LHS,RHS,Opc,Result,OpLoc);
+}
+
+void BreakStmt::EmitImpl(Serializer& S) const {
+  S.Emit(BreakLoc);
+}
+
+BreakStmt* BreakStmt::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  return new BreakStmt(Loc);
+}
+
+void CallExpr::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(RParenLoc);
+  S.EmitInt(NumArgs);
+  S.BatchEmitOwnedPtrs(NumArgs+1,SubExprs);  
+}
+
+CallExpr* CallExpr::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  SourceLocation L = SourceLocation::ReadVal(D);
+  unsigned NumArgs = D.ReadInt();
+  Expr** SubExprs = new Expr*[NumArgs+1];
+  D.BatchReadOwnedPtrs(NumArgs+1,SubExprs);
+
+  return new CallExpr(SubExprs,NumArgs,t,L);  
+}
+
+void CaseStmt::EmitImpl(Serializer& S) const {
+  S.Emit(CaseLoc);
+  S.EmitPtr(getNextSwitchCase());
+  S.BatchEmitOwnedPtrs((unsigned) END_EXPR,&SubExprs[0]);
+}
+
+CaseStmt* CaseStmt::CreateImpl(Deserializer& D) {
+  SourceLocation CaseLoc = SourceLocation::ReadVal(D);
+  CaseStmt* stmt = new CaseStmt(NULL,NULL,NULL,CaseLoc);  
+  D.ReadPtr(stmt->NextSwitchCase);
+  D.BatchReadOwnedPtrs((unsigned) END_EXPR,&stmt->SubExprs[0]);
+  return stmt;
+}
+
+void CastExpr::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(Loc);
+  S.EmitOwnedPtr(Op);
+}
+
+CastExpr* CastExpr::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  Expr* Op = D.ReadOwnedPtr<Expr>();
+  return new CastExpr(t,Op,Loc);
+}
+  
+
+void CharacterLiteral::EmitImpl(Serializer& S) const {
+  S.Emit(Value);
+  S.Emit(Loc);
+  S.Emit(getType());
+}
+
+CharacterLiteral* CharacterLiteral::CreateImpl(Deserializer& D) {
+  unsigned value = D.ReadInt();
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  QualType T = QualType::ReadVal(D);
+  return new CharacterLiteral(value,T,Loc);
+}
+
+void CompoundAssignOperator::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(ComputationType);
+  S.Emit(getOperatorLoc());
+  S.EmitInt(getOpcode());
+  S.BatchEmitOwnedPtrs(getLHS(),getRHS());
+}
+
+CompoundAssignOperator* 
+CompoundAssignOperator::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  QualType c = QualType::ReadVal(D);
+  SourceLocation L = SourceLocation::ReadVal(D);
+  Opcode Opc = static_cast<Opcode>(D.ReadInt());
+  Expr* LHS, *RHS;
+  D.BatchReadOwnedPtrs(LHS,RHS);
+  
+  return new CompoundAssignOperator(LHS,RHS,Opc,t,c,L);
+}
+
+void CompoundLiteralExpr::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(getLParenLoc());
+  S.EmitBool(isFileScope());
+  S.EmitOwnedPtr(Init);
+}
+
+CompoundLiteralExpr* CompoundLiteralExpr::CreateImpl(Deserializer& D) {
+  QualType Q = QualType::ReadVal(D);
+  SourceLocation L = SourceLocation::ReadVal(D);
+  bool fileScope = D.ReadBool();
+  Expr* Init = D.ReadOwnedPtr<Expr>();
+  return new CompoundLiteralExpr(L, Q, Init, fileScope);
+}
+
+void CompoundStmt::EmitImpl(Serializer& S) const {
+  S.Emit(LBracLoc);
+  S.Emit(RBracLoc);
+  S.Emit(Body.size());
+  
+  for (const_body_iterator I=body_begin(), E=body_end(); I!=E; ++I)
+    S.EmitOwnedPtr(*I);
+}
+
+CompoundStmt* CompoundStmt::CreateImpl(Deserializer& D) {
+  SourceLocation LB = SourceLocation::ReadVal(D);
+  SourceLocation RB = SourceLocation::ReadVal(D);
+  unsigned size = D.ReadInt();
+  
+  CompoundStmt* stmt = new CompoundStmt(NULL,0,LB,RB);
+  
+  stmt->Body.reserve(size);
+  
+  for (unsigned i = 0; i < size; ++i)
+    stmt->Body.push_back(D.ReadOwnedPtr<Stmt>());
+  
+  return stmt;
+}
+
+void ConditionalOperator::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.BatchEmitOwnedPtrs((unsigned) END_EXPR, SubExprs);
+}
+
+ConditionalOperator* ConditionalOperator::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  ConditionalOperator* c = new ConditionalOperator(NULL,NULL,NULL,t);
+  D.BatchReadOwnedPtrs((unsigned) END_EXPR, c->SubExprs);
+  return c;
+}
+
+void ContinueStmt::EmitImpl(Serializer& S) const {
+  S.Emit(ContinueLoc);
+}
+
+ContinueStmt* ContinueStmt::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  return new ContinueStmt(Loc);
+}
+
+void DeclStmt::EmitImpl(Serializer& S) const {
+  // FIXME: special handling for struct decls.
+  S.EmitOwnedPtr(getDecl());  
+  S.Emit(StartLoc);
+  S.Emit(EndLoc);
+}
+
+void DeclRefExpr::EmitImpl(Serializer& S) const {
+  S.Emit(Loc);
+  S.Emit(getType());
+  
+  // Some DeclRefExprs can actually hold the owning reference to a FunctionDecl.
+  // This occurs when an implicitly defined function is called, and
+  // the decl does not appear in the source file.  We thus check if the
+  // decl pointer has been registered, and if not, emit an owned pointer.
+
+  // FIXME: While this will work for serialization, it won't work for
+  //  memory management.  The only reason this works for serialization is
+  //  because we are tracking all serialized pointers.  Either DeclRefExpr
+  //  needs an explicit bit indicating that it owns the the object,
+  //  or we need a different ownership model.
+  
+  const Decl* d = getDecl();
+  
+  if (!S.isRegistered(d)) {
+    assert (isa<FunctionDecl>(d) 
+     && "DeclRefExpr can only own FunctionDecls for implicitly def. funcs.");
+
+    S.EmitBool(true);
+    S.EmitOwnedPtr(d);
+  }
+  else {
+    S.EmitBool(false);
+    S.EmitPtr(d);
+  }
+}
+
+DeclRefExpr* DeclRefExpr::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  QualType T = QualType::ReadVal(D);  
+  bool OwnsDecl = D.ReadBool();
+  ValueDecl* decl;
+  
+  if (!OwnsDecl)
+    D.ReadPtr(decl,false); // No backpatching.
+  else
+    decl = cast<ValueDecl>(D.ReadOwnedPtr<Decl>());
+  
+  return new DeclRefExpr(decl,T,Loc);
+}
+
+
+DeclStmt* DeclStmt::CreateImpl(Deserializer& D) {
+  ScopedDecl* decl = cast<ScopedDecl>(D.ReadOwnedPtr<Decl>());
+  SourceLocation StartLoc = SourceLocation::ReadVal(D);
+  SourceLocation EndLoc = SourceLocation::ReadVal(D);
+  return new DeclStmt(decl, StartLoc, EndLoc);
+}
+
+void DefaultStmt::EmitImpl(Serializer& S) const {
+  S.Emit(DefaultLoc);
+  S.EmitOwnedPtr(getSubStmt());
+  S.EmitPtr(getNextSwitchCase());
+}
+
+DefaultStmt* DefaultStmt::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  Stmt* SubStmt = D.ReadOwnedPtr<Stmt>();
+  
+  DefaultStmt* stmt = new DefaultStmt(Loc,SubStmt);
+  stmt->setNextSwitchCase(D.ReadPtr<SwitchCase>());
+  
+  return stmt;
+}
+
+void DoStmt::EmitImpl(Serializer& S) const {
+  S.Emit(DoLoc);
+  S.EmitOwnedPtr(getCond());
+  S.EmitOwnedPtr(getBody());
+}
+
+DoStmt* DoStmt::CreateImpl(Deserializer& D) {
+  SourceLocation DoLoc = SourceLocation::ReadVal(D);
+  Expr* Cond = D.ReadOwnedPtr<Expr>();
+  Stmt* Body = D.ReadOwnedPtr<Stmt>();
+  return new DoStmt(Body,Cond,DoLoc);
+}
+
+void FloatingLiteral::EmitImpl(Serializer& S) const {
+  S.Emit(Loc);
+  S.Emit(getType());
+  S.EmitBool(isExact());
+  S.Emit(Value);
+}
+
+FloatingLiteral* FloatingLiteral::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  QualType t = QualType::ReadVal(D);
+  bool isExact = D.ReadBool();
+  llvm::APFloat Val = llvm::APFloat::ReadVal(D);
+  FloatingLiteral* expr = new FloatingLiteral(Val,&isExact,t,Loc);
+  return expr;
+}
+
+void ForStmt::EmitImpl(Serializer& S) const {
+  S.Emit(ForLoc);
+  S.EmitOwnedPtr(getInit());
+  S.EmitOwnedPtr(getCond());
+  S.EmitOwnedPtr(getInc());
+  S.EmitOwnedPtr(getBody());
+}
+
+ForStmt* ForStmt::CreateImpl(Deserializer& D) {
+  SourceLocation ForLoc = SourceLocation::ReadVal(D);
+  Stmt* Init = D.ReadOwnedPtr<Stmt>();
+  Expr* Cond = D.ReadOwnedPtr<Expr>();
+  Expr* Inc = D.ReadOwnedPtr<Expr>();
+  Stmt* Body = D.ReadOwnedPtr<Stmt>();
+  return new ForStmt(Init,Cond,Inc,Body,ForLoc);
+}
+
+void GotoStmt::EmitImpl(Serializer& S) const {
+  S.Emit(GotoLoc);
+  S.Emit(LabelLoc);
+  S.EmitPtr(Label);
+}
+
+GotoStmt* GotoStmt::CreateImpl(Deserializer& D) {
+  SourceLocation GotoLoc = SourceLocation::ReadVal(D);
+  SourceLocation LabelLoc = SourceLocation::ReadVal(D);
+  GotoStmt* stmt = new GotoStmt(NULL,GotoLoc,LabelLoc);
+  D.ReadPtr(stmt->Label); // This pointer may be backpatched later.
+  return stmt;  
+}
+
+void IfStmt::EmitImpl(Serializer& S) const {
+  S.Emit(IfLoc);
+  S.EmitOwnedPtr(getCond());
+  S.EmitOwnedPtr(getThen());
+  S.EmitOwnedPtr(getElse());
+}
+
+IfStmt* IfStmt::CreateImpl(Deserializer& D) {
+  SourceLocation L = SourceLocation::ReadVal(D);
+  Expr* Cond = D.ReadOwnedPtr<Expr>();
+  Stmt* Then = D.ReadOwnedPtr<Stmt>();
+  Stmt* Else = D.ReadOwnedPtr<Stmt>();
+  return new IfStmt(L,Cond,Then,Else);
+}
+
+void ImaginaryLiteral::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.EmitOwnedPtr(Val);    
+}
+
+ImaginaryLiteral* ImaginaryLiteral::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  Expr* expr = D.ReadOwnedPtr<Expr>();
+  assert (isa<FloatingLiteral>(expr) || isa<IntegerLiteral>(expr));
+  return new ImaginaryLiteral(expr,t);
+}
+
+void ImplicitCastExpr::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.EmitOwnedPtr(Op);
+}
+
+ImplicitCastExpr* ImplicitCastExpr::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  Expr* Op = D.ReadOwnedPtr<Expr>();
+  return new ImplicitCastExpr(t,Op);
+}
+
+void IndirectGotoStmt::EmitImpl(Serializer& S) const {
+  S.EmitOwnedPtr(Target);  
+}
+
+IndirectGotoStmt* IndirectGotoStmt::CreateImpl(Deserializer& D) {
+  Expr* Target = D.ReadOwnedPtr<Expr>();
+  return new IndirectGotoStmt(Target);
+}
+
+void InitListExpr::EmitImpl(Serializer& S) const {
+  S.Emit(LBraceLoc);
+  S.Emit(RBraceLoc);
+  S.EmitInt(NumInits);
+  S.BatchEmitOwnedPtrs(NumInits,InitExprs);
+}
+
+InitListExpr* InitListExpr::CreateImpl(Deserializer& D) {
+  InitListExpr* expr = new InitListExpr();
+  expr->LBraceLoc = SourceLocation::ReadVal(D);
+  expr->RBraceLoc = SourceLocation::ReadVal(D);
+  expr->NumInits = D.ReadInt();
+  assert(expr->NumInits);
+  expr->InitExprs = new Expr*[expr->NumInits];
+  D.BatchReadOwnedPtrs(expr->NumInits,expr->InitExprs);
+  return expr;
+}
+
+void IntegerLiteral::EmitImpl(Serializer& S) const {
+  S.Emit(Loc);
+  S.Emit(getType());
+  S.Emit(getValue());
+}
+
+IntegerLiteral* IntegerLiteral::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  QualType T = QualType::ReadVal(D);
+  
+  // Create a dummy APInt because it is more efficient to deserialize
+  // it in place with the deserialized IntegerLiteral. (fewer copies)
+  llvm::APInt temp;  
+  IntegerLiteral* expr = new IntegerLiteral(temp,T,Loc);
+  D.Read(expr->Value);
+  
+  return expr;
+}
+
+void LabelStmt::EmitImpl(Serializer& S) const {
+  S.EmitPtr(Label);
+  S.Emit(IdentLoc);
+  S.EmitOwnedPtr(SubStmt);
+}
+
+LabelStmt* LabelStmt::CreateImpl(Deserializer& D) {
+  IdentifierInfo* Label = D.ReadPtr<IdentifierInfo>();
+  SourceLocation IdentLoc = SourceLocation::ReadVal(D);
+  Stmt* SubStmt = D.ReadOwnedPtr<Stmt>();
+  return new LabelStmt(IdentLoc,Label,SubStmt);
+}
+
+void MemberExpr::EmitImpl(Serializer& S) const {
+  S.Emit(MemberLoc);
+  S.EmitPtr(MemberDecl);
+  S.EmitBool(IsArrow);
+  S.Emit(getType());
+  S.EmitOwnedPtr(Base);
+}
+
+MemberExpr* MemberExpr::CreateImpl(Deserializer& D) {
+  SourceLocation L = SourceLocation::ReadVal(D);
+  FieldDecl* MemberDecl = cast<FieldDecl>(D.ReadPtr<Decl>());
+  bool IsArrow = D.ReadBool();
+  QualType T = QualType::ReadVal(D);
+  Expr* base = D.ReadOwnedPtr<Expr>();
+  
+  return new MemberExpr(base,IsArrow,MemberDecl,L,T); 
+}
+
+void NullStmt::EmitImpl(Serializer& S) const {
+  S.Emit(SemiLoc);
+}
+
+NullStmt* NullStmt::CreateImpl(Deserializer& D) {
+  SourceLocation SemiLoc = SourceLocation::ReadVal(D);
+  return new NullStmt(SemiLoc);
+}
+
+void ParenExpr::EmitImpl(Serializer& S) const {
+  S.Emit(L);
+  S.Emit(R);
+  S.EmitOwnedPtr(Val);
+}
+
+ParenExpr* ParenExpr::CreateImpl(Deserializer& D) {
+  SourceLocation L = SourceLocation::ReadVal(D);
+  SourceLocation R = SourceLocation::ReadVal(D);
+  Expr* val = D.ReadOwnedPtr<Expr>();  
+  return new ParenExpr(L,R,val);
+}
+
+void PreDefinedExpr::EmitImpl(Serializer& S) const {
+  S.Emit(Loc);
+  S.EmitInt(getIdentType());
+  S.Emit(getType());  
+}
+
+PreDefinedExpr* PreDefinedExpr::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  IdentType it = static_cast<IdentType>(D.ReadInt());
+  QualType Q = QualType::ReadVal(D);
+  return new PreDefinedExpr(Loc,Q,it);
+}
+
+void ReturnStmt::EmitImpl(Serializer& S) const {
+  S.Emit(RetLoc);
+  S.EmitOwnedPtr(RetExpr);
+}
+
+ReturnStmt* ReturnStmt::CreateImpl(Deserializer& D) {
+  SourceLocation RetLoc = SourceLocation::ReadVal(D);
+  Expr* RetExpr = D.ReadOwnedPtr<Expr>();  
+  return new ReturnStmt(RetLoc,RetExpr);
+}
+
+void SizeOfAlignOfTypeExpr::EmitImpl(Serializer& S) const {
+  S.EmitBool(isSizeof);
+  S.Emit(Ty);
+  S.Emit(getType());
+  S.Emit(OpLoc);
+  S.Emit(RParenLoc);
+}
+
+SizeOfAlignOfTypeExpr* SizeOfAlignOfTypeExpr::CreateImpl(Deserializer& D) {
+  bool isSizeof = D.ReadBool();
+  QualType Ty = QualType::ReadVal(D);
+  QualType Res = QualType::ReadVal(D);
+  SourceLocation OpLoc = SourceLocation::ReadVal(D);
+  SourceLocation RParenLoc = SourceLocation::ReadVal(D);
+  
+  return new SizeOfAlignOfTypeExpr(isSizeof,Ty,Res,OpLoc,RParenLoc);  
+}
+
+void StmtExpr::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(LParenLoc);
+  S.Emit(RParenLoc);
+  S.EmitOwnedPtr(SubStmt);
+}
+
+StmtExpr* StmtExpr::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  SourceLocation L = SourceLocation::ReadVal(D);
+  SourceLocation R = SourceLocation::ReadVal(D);
+  CompoundStmt* SubStmt = cast<CompoundStmt>(D.ReadOwnedPtr<Stmt>());
+  return new StmtExpr(SubStmt,t,L,R);
+}
+
+void StringLiteral::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(firstTokLoc);
+  S.Emit(lastTokLoc);
+  S.EmitBool(isWide());
+  S.Emit(getByteLength());
+
+  for (unsigned i = 0 ; i < ByteLength; ++i)
+    S.EmitInt(StrData[i]);
+}
+
+StringLiteral* StringLiteral::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  SourceLocation firstTokLoc = SourceLocation::ReadVal(D);
+  SourceLocation lastTokLoc = SourceLocation::ReadVal(D);
+  bool isWide = D.ReadBool();
+  unsigned ByteLength = D.ReadInt();
+  
+  StringLiteral* sl = new StringLiteral(NULL,0,isWide,t,firstTokLoc,lastTokLoc);
+
+  char* StrData = new char[ByteLength];
+  for (unsigned i = 0; i < ByteLength; ++i)
+    StrData[i] = (char) D.ReadInt();
+
+  sl->ByteLength = ByteLength;
+  sl->StrData = StrData;
+  
+  return sl;
+}
+
+void SwitchStmt::EmitImpl(Serializer& S) const {
+  S.Emit(SwitchLoc);
+  S.EmitOwnedPtr(getCond());
+  S.EmitOwnedPtr(getBody());
+  S.EmitPtr(FirstCase);  
+}
+
+SwitchStmt* SwitchStmt::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  Stmt* Cond = D.ReadOwnedPtr<Stmt>();
+  Stmt* Body = D.ReadOwnedPtr<Stmt>();
+  SwitchCase* FirstCase = cast<SwitchCase>(D.ReadPtr<Stmt>());
+  
+  SwitchStmt* stmt = new SwitchStmt(cast<Expr>(Cond));
+  stmt->setBody(Body,Loc);
+  stmt->FirstCase = FirstCase;
+  
+  return stmt;
+}
+
+void UnaryOperator::EmitImpl(Serializer& S) const {
+  S.Emit(getType());
+  S.Emit(Loc);
+  S.EmitInt(Opc);
+  S.EmitOwnedPtr(Val);
+}
+
+UnaryOperator* UnaryOperator::CreateImpl(Deserializer& D) {
+  QualType t = QualType::ReadVal(D);
+  SourceLocation L = SourceLocation::ReadVal(D);
+  Opcode Opc = static_cast<Opcode>(D.ReadInt());
+  Expr* Val = D.ReadOwnedPtr<Expr>();
+  return new UnaryOperator(Val,Opc,t,L);
+}
+
+void WhileStmt::EmitImpl(Serializer& S) const {
+  S.Emit(WhileLoc);
+  S.EmitOwnedPtr(getCond());
+  S.EmitOwnedPtr(getBody());
+}
+
+WhileStmt* WhileStmt::CreateImpl(Deserializer& D) {
+  SourceLocation WhileLoc = SourceLocation::ReadVal(D);
+  Expr* Cond = D.ReadOwnedPtr<Expr>();
+  Stmt* Body = D.ReadOwnedPtr<Stmt>();
+  return new WhileStmt(Cond,Body,WhileLoc);
+}
+
+//===----------------------------------------------------------------------===//
+//   Objective C Serialization
+//===----------------------------------------------------------------------===//
+
+void ObjCAtCatchStmt::EmitImpl(Serializer& S) const {
+  S.Emit(AtCatchLoc);
+  S.Emit(RParenLoc);
+  S.BatchEmitOwnedPtrs((unsigned) END_EXPR, &SubExprs[0]);
+}
+
+ObjCAtCatchStmt* ObjCAtCatchStmt::CreateImpl(Deserializer& D) {
+  SourceLocation AtCatchLoc = SourceLocation::ReadVal(D);
+  SourceLocation RParenLoc = SourceLocation::ReadVal(D);
+  
+  ObjCAtCatchStmt* stmt = new ObjCAtCatchStmt(AtCatchLoc,RParenLoc);
+  D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubExprs[0]);
+
+  return stmt;
+}
+
+void ObjCAtFinallyStmt::EmitImpl(Serializer& S) const {
+  S.Emit(AtFinallyLoc);
+  S.EmitOwnedPtr(AtFinallyStmt);
+}
+
+ObjCAtFinallyStmt* ObjCAtFinallyStmt::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  Stmt* AtFinallyStmt = D.ReadOwnedPtr<Stmt>();
+  return new ObjCAtFinallyStmt(Loc,AtFinallyStmt);  
+}
+
+void ObjCAtSynchronizedStmt::EmitImpl(Serializer& S) const {
+  S.Emit(AtSynchronizedLoc);
+  S.BatchEmitOwnedPtrs((unsigned) END_EXPR,&SubStmts[0]);
+ }
+
+ObjCAtSynchronizedStmt* ObjCAtSynchronizedStmt::CreateImpl(Deserializer& D) {
+  SourceLocation L = SourceLocation::ReadVal(D);
+  ObjCAtSynchronizedStmt* stmt = new ObjCAtSynchronizedStmt(L,0,0);
+  D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubStmts[0]);
+  return stmt;
+}
+
+void ObjCAtThrowStmt::EmitImpl(Serializer& S) const {
+  S.Emit(AtThrowLoc);
+  S.EmitOwnedPtr(Throw);
+}
+
+ObjCAtThrowStmt* ObjCAtThrowStmt::CreateImpl(Deserializer& D) {
+  SourceLocation L = SourceLocation::ReadVal(D);
+  Stmt* Throw = D.ReadOwnedPtr<Stmt>();
+  return new ObjCAtThrowStmt(L,Throw);  
+}
+  
+void ObjCAtTryStmt::EmitImpl(Serializer& S) const {
+  S.Emit(AtTryLoc);
+  S.BatchEmitOwnedPtrs((unsigned) END_EXPR, &SubStmts[0]);
+}
+
+ObjCAtTryStmt* ObjCAtTryStmt::CreateImpl(Deserializer& D) {
+  SourceLocation L = SourceLocation::ReadVal(D);
+  ObjCAtTryStmt* stmt = new ObjCAtTryStmt(L,NULL,NULL,NULL);
+  D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubStmts[0]);
+  return stmt;
+}
+
+void ObjCEncodeExpr::EmitImpl(Serializer& S) const {
+  S.Emit(AtLoc);
+  S.Emit(RParenLoc);
+  S.Emit(getType());
+  S.Emit(EncType);
+}
+
+ObjCEncodeExpr* ObjCEncodeExpr::CreateImpl(Deserializer& D) {
+  SourceLocation AtLoc = SourceLocation::ReadVal(D);
+  SourceLocation RParenLoc = SourceLocation::ReadVal(D);  
+  QualType T = QualType::ReadVal(D);
+  QualType ET = QualType::ReadVal(D);
+  return new ObjCEncodeExpr(T,ET,AtLoc,RParenLoc);
+}
+
+void ObjCForCollectionStmt::EmitImpl(Serializer& S) const {
+  S.Emit(ForLoc);
+  S.Emit(RParenLoc);
+  S.BatchEmitOwnedPtrs(getElement(),getCollection(),getBody());
+}
+
+ObjCForCollectionStmt* ObjCForCollectionStmt::CreateImpl(Deserializer& D) {
+  SourceLocation ForLoc = SourceLocation::ReadVal(D);
+  SourceLocation RParenLoc = SourceLocation::ReadVal(D);
+  Stmt* Element;
+  Expr* Collection;
+  Stmt* Body;
+  D.BatchReadOwnedPtrs(Element,Collection,Body);  
+  return new ObjCForCollectionStmt(Element,Collection,Body,ForLoc, RParenLoc);
+}
+
+void ObjCIvarRefExpr::EmitImpl(Serializer& S) const {
+  S.Emit(Loc);
+  S.Emit(getType());
+  S.EmitPtr(getDecl());
+}
+  
+ObjCIvarRefExpr* ObjCIvarRefExpr::CreateImpl(Deserializer& D) {
+  SourceLocation Loc = SourceLocation::ReadVal(D);
+  QualType T = QualType::ReadVal(D);
+  ObjCIvarRefExpr* dr = new ObjCIvarRefExpr(NULL,T,Loc);
+  D.ReadPtr(dr->D,false);  
+  return dr;
+}
+
+void ObjCSelectorExpr::EmitImpl(Serializer& S) const {
+  S.Emit(AtLoc);
+  S.Emit(RParenLoc);
+  S.Emit(getType());
+  S.Emit(SelName);
+}
+
+ObjCSelectorExpr* ObjCSelectorExpr::CreateImpl(Deserializer& D) {
+  SourceLocation AtLoc = SourceLocation::ReadVal(D);
+  SourceLocation RParenLoc = SourceLocation::ReadVal(D);
+  QualType T = QualType::ReadVal(D);
+  Selector SelName = Selector::ReadVal(D);
+  
+  return new ObjCSelectorExpr(T,SelName,AtLoc,RParenLoc);
+}
+
+void ObjCStringLiteral::EmitImpl(Serializer& S) const {
+  S.Emit(AtLoc);
+  S.Emit(getType());
+  S.EmitOwnedPtr(String);
+}
+
+ObjCStringLiteral* ObjCStringLiteral::CreateImpl(Deserializer& D) {
+  SourceLocation L = SourceLocation::ReadVal(D);
+  QualType T = QualType::ReadVal(D);
+  StringLiteral* String = cast<StringLiteral>(D.ReadOwnedPtr<Stmt>());
+  return new ObjCStringLiteral(String,T,L);
+}