diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/AST/DeclSerialization.cpp | 123 | ||||
| -rw-r--r-- | lib/AST/StmtSerialization.cpp | 295 | ||||
| -rw-r--r-- | lib/AST/TranslationUnit.cpp | 2 | ||||
| -rw-r--r-- | lib/AST/TypeSerialization.cpp | 4 |
4 files changed, 215 insertions, 209 deletions
diff --git a/lib/AST/DeclSerialization.cpp b/lib/AST/DeclSerialization.cpp index a2e9ce1b12..bc5310c414 100644 --- a/lib/AST/DeclSerialization.cpp +++ b/lib/AST/DeclSerialization.cpp @@ -31,45 +31,45 @@ void Decl::Emit(Serializer& S) const { EmitImpl(S); } -Decl* Decl::Create(Deserializer& D) { +Decl* Decl::Create(Deserializer& D, ASTContext& C) { Kind k = static_cast<Kind>(D.ReadInt()); - + switch (k) { default: assert (false && "Not implemented."); break; case BlockVar: - return BlockVarDecl::CreateImpl(D); + return BlockVarDecl::CreateImpl(D, C); case Enum: - return EnumDecl::CreateImpl(D); + return EnumDecl::CreateImpl(D, C); case EnumConstant: - return EnumConstantDecl::CreateImpl(D); + return EnumConstantDecl::CreateImpl(D, C); case Field: - return FieldDecl::CreateImpl(D); + return FieldDecl::CreateImpl(D, C); case FileVar: - return FileVarDecl::CreateImpl(D); + return FileVarDecl::CreateImpl(D, C); case ParmVar: - return ParmVarDecl::CreateImpl(D); + return ParmVarDecl::CreateImpl(D, C); case Function: - return FunctionDecl::CreateImpl(D); + return FunctionDecl::CreateImpl(D, C); case Union: case Struct: - return RecordDecl::CreateImpl(k,D); + return RecordDecl::CreateImpl(k, D, C); case Typedef: - return TypedefDecl::CreateImpl(D); + return TypedefDecl::CreateImpl(D, C); case FileScopeAsm: - return FileScopeAsmDecl::CreateImpl(D); + return FileScopeAsmDecl::CreateImpl(D, C); } } @@ -81,7 +81,7 @@ void Decl::EmitInRec(Serializer& S) const { S.Emit(getLocation()); // From Decl. } -void Decl::ReadInRec(Deserializer& D) { +void Decl::ReadInRec(Deserializer& D, ASTContext& C) { Loc = SourceLocation::ReadVal(D); // From Decl. } @@ -94,8 +94,8 @@ void NamedDecl::EmitInRec(Serializer& S) const { S.EmitPtr(getIdentifier()); // From NamedDecl. } -void NamedDecl::ReadInRec(Deserializer& D) { - Decl::ReadInRec(D); +void NamedDecl::ReadInRec(Deserializer& D, ASTContext& C) { + Decl::ReadInRec(D, C); D.ReadPtr(Identifier); // From NamedDecl. } @@ -109,8 +109,8 @@ void ScopedDecl::EmitInRec(Serializer& S) const { S.EmitPtr(cast_or_null<Decl>(getDeclContext())); // From ScopedDecl. } -void ScopedDecl::ReadInRec(Deserializer& D) { - NamedDecl::ReadInRec(D); +void ScopedDecl::ReadInRec(Deserializer& D, ASTContext& C) { + NamedDecl::ReadInRec(D, C); D.ReadPtr(Next); // From ScopedDecl. Decl *TmpD; D.ReadPtr(TmpD); // From ScopedDecl. @@ -127,9 +127,9 @@ void ScopedDecl::EmitOutRec(Serializer& S) const { S.EmitOwnedPtr(getNextDeclarator()); // From ScopedDecl. } -void ScopedDecl::ReadOutRec(Deserializer& D) { +void ScopedDecl::ReadOutRec(Deserializer& D, ASTContext& C) { NextDeclarator = - cast_or_null<ScopedDecl>(D.ReadOwnedPtr<Decl>()); // From ScopedDecl. + cast_or_null<ScopedDecl>(D.ReadOwnedPtr<Decl>(C)); // From ScopedDecl. } //===----------------------------------------------------------------------===// @@ -141,8 +141,8 @@ void ValueDecl::EmitInRec(Serializer& S) const { S.Emit(getType()); // From ValueDecl. } -void ValueDecl::ReadInRec(Deserializer& D) { - ScopedDecl::ReadInRec(D); +void ValueDecl::ReadInRec(Deserializer& D, ASTContext& C) { + ScopedDecl::ReadInRec(D, C); DeclType = QualType::ReadVal(D); // From ValueDecl. } @@ -155,8 +155,8 @@ void VarDecl::EmitInRec(Serializer& S) const { S.EmitInt(getStorageClass()); // From VarDecl. } -void VarDecl::ReadInRec(Deserializer& D) { - ValueDecl::ReadInRec(D); +void VarDecl::ReadInRec(Deserializer& D, ASTContext& C) { + ValueDecl::ReadInRec(D, C); SClass = static_cast<StorageClass>(D.ReadInt()); // From VarDecl. } @@ -172,11 +172,12 @@ void VarDecl::EmitOutRec(Serializer& S) const { getNextDeclarator()); // From ScopedDecl. } -void VarDecl::ReadOutRec(Deserializer& D) { +void VarDecl::ReadOutRec(Deserializer& D, ASTContext& C) { Decl* next_declarator; - D.BatchReadOwnedPtrs(Init, // From VarDecl. - next_declarator); // From ScopedDecl. + D.BatchReadOwnedPtrs(Init, // From VarDecl. + next_declarator, // From ScopedDecl. + C); setNextDeclarator(cast_or_null<ScopedDecl>(next_declarator)); } @@ -187,20 +188,20 @@ void VarDecl::EmitImpl(Serializer& S) const { VarDecl::EmitOutRec(S); } -void VarDecl::ReadImpl(Deserializer& D) { - ReadInRec(D); - ReadOutRec(D); +void VarDecl::ReadImpl(Deserializer& D, ASTContext& C) { + ReadInRec(D, C); + ReadOutRec(D, C); } //===----------------------------------------------------------------------===// // BlockVarDecl Serialization. //===----------------------------------------------------------------------===// -BlockVarDecl* BlockVarDecl::CreateImpl(Deserializer& D) { +BlockVarDecl* BlockVarDecl::CreateImpl(Deserializer& D, ASTContext& C) { BlockVarDecl* decl = new BlockVarDecl(0, SourceLocation(),NULL,QualType(),None,NULL); - decl->VarDecl::ReadImpl(D); + decl->VarDecl::ReadImpl(D, C); return decl; } @@ -209,11 +210,11 @@ BlockVarDecl* BlockVarDecl::CreateImpl(Deserializer& D) { // FileVarDecl Serialization. //===----------------------------------------------------------------------===// -FileVarDecl* FileVarDecl::CreateImpl(Deserializer& D) { +FileVarDecl* FileVarDecl::CreateImpl(Deserializer& D, ASTContext& C) { FileVarDecl* decl = new FileVarDecl(0, SourceLocation(),NULL,QualType(),None,NULL); - decl->VarDecl::ReadImpl(D); + decl->VarDecl::ReadImpl(D, C); return decl; } @@ -227,11 +228,11 @@ void ParmVarDecl::EmitImpl(llvm::Serializer& S) const { S.EmitInt(getObjCDeclQualifier()); // From ParmVarDecl. } -ParmVarDecl* ParmVarDecl::CreateImpl(Deserializer& D) { +ParmVarDecl* ParmVarDecl::CreateImpl(Deserializer& D, ASTContext& C) { ParmVarDecl* decl = new ParmVarDecl(0, SourceLocation(),NULL,QualType(),None,NULL); - decl->VarDecl::ReadImpl(D); + decl->VarDecl::ReadImpl(D, C); decl->objcDeclQualifier = static_cast<ObjCDeclQualifier>(D.ReadInt()); return decl; @@ -248,17 +249,17 @@ void EnumDecl::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs(ElementList,getNextDeclarator()); } -EnumDecl* EnumDecl::CreateImpl(Deserializer& D) { +EnumDecl* EnumDecl::CreateImpl(Deserializer& D, ASTContext& C) { EnumDecl* decl = new EnumDecl(0, SourceLocation(),NULL,NULL); - decl->ScopedDecl::ReadInRec(D); + decl->ScopedDecl::ReadInRec(D, C); decl->setDefinition(D.ReadBool()); decl->IntegerType = QualType::ReadVal(D); Decl* next_declarator; Decl* Elist; - D.BatchReadOwnedPtrs(Elist,next_declarator); + D.BatchReadOwnedPtrs(Elist, next_declarator, C); decl->ElementList = cast_or_null<EnumConstantDecl>(Elist); decl->setNextDeclarator(cast_or_null<ScopedDecl>(next_declarator)); @@ -276,7 +277,7 @@ void EnumConstantDecl::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs(getNextDeclarator(),Init); } -EnumConstantDecl* EnumConstantDecl::CreateImpl(Deserializer& D) { +EnumConstantDecl* EnumConstantDecl::CreateImpl(Deserializer& D, ASTContext& C) { llvm::APSInt val(1); D.Read(val); @@ -284,11 +285,11 @@ EnumConstantDecl* EnumConstantDecl::CreateImpl(Deserializer& D) { new EnumConstantDecl(0, SourceLocation(),NULL,QualType(),NULL, val,NULL); - decl->ValueDecl::ReadInRec(D); + decl->ValueDecl::ReadInRec(D, C); Decl* next_declarator; - D.BatchReadOwnedPtrs(next_declarator,decl->Init); + D.BatchReadOwnedPtrs(next_declarator, decl->Init, C); decl->setNextDeclarator(cast_or_null<ScopedDecl>(next_declarator)); @@ -305,11 +306,11 @@ void FieldDecl::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(BitWidth); } -FieldDecl* FieldDecl::CreateImpl(Deserializer& D) { +FieldDecl* FieldDecl::CreateImpl(Deserializer& D, ASTContext& C) { FieldDecl* decl = new FieldDecl(SourceLocation(), NULL, QualType(), 0); decl->DeclType.ReadBackpatch(D); - decl->ReadInRec(D); - decl->BitWidth = D.ReadOwnedPtr<Expr>(); + decl->ReadInRec(D, C); + decl->BitWidth = D.ReadOwnedPtr<Expr>(C); return decl; } @@ -337,14 +338,14 @@ void FunctionDecl::EmitImpl(Serializer& S) const { } } -FunctionDecl* FunctionDecl::CreateImpl(Deserializer& D) { +FunctionDecl* FunctionDecl::CreateImpl(Deserializer& D, ASTContext& C) { StorageClass SClass = static_cast<StorageClass>(D.ReadInt()); bool IsInline = D.ReadBool(); FunctionDecl* decl = new FunctionDecl(0, SourceLocation(),NULL,QualType(),SClass, IsInline, 0); - decl->ValueDecl::ReadInRec(D); + decl->ValueDecl::ReadInRec(D, C); D.ReadPtr(decl->DeclChain); Decl* next_declarator; @@ -358,9 +359,9 @@ FunctionDecl* FunctionDecl::CreateImpl(Deserializer& D) { if (hasParamDecls) D.BatchReadOwnedPtrs(decl->getNumParams(), reinterpret_cast<Decl**>(&decl->ParamInfo[0]), - decl->Body, next_declarator); + decl->Body, next_declarator, C); else - D.BatchReadOwnedPtrs(decl->Body, next_declarator); + D.BatchReadOwnedPtrs(decl->Body, next_declarator, C); decl->setNextDeclarator(cast_or_null<ScopedDecl>(next_declarator)); @@ -385,10 +386,12 @@ void RecordDecl::EmitImpl(Serializer& S) const { ScopedDecl::EmitOutRec(S); } -RecordDecl* RecordDecl::CreateImpl(Decl::Kind DK, Deserializer& D) { +RecordDecl* RecordDecl::CreateImpl(Decl::Kind DK, Deserializer& D, + ASTContext& C) { + RecordDecl* decl = new RecordDecl(DK,0,SourceLocation(),NULL,NULL); - decl->ScopedDecl::ReadInRec(D); + decl->ScopedDecl::ReadInRec(D, C); decl->setDefinition(D.ReadBool()); decl->setHasFlexibleArrayMember(D.ReadBool()); decl->NumMembers = D.ReadSInt(); @@ -399,12 +402,12 @@ RecordDecl* RecordDecl::CreateImpl(Decl::Kind DK, Deserializer& D) { D.BatchReadOwnedPtrs((unsigned) decl->getNumMembers(), (Decl**) &decl->Members[0], - next_declarator); + next_declarator, C); decl->setNextDeclarator(cast_or_null<ScopedDecl>(next_declarator)); } else - decl->ScopedDecl::ReadOutRec(D); + decl->ScopedDecl::ReadOutRec(D, C); return decl; } @@ -419,13 +422,13 @@ void TypedefDecl::EmitImpl(Serializer& S) const { ScopedDecl::EmitOutRec(S); } -TypedefDecl* TypedefDecl::CreateImpl(Deserializer& D) { +TypedefDecl* TypedefDecl::CreateImpl(Deserializer& D, ASTContext& C) { QualType T = QualType::ReadVal(D); TypedefDecl* decl = new TypedefDecl(0, SourceLocation(),NULL,T,NULL); - decl->ScopedDecl::ReadInRec(D); - decl->ScopedDecl::ReadOutRec(D); + decl->ScopedDecl::ReadInRec(D, C); + decl->ScopedDecl::ReadOutRec(D, C); return decl; } @@ -440,8 +443,8 @@ void LinkageSpecDecl::EmitInRec(Serializer& S) const { S.EmitPtr(D); } -void LinkageSpecDecl::ReadInRec(Deserializer& D) { - Decl::ReadInRec(D); +void LinkageSpecDecl::ReadInRec(Deserializer& D, ASTContext& C) { + Decl::ReadInRec(D, C); Language = static_cast<LanguageIDs>(D.ReadInt()); D.ReadPtr(this->D); } @@ -456,11 +459,11 @@ void FileScopeAsmDecl::EmitImpl(llvm::Serializer& S) const S.EmitOwnedPtr(AsmString); } -FileScopeAsmDecl* FileScopeAsmDecl::CreateImpl(Deserializer& D) { +FileScopeAsmDecl* FileScopeAsmDecl::CreateImpl(Deserializer& D, ASTContext& C) { FileScopeAsmDecl* decl = new FileScopeAsmDecl(SourceLocation(), 0); - decl->Decl::ReadInRec(D); - decl->AsmString = cast<StringLiteral>(D.ReadOwnedPtr<Expr>()); + decl->Decl::ReadInRec(D, C); + decl->AsmString = cast<StringLiteral>(D.ReadOwnedPtr<Expr>(C)); // D.ReadOwnedPtr(D.ReadOwnedPtr<StringLiteral>())<#T * * Ptr#>, <#bool AutoRegister#>)(decl->AsmString); return decl; diff --git a/lib/AST/StmtSerialization.cpp b/lib/AST/StmtSerialization.cpp index 433e8e2702..41569df8f2 100644 --- a/lib/AST/StmtSerialization.cpp +++ b/lib/AST/StmtSerialization.cpp @@ -27,7 +27,7 @@ void Stmt::Emit(Serializer& S) const { S.FlushRecord(); } -Stmt* Stmt::Create(Deserializer& D) { +Stmt* Stmt::Create(Deserializer& D, ASTContext& C) { StmtClass SC = static_cast<StmtClass>(D.ReadInt()); switch (SC) { @@ -36,155 +36,155 @@ Stmt* Stmt::Create(Deserializer& D) { return NULL; case AddrLabelExprClass: - return AddrLabelExpr::CreateImpl(D); + return AddrLabelExpr::CreateImpl(D, C); case ArraySubscriptExprClass: - return ArraySubscriptExpr::CreateImpl(D); + return ArraySubscriptExpr::CreateImpl(D, C); case AsmStmtClass: - return AsmStmt::CreateImpl(D); + return AsmStmt::CreateImpl(D, C); case BinaryOperatorClass: - return BinaryOperator::CreateImpl(D); + return BinaryOperator::CreateImpl(D, C); case BreakStmtClass: - return BreakStmt::CreateImpl(D); + return BreakStmt::CreateImpl(D, C); case CallExprClass: - return CallExpr::CreateImpl(D); + return CallExpr::CreateImpl(D, C); case CaseStmtClass: - return CaseStmt::CreateImpl(D); + return CaseStmt::CreateImpl(D, C); case CastExprClass: - return CastExpr::CreateImpl(D); + return CastExpr::CreateImpl(D, C); case CharacterLiteralClass: - return CharacterLiteral::CreateImpl(D); + return CharacterLiteral::CreateImpl(D, C); case CompoundAssignOperatorClass: - return CompoundAssignOperator::CreateImpl(D); + return CompoundAssignOperator::CreateImpl(D, C); case CompoundLiteralExprClass: - return CompoundLiteralExpr::CreateImpl(D); + return CompoundLiteralExpr::CreateImpl(D, C); case CompoundStmtClass: - return CompoundStmt::CreateImpl(D); + return CompoundStmt::CreateImpl(D, C); case ConditionalOperatorClass: - return ConditionalOperator::CreateImpl(D); + return ConditionalOperator::CreateImpl(D, C); case ContinueStmtClass: - return ContinueStmt::CreateImpl(D); + return ContinueStmt::CreateImpl(D, C); case DeclRefExprClass: - return DeclRefExpr::CreateImpl(D); + return DeclRefExpr::CreateImpl(D, C); case DeclStmtClass: - return DeclStmt::CreateImpl(D); + return DeclStmt::CreateImpl(D, C); case DefaultStmtClass: - return DefaultStmt::CreateImpl(D); + return DefaultStmt::CreateImpl(D, C); case DoStmtClass: - return DoStmt::CreateImpl(D); + return DoStmt::CreateImpl(D, C); case FloatingLiteralClass: - return FloatingLiteral::CreateImpl(D); + return FloatingLiteral::CreateImpl(D, C); case ForStmtClass: - return ForStmt::CreateImpl(D); + return ForStmt::CreateImpl(D, C); case GotoStmtClass: - return GotoStmt::CreateImpl(D); + return GotoStmt::CreateImpl(D, C); case IfStmtClass: - return IfStmt::CreateImpl(D); + return IfStmt::CreateImpl(D, C); case ImaginaryLiteralClass: - return ImaginaryLiteral::CreateImpl(D); + return ImaginaryLiteral::CreateImpl(D, C); case ImplicitCastExprClass: - return ImplicitCastExpr::CreateImpl(D); + return ImplicitCastExpr::CreateImpl(D, C); case IndirectGotoStmtClass: - return IndirectGotoStmt::CreateImpl(D); + return IndirectGotoStmt::CreateImpl(D, C); case InitListExprClass: - return InitListExpr::CreateImpl(D); + return InitListExpr::CreateImpl(D, C); case IntegerLiteralClass: - return IntegerLiteral::CreateImpl(D); + return IntegerLiteral::CreateImpl(D, C); case LabelStmtClass: - return LabelStmt::CreateImpl(D); + return LabelStmt::CreateImpl(D, C); case MemberExprClass: - return MemberExpr::CreateImpl(D); + return MemberExpr::CreateImpl(D, C); case NullStmtClass: - return NullStmt::CreateImpl(D); + return NullStmt::CreateImpl(D, C); case ParenExprClass: - return ParenExpr::CreateImpl(D); + return ParenExpr::CreateImpl(D, C); case PreDefinedExprClass: - return PreDefinedExpr::CreateImpl(D); + return PreDefinedExpr::CreateImpl(D, C); case ReturnStmtClass: - return ReturnStmt::CreateImpl(D); + return ReturnStmt::CreateImpl(D, C); case SizeOfAlignOfTypeExprClass: - return SizeOfAlignOfTypeExpr::CreateImpl(D); + return SizeOfAlignOfTypeExpr::CreateImpl(D, C); case StmtExprClass: - return StmtExpr::CreateImpl(D); + return StmtExpr::CreateImpl(D, C); case StringLiteralClass: - return StringLiteral::CreateImpl(D); + return StringLiteral::CreateImpl(D, C); case SwitchStmtClass: - return SwitchStmt::CreateImpl(D); + return SwitchStmt::CreateImpl(D, C); case UnaryOperatorClass: - return UnaryOperator::CreateImpl(D); + return UnaryOperator::CreateImpl(D, C); case WhileStmtClass: - return WhileStmt::CreateImpl(D); + return WhileStmt::CreateImpl(D, C); //==--------------------------------------==// // Objective C //==--------------------------------------==// case ObjCAtCatchStmtClass: - return ObjCAtCatchStmt::CreateImpl(D); + return ObjCAtCatchStmt::CreateImpl(D, C); case ObjCAtFinallyStmtClass: - return ObjCAtFinallyStmt::CreateImpl(D); + return ObjCAtFinallyStmt::CreateImpl(D, C); case ObjCAtSynchronizedStmtClass: - return ObjCAtSynchronizedStmt::CreateImpl(D); + return ObjCAtSynchronizedStmt::CreateImpl(D, C); case ObjCAtThrowStmtClass: - return ObjCAtThrowStmt::CreateImpl(D); + return ObjCAtThrowStmt::CreateImpl(D, C); case ObjCAtTryStmtClass: - return ObjCAtTryStmt::CreateImpl(D); + return ObjCAtTryStmt::CreateImpl(D, C); case ObjCEncodeExprClass: - return ObjCEncodeExpr::CreateImpl(D); + return ObjCEncodeExpr::CreateImpl(D, C); case ObjCForCollectionStmtClass: - return ObjCForCollectionStmt::CreateImpl(D); + return ObjCForCollectionStmt::CreateImpl(D, C); case ObjCIvarRefExprClass: - return ObjCIvarRefExpr::CreateImpl(D); + return ObjCIvarRefExpr::CreateImpl(D, C); case ObjCSelectorExprClass: - return ObjCSelectorExpr::CreateImpl(D); + return ObjCSelectorExpr::CreateImpl(D, C); case ObjCStringLiteralClass: - return ObjCStringLiteral::CreateImpl(D); + return ObjCStringLiteral::CreateImpl(D, C); } } @@ -199,7 +199,7 @@ void AddrLabelExpr::EmitImpl(Serializer& S) const { S.EmitPtr(Label); } -AddrLabelExpr* AddrLabelExpr::CreateImpl(Deserializer& D) { +AddrLabelExpr* AddrLabelExpr::CreateImpl(Deserializer& D, ASTContext& C) { QualType t = QualType::ReadVal(D); SourceLocation AALoc = SourceLocation::ReadVal(D); SourceLocation LLoc = SourceLocation::ReadVal(D); @@ -214,11 +214,11 @@ void ArraySubscriptExpr::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs(getLHS(),getRHS()); } -ArraySubscriptExpr* ArraySubscriptExpr::CreateImpl(Deserializer& D) { +ArraySubscriptExpr* ArraySubscriptExpr::CreateImpl(Deserializer& D, ASTContext& C) { QualType t = QualType::ReadVal(D); SourceLocation L = SourceLocation::ReadVal(D); Expr *LHS, *RHS; - D.BatchReadOwnedPtrs(LHS,RHS); + D.BatchReadOwnedPtrs(LHS, RHS, C); return new ArraySubscriptExpr(LHS,RHS,t,L); } @@ -249,9 +249,9 @@ void AsmStmt::EmitImpl(Serializer& S) const { Clobbers[i]->EmitImpl(S); } -AsmStmt* AsmStmt::CreateImpl(Deserializer& D) { +AsmStmt* AsmStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation ALoc = SourceLocation::ReadVal(D); - StringLiteral *AsmStr = StringLiteral::CreateImpl(D); + StringLiteral *AsmStr = StringLiteral::CreateImpl(D, C); SourceLocation PLoc = SourceLocation::ReadVal(D); bool IsVolatile = D.ReadBool(); @@ -275,16 +275,16 @@ AsmStmt* AsmStmt::CreateImpl(Deserializer& D) { Stmt->Constraints.reserve(size); for (unsigned i = 0; i < size; ++i) - Stmt->Constraints.push_back(StringLiteral::CreateImpl(D)); + Stmt->Constraints.push_back(StringLiteral::CreateImpl(D, C)); Stmt->Exprs.reserve(size); for (unsigned i = 0; i < size; ++i) - Stmt->Exprs.push_back(D.ReadOwnedPtr<Expr>()); + Stmt->Exprs.push_back(D.ReadOwnedPtr<Expr>(C)); unsigned NumClobbers = D.ReadInt(); Stmt->Clobbers.reserve(NumClobbers); for (unsigned i = 0; i < NumClobbers; ++i) - Stmt->Clobbers.push_back(StringLiteral::CreateImpl(D)); + Stmt->Clobbers.push_back(StringLiteral::CreateImpl(D, C)); return Stmt; } @@ -296,12 +296,12 @@ void BinaryOperator::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs(getLHS(),getRHS()); } -BinaryOperator* BinaryOperator::CreateImpl(Deserializer& D) { +BinaryOperator* BinaryOperator::CreateImpl(Deserializer& D, ASTContext& C) { Opcode Opc = static_cast<Opcode>(D.ReadInt()); SourceLocation OpLoc = SourceLocation::ReadVal(D); QualType Result = QualType::ReadVal(D); Expr *LHS, *RHS; - D.BatchReadOwnedPtrs(LHS,RHS); + D.BatchReadOwnedPtrs(LHS, RHS, C); return new BinaryOperator(LHS,RHS,Opc,Result,OpLoc); } @@ -310,7 +310,7 @@ void BreakStmt::EmitImpl(Serializer& S) const { S.Emit(BreakLoc); } -BreakStmt* BreakStmt::CreateImpl(Deserializer& D) { +BreakStmt* BreakStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation Loc = SourceLocation::ReadVal(D); return new BreakStmt(Loc); } @@ -322,12 +322,12 @@ void CallExpr::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs(NumArgs+1,SubExprs); } -CallExpr* CallExpr::CreateImpl(Deserializer& D) { +CallExpr* CallExpr::CreateImpl(Deserializer& D, ASTContext& C) { 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); + D.BatchReadOwnedPtrs(NumArgs+1, SubExprs, C); return new CallExpr(SubExprs,NumArgs,t,L); } @@ -338,11 +338,11 @@ void CaseStmt::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs((unsigned) END_EXPR,&SubExprs[0]); } -CaseStmt* CaseStmt::CreateImpl(Deserializer& D) { +CaseStmt* CaseStmt::CreateImpl(Deserializer& D, ASTContext& C) { 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]); + D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubExprs[0], C); return stmt; } @@ -352,10 +352,10 @@ void CastExpr::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(Op); } -CastExpr* CastExpr::CreateImpl(Deserializer& D) { +CastExpr* CastExpr::CreateImpl(Deserializer& D, ASTContext& C) { QualType t = QualType::ReadVal(D); SourceLocation Loc = SourceLocation::ReadVal(D); - Expr* Op = D.ReadOwnedPtr<Expr>(); + Expr* Op = D.ReadOwnedPtr<Expr>(C); return new CastExpr(t,Op,Loc); } @@ -366,7 +366,7 @@ void CharacterLiteral::EmitImpl(Serializer& S) const { S.Emit(getType()); } -CharacterLiteral* CharacterLiteral::CreateImpl(Deserializer& D) { +CharacterLiteral* CharacterLiteral::CreateImpl(Deserializer& D, ASTContext& C) { unsigned value = D.ReadInt(); SourceLocation Loc = SourceLocation::ReadVal(D); QualType T = QualType::ReadVal(D); @@ -382,13 +382,13 @@ void CompoundAssignOperator::EmitImpl(Serializer& S) const { } CompoundAssignOperator* -CompoundAssignOperator::CreateImpl(Deserializer& D) { +CompoundAssignOperator::CreateImpl(Deserializer& D, ASTContext& C) { 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); + D.BatchReadOwnedPtrs(LHS, RHS, C); return new CompoundAssignOperator(LHS,RHS,Opc,t,c,L); } @@ -400,11 +400,11 @@ void CompoundLiteralExpr::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(Init); } -CompoundLiteralExpr* CompoundLiteralExpr::CreateImpl(Deserializer& D) { +CompoundLiteralExpr* CompoundLiteralExpr::CreateImpl(Deserializer& D, ASTContext& C) { QualType Q = QualType::ReadVal(D); SourceLocation L = SourceLocation::ReadVal(D); bool fileScope = D.ReadBool(); - Expr* Init = D.ReadOwnedPtr<Expr>(); + Expr* Init = D.ReadOwnedPtr<Expr>(C); return new CompoundLiteralExpr(L, Q, Init, fileScope); } @@ -417,7 +417,7 @@ void CompoundStmt::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(*I); } -CompoundStmt* CompoundStmt::CreateImpl(Deserializer& D) { +CompoundStmt* CompoundStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation LB = SourceLocation::ReadVal(D); SourceLocation RB = SourceLocation::ReadVal(D); unsigned size = D.ReadInt(); @@ -427,7 +427,7 @@ CompoundStmt* CompoundStmt::CreateImpl(Deserializer& D) { stmt->Body.reserve(size); for (unsigned i = 0; i < size; ++i) - stmt->Body.push_back(D.ReadOwnedPtr<Stmt>()); + stmt->Body.push_back(D.ReadOwnedPtr<Stmt>(C)); return stmt; } @@ -437,10 +437,12 @@ void ConditionalOperator::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs((unsigned) END_EXPR, SubExprs); } -ConditionalOperator* ConditionalOperator::CreateImpl(Deserializer& D) { +ConditionalOperator* ConditionalOperator::CreateImpl(Deserializer& D, + ASTContext& C) { + QualType t = QualType::ReadVal(D); ConditionalOperator* c = new ConditionalOperator(NULL,NULL,NULL,t); - D.BatchReadOwnedPtrs((unsigned) END_EXPR, c->SubExprs); + D.BatchReadOwnedPtrs((unsigned) END_EXPR, c->SubExprs, C); return c; } @@ -448,7 +450,7 @@ void ContinueStmt::EmitImpl(Serializer& S) const { S.Emit(ContinueLoc); } -ContinueStmt* ContinueStmt::CreateImpl(Deserializer& D) { +ContinueStmt* ContinueStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation Loc = SourceLocation::ReadVal(D); return new ContinueStmt(Loc); } @@ -490,7 +492,7 @@ void DeclRefExpr::EmitImpl(Serializer& S) const { } } -DeclRefExpr* DeclRefExpr::CreateImpl(Deserializer& D) { +DeclRefExpr* DeclRefExpr::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation Loc = SourceLocation::ReadVal(D); QualType T = QualType::ReadVal(D); bool OwnsDecl = D.ReadBool(); @@ -499,14 +501,13 @@ DeclRefExpr* DeclRefExpr::CreateImpl(Deserializer& D) { if (!OwnsDecl) D.ReadPtr(decl,false); // No backpatching. else - decl = cast<ValueDecl>(D.ReadOwnedPtr<Decl>()); + decl = cast<ValueDecl>(D.ReadOwnedPtr<Decl>(C)); return new DeclRefExpr(decl,T,Loc); } - -DeclStmt* DeclStmt::CreateImpl(Deserializer& D) { - ScopedDecl* decl = cast<ScopedDecl>(D.ReadOwnedPtr<Decl>()); +DeclStmt* DeclStmt::CreateImpl(Deserializer& D, ASTContext& C) { + ScopedDecl* decl = cast<ScopedDecl>(D.ReadOwnedPtr<Decl>(C)); SourceLocation StartLoc = SourceLocation::ReadVal(D); SourceLocation EndLoc = SourceLocation::ReadVal(D); return new DeclStmt(decl, StartLoc, EndLoc); @@ -518,9 +519,9 @@ void DefaultStmt::EmitImpl(Serializer& S) const { S.EmitPtr(getNextSwitchCase()); } -DefaultStmt* DefaultStmt::CreateImpl(Deserializer& D) { +DefaultStmt* DefaultStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation Loc = SourceLocation::ReadVal(D); - Stmt* SubStmt = D.ReadOwnedPtr<Stmt>(); + Stmt* SubStmt = D.ReadOwnedPtr<Stmt>(C); DefaultStmt* stmt = new DefaultStmt(Loc,SubStmt); stmt->setNextSwitchCase(D.ReadPtr<SwitchCase>()); @@ -534,10 +535,10 @@ void DoStmt::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(getBody()); } -DoStmt* DoStmt::CreateImpl(Deserializer& D) { +DoStmt* DoStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation DoLoc = SourceLocation::ReadVal(D); - Expr* Cond = D.ReadOwnedPtr<Expr>(); - Stmt* Body = D.ReadOwnedPtr<Stmt>(); + Expr* Cond = D.ReadOwnedPtr<Expr>(C); + Stmt* Body = D.ReadOwnedPtr<Stmt>(C); return new DoStmt(Body,Cond,DoLoc); } @@ -548,7 +549,7 @@ void FloatingLiteral::EmitImpl(Serializer& S) const { S.Emit(Value); } -FloatingLiteral* FloatingLiteral::CreateImpl(Deserializer& D) { +FloatingLiteral* FloatingLiteral::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation Loc = SourceLocation::ReadVal(D); QualType t = QualType::ReadVal(D); bool isExact = D.ReadBool(); @@ -565,12 +566,12 @@ void ForStmt::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(getBody()); } -ForStmt* ForStmt::CreateImpl(Deserializer& D) { +ForStmt* ForStmt::CreateImpl(Deserializer& D, ASTContext& C) { 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>(); + Stmt* Init = D.ReadOwnedPtr<Stmt>(C); + Expr* Cond = D.ReadOwnedPtr<Expr>(C); + Expr* Inc = D.ReadOwnedPtr<Expr>(C); + Stmt* Body = D.ReadOwnedPtr<Stmt>(C); return new ForStmt(Init,Cond,Inc,Body,ForLoc); } @@ -580,7 +581,7 @@ void GotoStmt::EmitImpl(Serializer& S) const { S.EmitPtr(Label); } -GotoStmt* GotoStmt::CreateImpl(Deserializer& D) { +GotoStmt* GotoStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation GotoLoc = SourceLocation::ReadVal(D); SourceLocation LabelLoc = SourceLocation::ReadVal(D); GotoStmt* stmt = new GotoStmt(NULL,GotoLoc,LabelLoc); @@ -595,11 +596,11 @@ void IfStmt::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(getElse()); } -IfStmt* IfStmt::CreateImpl(Deserializer& D) { +IfStmt* IfStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation L = SourceLocation::ReadVal(D); - Expr* Cond = D.ReadOwnedPtr<Expr>(); - Stmt* Then = D.ReadOwnedPtr<Stmt>(); - Stmt* Else = D.ReadOwnedPtr<Stmt>(); + Expr* Cond = D.ReadOwnedPtr<Expr>(C); + Stmt* Then = D.ReadOwnedPtr<Stmt>(C); + Stmt* Else = D.ReadOwnedPtr<Stmt>(C); return new IfStmt(L,Cond,Then,Else); } @@ -608,9 +609,9 @@ void ImaginaryLiteral::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(Val); } -ImaginaryLiteral* ImaginaryLiteral::CreateImpl(Deserializer& D) { +ImaginaryLiteral* ImaginaryLiteral::CreateImpl(Deserializer& D, ASTContext& C) { QualType t = QualType::ReadVal(D); - Expr* expr = D.ReadOwnedPtr<Expr>(); + Expr* expr = D.ReadOwnedPtr<Expr>(C); assert (isa<FloatingLiteral>(expr) || isa<IntegerLiteral>(expr)); return new ImaginaryLiteral(expr,t); } @@ -620,9 +621,9 @@ void ImplicitCastExpr::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(Op); } -ImplicitCastExpr* ImplicitCastExpr::CreateImpl(Deserializer& D) { +ImplicitCastExpr* ImplicitCastExpr::CreateImpl(Deserializer& D, ASTContext& C) { QualType t = QualType::ReadVal(D); - Expr* Op = D.ReadOwnedPtr<Expr>(); + Expr* Op = D.ReadOwnedPtr<Expr>(C); return new ImplicitCastExpr(t,Op); } @@ -630,8 +631,8 @@ void IndirectGotoStmt::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(Target); } -IndirectGotoStmt* IndirectGotoStmt::CreateImpl(Deserializer& D) { - Expr* Target = D.ReadOwnedPtr<Expr>(); +IndirectGotoStmt* IndirectGotoStmt::CreateImpl(Deserializer& D, ASTContext& C) { + Expr* Target = D.ReadOwnedPtr<Expr>(C); return new IndirectGotoStmt(Target); } @@ -642,14 +643,14 @@ void InitListExpr::EmitImpl(Serializer& S) const { S.BatchEmitOwnedPtrs(NumInits,InitExprs); } -InitListExpr* InitListExpr::CreateImpl(Deserializer& D) { +InitListExpr* InitListExpr::CreateImpl(Deserializer& D, ASTContext& C) { 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); + D.BatchReadOwnedPtrs(expr->NumInits, expr->InitExprs, C); return expr; } @@ -659,7 +660,7 @@ void IntegerLiteral::EmitImpl(Serializer& S) const { S.Emit(getValue()); } -IntegerLiteral* IntegerLiteral::CreateImpl(Deserializer& D) { +IntegerLiteral* IntegerLiteral::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation Loc = SourceLocation::ReadVal(D); QualType T = QualType::ReadVal(D); @@ -678,10 +679,10 @@ void LabelStmt::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(SubStmt); } -LabelStmt* LabelStmt::CreateImpl(Deserializer& D) { +LabelStmt* LabelStmt::CreateImpl(Deserializer& D, ASTContext& C) { IdentifierInfo* Label = D.ReadPtr<IdentifierInfo>(); SourceLocation IdentLoc = SourceLocation::ReadVal(D); - Stmt* SubStmt = D.ReadOwnedPtr<Stmt>(); + Stmt* SubStmt = D.ReadOwnedPtr<Stmt>(C); return new LabelStmt(IdentLoc,Label,SubStmt); } @@ -693,12 +694,12 @@ void MemberExpr::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(Base); } -MemberExpr* MemberExpr::CreateImpl(Deserializer& D) { +MemberExpr* MemberExpr::CreateImpl(Deserializer& D, ASTContext& C) { 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>(); + Expr* base = D.ReadOwnedPtr<Expr>(C); return new MemberExpr(base,IsArrow,MemberDecl,L,T); } @@ -707,7 +708,7 @@ void NullStmt::EmitImpl(Serializer& S) const { S.Emit(SemiLoc); } -NullStmt* NullStmt::CreateImpl(Deserializer& D) { +NullStmt* NullStmt::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation SemiLoc = SourceLocation::ReadVal(D); return new NullStmt(SemiLoc); } @@ -718,10 +719,10 @@ void ParenExpr::EmitImpl(Serializer& S) const { S.EmitOwnedPtr(Val); } -ParenExpr* ParenExpr::CreateImpl(Deserializer& D) { +ParenExpr* ParenExpr::CreateImpl(Deserializer& D, ASTContext& C) { SourceLocation L = SourceLocation::ReadVal(D); SourceLocation R = SourceLocation::ReadVal(D); - Expr* val = D.ReadOwnedPtr<Expr>(); + Expr* val = D.ReadOwnedPtr<Expr>(C); return new ParenExpr(L,R,val); } @@ -731,7 +732,7 @@ void PreDefinedExpr::EmitImpl(Serializer& S) const { S.Emit(getType()); } -PreDefinedExpr* PreDefinedExpr::CreateImpl(Deserializer& D) { +PreDefinedExpr* PreDefinedExp |