From: Douglas Gregor Date: Thu, 16 Apr 2009 22:23:12 +0000 (+0000) Subject: Prepare PCH reader and writer for (de-)serialization of statements. No X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=c9490c000f515c29f200a1215328d8ab9a0f3818;p=clang Prepare PCH reader and writer for (de-)serialization of statements. No functionality change. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@69319 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Frontend/PCHBitCodes.h b/include/clang/Frontend/PCHBitCodes.h index c8b654c667..a218a5fcf6 100644 --- a/include/clang/Frontend/PCHBitCodes.h +++ b/include/clang/Frontend/PCHBitCodes.h @@ -372,9 +372,9 @@ namespace clang { enum StmtCode { /// \brief A marker record that indicates that we are at the end /// of an expression. - EXPR_STOP, + STMT_STOP, /// \brief A NULL expression. - EXPR_NULL, + STMT_NULL_PTR, /// \brief A PredefinedExpr record. EXPR_PREDEFINED, /// \brief A DeclRefExpr record. diff --git a/include/clang/Frontend/PCHReader.h b/include/clang/Frontend/PCHReader.h index 4cc4c24cc5..995a1d563f 100644 --- a/include/clang/Frontend/PCHReader.h +++ b/include/clang/Frontend/PCHReader.h @@ -235,6 +235,9 @@ public: /// \brief Reads an expression from the current stream position. Expr *ReadExpr(); + /// \brief Reads a statement from the current stream position. + Stmt *ReadStmt(); + /// \brief Retrieve the AST context that this PCH reader /// supplements. ASTContext &getContext() { return Context; } diff --git a/include/clang/Frontend/PCHWriter.h b/include/clang/Frontend/PCHWriter.h index 0f9031f1c1..4af64e6ee1 100644 --- a/include/clang/Frontend/PCHWriter.h +++ b/include/clang/Frontend/PCHWriter.h @@ -48,7 +48,7 @@ public: private: /// \brief The bitstream writer used to emit this precompiled header. - llvm::BitstreamWriter &S; + llvm::BitstreamWriter &Stream; /// \brief Map that provides the ID numbers of each declaration within /// the output stream. @@ -104,9 +104,9 @@ private: /// record. llvm::SmallVector ExternalDefinitions; - /// \brief Expressions that we've encountered while serializing a + /// \brief Statements that we've encountered while serializing a /// declaration or type. - llvm::SmallVector ExprsToEmit; + llvm::SmallVector StmtsToEmit; void WriteTargetTriple(const TargetInfo &Target); void WriteLanguageOptions(const LangOptions &LangOpts); @@ -125,7 +125,7 @@ private: public: /// \brief Create a new precompiled header writer that outputs to /// the given bitstream. - PCHWriter(llvm::BitstreamWriter &S); + PCHWriter(llvm::BitstreamWriter &Stream); /// \brief Write a precompiled header for the given AST context. void WritePCH(ASTContext &Context, const Preprocessor &PP); @@ -154,22 +154,22 @@ public: /// \brief Emit a declaration name. void AddDeclarationName(DeclarationName Name, RecordData &Record); - /// \brief Add the given expression to the queue of expressions to + /// \brief Add the given statement or expression to the queue of statements to /// emit. /// /// This routine should be used when emitting types and declarations /// that have expressions as part of their formulation. Once the - /// type or declaration has been written, call FlushExprs() to write - /// the corresponding expressions just after the type or + /// type or declaration has been written, call FlushStmts() to write + /// the corresponding statements just after the type or /// declaration. - void AddExpr(Expr *E) { ExprsToEmit.push_back(E); } + void AddStmt(Stmt *S) { StmtsToEmit.push_back(S); } /// \brief Write the given subexpression to the bitstream. - void WriteSubExpr(Expr *E); + void WriteSubStmt(Stmt *S); - /// \brief Flush all of the expressions that have been added to the - /// queue via AddExpr(). - void FlushExprs(); + /// \brief Flush all of the statements and expressions that have + /// been added to the queue via AddStmt(). + void FlushStmts(); }; } // end namespace clang diff --git a/lib/Frontend/PCHReader.cpp b/lib/Frontend/PCHReader.cpp index 0bc059ed66..ceba88049a 100644 --- a/lib/Frontend/PCHReader.cpp +++ b/lib/Frontend/PCHReader.cpp @@ -220,12 +220,12 @@ namespace { PCHReader &Reader; const PCHReader::RecordData &Record; unsigned &Idx; - llvm::SmallVectorImpl &ExprStack; + llvm::SmallVectorImpl &StmtStack; public: PCHStmtReader(PCHReader &Reader, const PCHReader::RecordData &Record, - unsigned &Idx, llvm::SmallVectorImpl &ExprStack) - : Reader(Reader), Record(Record), Idx(Idx), ExprStack(ExprStack) { } + unsigned &Idx, llvm::SmallVectorImpl &StmtStack) + : Reader(Reader), Record(Record), Idx(Idx), StmtStack(StmtStack) { } /// \brief The number of record fields required for the Expr class /// itself. @@ -310,7 +310,7 @@ unsigned PCHStmtReader::VisitFloatingLiteral(FloatingLiteral *E) { unsigned PCHStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { VisitExpr(E); - E->setSubExpr(ExprStack.back()); + E->setSubExpr(cast(StmtStack.back())); return 1; } @@ -346,13 +346,13 @@ unsigned PCHStmtReader::VisitParenExpr(ParenExpr *E) { VisitExpr(E); E->setLParen(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParen(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setSubExpr(ExprStack.back()); + E->setSubExpr(cast(StmtStack.back())); return 1; } unsigned PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); - E->setSubExpr(ExprStack.back()); + E->setSubExpr(cast(StmtStack.back())); E->setOpcode((UnaryOperator::Opcode)Record[Idx++]); E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); return 1; @@ -362,7 +362,7 @@ unsigned PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { VisitExpr(E); E->setSizeof(Record[Idx++]); if (Record[Idx] == 0) { - E->setArgument(ExprStack.back()); + E->setArgument(cast(StmtStack.back())); ++Idx; } else { E->setArgument(Reader.GetType(Record[Idx++])); @@ -374,8 +374,8 @@ unsigned PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { unsigned PCHStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); - E->setLHS(ExprStack[ExprStack.size() - 2]); - E->setRHS(ExprStack[ExprStack.size() - 2]); + E->setLHS(cast(StmtStack[StmtStack.size() - 2])); + E->setRHS(cast(StmtStack[StmtStack.size() - 2])); E->setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); return 2; } @@ -384,15 +384,15 @@ unsigned PCHStmtReader::VisitCallExpr(CallExpr *E) { VisitExpr(E); E->setNumArgs(Reader.getContext(), Record[Idx++]); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setCallee(ExprStack[ExprStack.size() - E->getNumArgs() - 1]); + E->setCallee(cast(StmtStack[StmtStack.size() - E->getNumArgs() - 1])); for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) - E->setArg(I, ExprStack[ExprStack.size() - N + I]); + E->setArg(I, cast(StmtStack[StmtStack.size() - N + I])); return E->getNumArgs() + 1; } unsigned PCHStmtReader::VisitMemberExpr(MemberExpr *E) { VisitExpr(E); - E->setBase(ExprStack.back()); + E->setBase(cast(StmtStack.back())); E->setMemberDecl(cast(Reader.GetDecl(Record[Idx++]))); E->setMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setArrow(Record[Idx++]); @@ -401,14 +401,14 @@ unsigned PCHStmtReader::VisitMemberExpr(MemberExpr *E) { unsigned PCHStmtReader::VisitCastExpr(CastExpr *E) { VisitExpr(E); - E->setSubExpr(ExprStack.back()); + E->setSubExpr(cast(StmtStack.back())); return 1; } unsigned PCHStmtReader::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); - E->setLHS(ExprStack.end()[-2]); - E->setRHS(ExprStack.end()[-1]); + E->setLHS(cast(StmtStack.end()[-2])); + E->setRHS(cast(StmtStack.end()[-1])); E->setOpcode((BinaryOperator::Opcode)Record[Idx++]); E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); return 2; @@ -423,9 +423,9 @@ unsigned PCHStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) { unsigned PCHStmtReader::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); - E->setCond(ExprStack[ExprStack.size() - 3]); - E->setLHS(ExprStack[ExprStack.size() - 2]); - E->setRHS(ExprStack[ExprStack.size() - 1]); + E->setCond(cast(StmtStack[StmtStack.size() - 3])); + E->setLHS(cast_or_null(StmtStack[StmtStack.size() - 2])); + E->setRHS(cast_or_null(StmtStack[StmtStack.size() - 1])); return 3; } @@ -451,14 +451,14 @@ unsigned PCHStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) { unsigned PCHStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); - E->setInitializer(ExprStack.back()); + E->setInitializer(cast(StmtStack.back())); E->setFileScope(Record[Idx++]); return 1; } unsigned PCHStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); - E->setBase(ExprStack.back()); + E->setBase(cast(StmtStack.back())); E->setAccessor(Reader.GetIdentifierInfo(Record, Idx)); E->setAccessorLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); return 1; @@ -469,8 +469,9 @@ unsigned PCHStmtReader::VisitInitListExpr(InitListExpr *E) { unsigned NumInits = Record[Idx++]; E->reserveInits(NumInits); for (unsigned I = 0; I != NumInits; ++I) - E->updateInit(I, ExprStack[ExprStack.size() - NumInits - 1 + I]); - E->setSyntacticForm(cast_or_null(ExprStack.back())); + E->updateInit(I, + cast(StmtStack[StmtStack.size() - NumInits - 1 + I])); + E->setSyntacticForm(cast_or_null(StmtStack.back())); E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setInitializedFieldInUnion( @@ -486,7 +487,7 @@ unsigned PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { unsigned NumSubExprs = Record[Idx++]; assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs"); for (unsigned I = 0; I != NumSubExprs; ++I) - E->setSubExpr(I, ExprStack[ExprStack.size() - NumSubExprs + I]); + E->setSubExpr(I, cast(StmtStack[StmtStack.size() - NumSubExprs + I])); E->setEqualOrColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setGNUSyntax(Record[Idx++]); @@ -551,7 +552,7 @@ unsigned PCHStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { unsigned PCHStmtReader::VisitVAArgExpr(VAArgExpr *E) { VisitExpr(E); - E->setSubExpr(ExprStack.back()); + E->setSubExpr(cast(StmtStack.back())); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); return 1; @@ -568,9 +569,9 @@ unsigned PCHStmtReader::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) { unsigned PCHStmtReader::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); - E->setCond(ExprStack[ExprStack.size() - 3]); - E->setLHS(ExprStack[ExprStack.size() - 2]); - E->setRHS(ExprStack[ExprStack.size() - 1]); + E->setCond(cast(StmtStack[StmtStack.size() - 3])); + E->setLHS(cast_or_null(StmtStack[StmtStack.size() - 2])); + E->setRHS(cast_or_null(StmtStack[StmtStack.size() - 1])); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); return 3; @@ -585,7 +586,7 @@ unsigned PCHStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { unsigned PCHStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); unsigned NumExprs = Record[Idx++]; - E->setExprs(&ExprStack[ExprStack.size() - NumExprs], NumExprs); + E->setExprs((Expr **)&StmtStack[StmtStack.size() - NumExprs], NumExprs); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); return NumExprs; @@ -1982,18 +1983,18 @@ Attr *PCHReader::ReadAttributes() { return PrevAttr; } -Expr *PCHReader::ReadExpr() { +Stmt *PCHReader::ReadStmt() { // Within the bitstream, expressions are stored in Reverse Polish // Notation, with each of the subexpressions preceding the // expression they are stored in. To evaluate expressions, we // continue reading expressions and placing them on the stack, with // expressions having operands removing those operands from the - // stack. Evaluation terminates when we see a EXPR_STOP record, and + // stack. Evaluation terminates when we see a STMT_STOP record, and // the single remaining expression on the stack is our result. RecordData Record; unsigned Idx; - llvm::SmallVector ExprStack; - PCHStmtReader Reader(*this, Record, Idx, ExprStack); + llvm::SmallVector StmtStack; + PCHStmtReader Reader(*this, Record, Idx, StmtStack); Stmt::EmptyShell Empty; while (true) { @@ -2021,159 +2022,163 @@ Expr *PCHReader::ReadExpr() { continue; } - Expr *E = 0; + Stmt *S = 0; Idx = 0; Record.clear(); bool Finished = false; switch ((pch::StmtCode)Stream.ReadRecord(Code, Record)) { - case pch::EXPR_STOP: + case pch::STMT_STOP: Finished = true; break; - case pch::EXPR_NULL: - E = 0; + case pch::STMT_NULL_PTR: + S = 0; break; case pch::EXPR_PREDEFINED: // FIXME: untested (until we can serialize function bodies). - E = new (Context) PredefinedExpr(Empty); + S = new (Context) PredefinedExpr(Empty); break; case pch::EXPR_DECL_REF: - E = new (Context) DeclRefExpr(Empty); + S = new (Context) DeclRefExpr(Empty); break; case pch::EXPR_INTEGER_LITERAL: - E = new (Context) IntegerLiteral(Empty); + S = new (Context) IntegerLiteral(Empty); break; case pch::EXPR_FLOATING_LITERAL: - E = new (Context) FloatingLiteral(Empty); + S = new (Context) FloatingLiteral(Empty); break; case pch::EXPR_IMAGINARY_LITERAL: - E = new (Context) ImaginaryLiteral(Empty); + S = new (Context) ImaginaryLiteral(Empty); break; case pch::EXPR_STRING_LITERAL: - E = StringLiteral::CreateEmpty(Context, + S = StringLiteral::CreateEmpty(Context, Record[PCHStmtReader::NumExprFields + 1]); break; case pch::EXPR_CHARACTER_LITERAL: - E = new (Context) CharacterLiteral(Empty); + S = new (Context) CharacterLiteral(Empty); break; case pch::EXPR_PAREN: - E = new (Context) ParenExpr(Empty); + S = new (Context) ParenExpr(Empty); break; case pch::EXPR_UNARY_OPERATOR: - E = new (Context) UnaryOperator(Empty); + S = new (Context) UnaryOperator(Empty); break; case pch::EXPR_SIZEOF_ALIGN_OF: - E = new (Context) SizeOfAlignOfExpr(Empty); + S = new (Context) SizeOfAlignOfExpr(Empty); break; case pch::EXPR_ARRAY_SUBSCRIPT: - E = new (Context) ArraySubscriptExpr(Empty); + S = new (Context) ArraySubscriptExpr(Empty); break; case pch::EXPR_CALL: - E = new (Context) CallExpr(Context, Empty); + S = new (Context) CallExpr(Context, Empty); break; case pch::EXPR_MEMBER: - E = new (Context) MemberExpr(Empty); + S = new (Context) MemberExpr(Empty); break; case pch::EXPR_BINARY_OPERATOR: - E = new (Context) BinaryOperator(Empty); + S = new (Context) BinaryOperator(Empty); break; case pch::EXPR_COMPOUND_ASSIGN_OPERATOR: - E = new (Context) CompoundAssignOperator(Empty); + S = new (Context) CompoundAssignOperator(Empty); break; case pch::EXPR_CONDITIONAL_OPERATOR: - E = new (Context) ConditionalOperator(Empty); + S = new (Context) ConditionalOperator(Empty); break; case pch::EXPR_IMPLICIT_CAST: - E = new (Context) ImplicitCastExpr(Empty); + S = new (Context) ImplicitCastExpr(Empty); break; case pch::EXPR_CSTYLE_CAST: - E = new (Context) CStyleCastExpr(Empty); + S = new (Context) CStyleCastExpr(Empty); break; case pch::EXPR_COMPOUND_LITERAL: - E = new (Context) CompoundLiteralExpr(Empty); + S = new (Context) CompoundLiteralExpr(Empty); break; case pch::EXPR_EXT_VECTOR_ELEMENT: - E = new (Context) ExtVectorElementExpr(Empty); + S = new (Context) ExtVectorElementExpr(Empty); break; case pch::EXPR_INIT_LIST: - E = new (Context) InitListExpr(Empty); + S = new (Context) InitListExpr(Empty); break; case pch::EXPR_DESIGNATED_INIT: - E = DesignatedInitExpr::CreateEmpty(Context, + S = DesignatedInitExpr::CreateEmpty(Context, Record[PCHStmtReader::NumExprFields] - 1); break; case pch::EXPR_IMPLICIT_VALUE_INIT: - E = new (Context) ImplicitValueInitExpr(Empty); + S = new (Context) ImplicitValueInitExpr(Empty); break; case pch::EXPR_VA_ARG: // FIXME: untested; we need function bodies first - E = new (Context) VAArgExpr(Empty); + S = new (Context) VAArgExpr(Empty); break; case pch::EXPR_TYPES_COMPATIBLE: - E = new (Context) TypesCompatibleExpr(Empty); + S = new (Context) TypesCompatibleExpr(Empty); break; case pch::EXPR_CHOOSE: - E = new (Context) ChooseExpr(Empty); + S = new (Context) ChooseExpr(Empty); break; case pch::EXPR_GNU_NULL: - E = new (Context) GNUNullExpr(Empty); + S = new (Context) GNUNullExpr(Empty); break; case pch::EXPR_SHUFFLE_VECTOR: - E = new (Context) ShuffleVectorExpr(Empty); + S = new (Context) ShuffleVectorExpr(Empty); break; case pch::EXPR_BLOCK_DECL_REF: // FIXME: untested until we have statement and block support - E = new (Context) BlockDeclRefExpr(Empty); + S = new (Context) BlockDeclRefExpr(Empty); break; } - // We hit an EXPR_STOP, so we're done with this expression. + // We hit a STMT_STOP, so we're done with this expression. if (Finished) break; - if (E) { - unsigned NumSubExprs = Reader.Visit(E); - while (NumSubExprs > 0) { - ExprStack.pop_back(); - --NumSubExprs; + if (S) { + unsigned NumSubStmts = Reader.Visit(S); + while (NumSubStmts > 0) { + StmtStack.pop_back(); + --NumSubStmts; } } assert(Idx == Record.size() && "Invalid deserialization of expression"); - ExprStack.push_back(E); + StmtStack.push_back(S); } - assert(ExprStack.size() == 1 && "Extra expressions on stack!"); - return ExprStack.back(); + assert(StmtStack.size() == 1 && "Extra expressions on stack!"); + return StmtStack.back(); +} + +Expr *PCHReader::ReadExpr() { + return dyn_cast_or_null(ReadStmt()); } DiagnosticBuilder PCHReader::Diag(unsigned DiagID) { diff --git a/lib/Frontend/PCHWriter.cpp b/lib/Frontend/PCHWriter.cpp index 8adabafae1..056aeec2d7 100644 --- a/lib/Frontend/PCHWriter.cpp +++ b/lib/Frontend/PCHWriter.cpp @@ -126,7 +126,7 @@ void PCHTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) { void PCHTypeWriter::VisitVariableArrayType(const VariableArrayType *T) { VisitArrayType(T); - Writer.AddExpr(T->getSizeExpr()); + Writer.AddStmt(T->getSizeExpr()); Code = pch::TYPE_VARIABLE_ARRAY; } @@ -166,7 +166,7 @@ void PCHTypeWriter::VisitTypedefType(const TypedefType *T) { } void PCHTypeWriter::VisitTypeOfExprType(const TypeOfExprType *T) { - Writer.AddExpr(T->getUnderlyingExpr()); + Writer.AddStmt(T->getUnderlyingExpr()); Code = pch::TYPE_TYPEOF_EXPR; } @@ -331,7 +331,7 @@ void PCHDeclWriter::VisitEnumConstantDecl(EnumConstantDecl *D) { VisitValueDecl(D); Record.push_back(D->getInitExpr()? 1 : 0); if (D->getInitExpr()) - Writer.AddExpr(D->getInitExpr()); + Writer.AddStmt(D->getInitExpr()); Writer.AddAPSInt(D->getInitVal(), Record); Code = pch::DECL_ENUM_CONSTANT; } @@ -360,7 +360,7 @@ void PCHDeclWriter::VisitFieldDecl(FieldDecl *D) { Record.push_back(D->isMutable()); Record.push_back(D->getBitWidth()? 1 : 0); if (D->getBitWidth()) - Writer.AddExpr(D->getBitWidth()); + Writer.AddStmt(D->getBitWidth()); Code = pch::DECL_FIELD; } @@ -374,7 +374,7 @@ void PCHDeclWriter::VisitVarDecl(VarDecl *D) { Writer.AddSourceLocation(D->getTypeSpecStartLoc(), Record); Record.push_back(D->getInit()? 1 : 0); if (D->getInit()) - Writer.AddExpr(D->getInit()); + Writer.AddStmt(D->getInit()); Code = pch::DECL_VAR; } @@ -395,7 +395,7 @@ void PCHDeclWriter::VisitOriginalParmVarDecl(OriginalParmVarDecl *D) { void PCHDeclWriter::VisitFileScopeAsmDecl(FileScopeAsmDecl *D) { VisitDecl(D); - Writer.AddExpr(D->getAsmString()); + Writer.AddStmt(D->getAsmString()); Code = pch::DECL_FILE_SCOPE_ASM; } @@ -515,7 +515,7 @@ void PCHStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) { void PCHStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getSubExpr()); + Writer.WriteSubStmt(E->getSubExpr()); Code = pch::EXPR_IMAGINARY_LITERAL; } @@ -547,13 +547,13 @@ void PCHStmtWriter::VisitParenExpr(ParenExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParen(), Record); Writer.AddSourceLocation(E->getRParen(), Record); - Writer.WriteSubExpr(E->getSubExpr()); + Writer.WriteSubStmt(E->getSubExpr()); Code = pch::EXPR_PAREN; } void PCHStmtWriter::VisitUnaryOperator(UnaryOperator *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getSubExpr()); + Writer.WriteSubStmt(E->getSubExpr()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = pch::EXPR_UNARY_OPERATOR; @@ -566,7 +566,7 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { Writer.AddTypeRef(E->getArgumentType(), Record); else { Record.push_back(0); - Writer.WriteSubExpr(E->getArgumentExpr()); + Writer.WriteSubStmt(E->getArgumentExpr()); } Writer.AddSourceLocation(E->getOperatorLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); @@ -575,8 +575,8 @@ void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { void PCHStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getLHS()); - Writer.WriteSubExpr(E->getRHS()); + Writer.WriteSubStmt(E->getLHS()); + Writer.WriteSubStmt(E->getRHS()); Writer.AddSourceLocation(E->getRBracketLoc(), Record); Code = pch::EXPR_ARRAY_SUBSCRIPT; } @@ -585,16 +585,16 @@ void PCHStmtWriter::VisitCallExpr(CallExpr *E) { VisitExpr(E); Record.push_back(E->getNumArgs()); Writer.AddSourceLocation(E->getRParenLoc(), Record); - Writer.WriteSubExpr(E->getCallee()); + Writer.WriteSubStmt(E->getCallee()); for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end(); Arg != ArgEnd; ++Arg) - Writer.WriteSubExpr(*Arg); + Writer.WriteSubStmt(*Arg); Code = pch::EXPR_CALL; } void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getBase()); + Writer.WriteSubStmt(E->getBase()); Writer.AddDeclRef(E->getMemberDecl(), Record); Writer.AddSourceLocation(E->getMemberLoc(), Record); Record.push_back(E->isArrow()); @@ -603,13 +603,13 @@ void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) { void PCHStmtWriter::VisitCastExpr(CastExpr *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getSubExpr()); + Writer.WriteSubStmt(E->getSubExpr()); } void PCHStmtWriter::VisitBinaryOperator(BinaryOperator *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getLHS()); - Writer.WriteSubExpr(E->getRHS()); + Writer.WriteSubStmt(E->getLHS()); + Writer.WriteSubStmt(E->getRHS()); Record.push_back(E->getOpcode()); // FIXME: stable encoding Writer.AddSourceLocation(E->getOperatorLoc(), Record); Code = pch::EXPR_BINARY_OPERATOR; @@ -624,9 +624,9 @@ void PCHStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) { void PCHStmtWriter::VisitConditionalOperator(ConditionalOperator *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getCond()); - Writer.WriteSubExpr(E->getLHS()); - Writer.WriteSubExpr(E->getRHS()); + Writer.WriteSubStmt(E->getCond()); + Writer.WriteSubStmt(E->getLHS()); + Writer.WriteSubStmt(E->getRHS()); Code = pch::EXPR_CONDITIONAL_OPERATOR; } @@ -651,14 +651,14 @@ void PCHStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) { void PCHStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { VisitExpr(E); Writer.AddSourceLocation(E->getLParenLoc(), Record); - Writer.WriteSubExpr(E->getInitializer()); + Writer.WriteSubStmt(E->getInitializer()); Record.push_back(E->isFileScope()); Code = pch::EXPR_COMPOUND_LITERAL; } void PCHStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getBase()); + Writer.WriteSubStmt(E->getBase()); Writer.AddIdentifierRef(&E->getAccessor(), Record); Writer.AddSourceLocation(E->getAccessorLoc(), Record); Code = pch::EXPR_EXT_VECTOR_ELEMENT; @@ -668,8 +668,8 @@ void PCHStmtWriter::VisitInitListExpr(InitListExpr *E) { VisitExpr(E); Record.push_back(E->getNumInits()); for (unsigned I = 0, N = E->getNumInits(); I != N; ++I) - Writer.WriteSubExpr(E->getInit(I)); - Writer.WriteSubExpr(E->getSyntacticForm()); + Writer.WriteSubStmt(E->getInit(I)); + Writer.WriteSubStmt(E->getSyntacticForm()); Writer.AddSourceLocation(E->getLBraceLoc(), Record); Writer.AddSourceLocation(E->getRBraceLoc(), Record); Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record); @@ -681,7 +681,7 @@ void PCHStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) - Writer.WriteSubExpr(E->getSubExpr(I)); + Writer.WriteSubStmt(E->getSubExpr(I)); Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record); Record.push_back(E->usesGNUSyntax()); for (DesignatedInitExpr::designators_iterator D = E->designators_begin(), @@ -721,7 +721,7 @@ void PCHStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { void PCHStmtWriter::VisitVAArgExpr(VAArgExpr *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getSubExpr()); + Writer.WriteSubStmt(E->getSubExpr()); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = pch::EXPR_VA_ARG; @@ -738,9 +738,9 @@ void PCHStmtWriter::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) { void PCHStmtWriter::VisitChooseExpr(ChooseExpr *E) { VisitExpr(E); - Writer.WriteSubExpr(E->getCond()); - Writer.WriteSubExpr(E->getLHS()); - Writer.WriteSubExpr(E->getRHS()); + Writer.WriteSubStmt(E->getCond()); + Writer.WriteSubStmt(E->getLHS()); + Writer.WriteSubStmt(E->getRHS()); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = pch::EXPR_CHOOSE; @@ -756,7 +756,7 @@ void PCHStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); Record.push_back(E->getNumSubExprs()); for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I) - Writer.WriteSubExpr(E->getExpr(I)); + Writer.WriteSubStmt(E->getExpr(I)); Writer.AddSourceLocation(E->getBuiltinLoc(), Record); Writer.AddSourceLocation(E->getRParenLoc(), Record); Code = pch::EXPR_SHUFFLE_VECTOR; @@ -780,12 +780,12 @@ void PCHWriter::WriteTargetTriple(const TargetInfo &Target) { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(pch::TARGET_TRIPLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Triple name - unsigned TripleAbbrev = S.EmitAbbrev(Abbrev); + unsigned TripleAbbrev = Stream.EmitAbbrev(Abbrev); RecordData Record; Record.push_back(pch::TARGET_TRIPLE); const char *Triple = Target.getTargetTriple(); - S.EmitRecordWithBlob(TripleAbbrev, Record, Triple, strlen(Triple)); + Stream.EmitRecordWithBlob(TripleAbbrev, Record, Triple, strlen(Triple)); } /// \brief Write the LangOptions structure. @@ -847,7 +847,7 @@ void PCHWriter::WriteLanguageOptions(const LangOptions &LangOpts) { Record.push_back(LangOpts.getGCMode()); Record.push_back(LangOpts.getVisibilityMode()); Record.push_back(LangOpts.InstantiationDepth); - S.EmitRecord(pch::LANGUAGE_OPTIONS, Record); + Stream.EmitRecord(pch::LANGUAGE_OPTIONS, Record); } //===----------------------------------------------------------------------===// @@ -856,7 +856,7 @@ void PCHWriter::WriteLanguageOptions(const LangOptions &LangOpts) { /// \brief Create an abbreviation for the SLocEntry that refers to a /// file. -static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &S) { +static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_FILE_ENTRY)); @@ -865,12 +865,12 @@ static unsigned CreateSLocFileAbbrev(llvm::BitstreamWriter &S) { Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // File name - return S.EmitAbbrev(Abbrev); + return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer. -static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &S) { +static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_BUFFER_ENTRY)); @@ -879,22 +879,22 @@ static unsigned CreateSLocBufferAbbrev(llvm::BitstreamWriter &S) { Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Characteristic Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Line directives Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Buffer name blob - return S.EmitAbbrev(Abbrev); + return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to a /// buffer's blob. -static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &S) { +static unsigned CreateSLocBufferBlobAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_BUFFER_BLOB)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Blob - return S.EmitAbbrev(Abbrev); + return Stream.EmitAbbrev(Abbrev); } /// \brief Create an abbreviation for the SLocEntry that refers to an /// buffer. -static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &S) { +static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &Stream) { using namespace llvm; BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(pch::SM_SLOC_INSTANTIATION_ENTRY)); @@ -903,7 +903,7 @@ static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &S) { Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // Start location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // End location Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Token length - return S.EmitAbbrev(Abbrev); + return Stream.EmitAbbrev(Abbrev); } /// \brief Writes the block containing the serialized form of the @@ -916,7 +916,7 @@ static unsigned CreateSLocInstantiationAbbrev(llvm::BitstreamWriter &S) { /// the files in the AST. void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) { // Enter the source manager block. - S.EnterSubblock(pch::SOURCE_MANAGER_BLOCK_ID, 3); + Stream.EnterSubblock(pch::SOURCE_MANAGER_BLOCK_ID, 3); // Abbreviations for the various kinds of source-location entries. int SLocFileAbbrv = -1; @@ -954,16 +954,16 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) { // The source location entry is a file. The blob associated // with this entry is the file name. if (SLocFileAbbrv == -1) - SLocFileAbbrv = CreateSLocFileAbbrev(S); - S.EmitRecordWithBlob(SLocFileAbbrv, Record, + SLocFileAbbrv = CreateSLocFileAbbrev(Stream); + Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Content->Entry->getName(), strlen(Content->Entry->getName())); } else { // The source location entry is a buffer. The blob associated // with this entry contains the contents of the buffer. if (SLocBufferAbbrv == -1) { - SLocBufferAbbrv = CreateSLocBufferAbbrev(S); - SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(S); + SLocBufferAbbrv = CreateSLocBufferAbbrev(Stream); + SLocBufferBlobAbbrv = CreateSLocBufferBlobAbbrev(Stream); } // We add one to the size so that we capture the trailing NULL @@ -971,10 +971,10 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) { // the reader side). const llvm::MemoryBuffer *Buffer = Content->getBuffer(); const char *Name = Buffer->getBufferIdentifier(); - S.EmitRecordWithBlob(SLocBufferAbbrv, Record, Name, strlen(Name) + 1); + Stream.EmitRecordWithBlob(SLocBufferAbbrv, Record, Name, strlen(Name) + 1); Record.clear(); Record.push_back(pch::SM_SLOC_BUFFER_BLOB); - S.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, + Stream.EmitRecordWithBlob(SLocBufferBlobAbbrv, Record, Buffer->getBufferStart(), Buffer->getBufferSize() + 1); } @@ -993,8 +993,8 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) { Record.push_back(NextOffset - SLoc->getOffset() - 1); if (SLocInstantiationAbbrv == -1) - SLocInstantiationAbbrv = CreateSLocInstantiationAbbrev(S); - S.EmitRecordWithAbbrev(SLocInstantiationAbbrv, Record); + SLocInstantiationAbbrv = CreateSLocInstantiationAbbrev(Stream); + Stream.EmitRecordWithAbbrev(SLocInstantiationAbbrv, Record); } Record.clear(); @@ -1032,11 +1032,11 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) { Record.push_back((unsigned)LE->FileKind); Record.push_back(LE->IncludeOffset); } - S.EmitRecord(pch::SM_LINE_TABLE, Record); + Stream.EmitRecord(pch::SM_LINE_TABLE, Record); } } - S.ExitBlock(); + Stream.ExitBlock(); } /// \brief Writes the block containing the serialized form of the @@ -1044,7 +1044,7 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr) { /// void PCHWriter::WritePreprocessor(const Preprocessor &PP) { // Enter the preprocessor block. - S.EnterSubblock(pch::PREPROCESSOR_BLOCK_ID, 3); + Stream.EnterSubblock(pch::PREPROCESSOR_BLOCK_ID, 3); // If the PCH file contains __DATE__ or __TIME__ emit a warning about this. // FIXME: use diagnostics subsystem for localization etc. @@ -1056,7 +1056,7 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) { // If the preprocessor __COUNTER__ value has been bumped, remember it. if (PP.getCounterValue() != 0) { Record.push_back(PP.getCounterValue()); - S.EmitRecord(pch::PP_COUNTER_VALUE, Record); + Stream.EmitRecord(pch::PP_COUNTER_VALUE, Record); Record.clear(); } @@ -1092,7 +1092,7 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) { I != E; ++I) AddIdentifierRef(*I, Record); } - S.EmitRecord(Code, Record); + Stream.EmitRecord(Code, Record); Record.clear(); // Emit the tokens array. @@ -1114,13 +1114,13 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) { // FIXME: Should translate token flags to a stable encoding. Record.push_back(Tok.getFlags()); - S.EmitRecord(pch::PP_TOKEN, Record); + Stream.EmitRecord(pch::PP_TOKEN, Record); Record.clear(); } } - S.ExitBlock(); + Stream.ExitBlock(); } @@ -1132,10 +1132,10 @@ void PCHWriter::WriteType(const Type *T) { // Record the offset for this type. if (TypeOffsets.size() == ID - pch::NUM_PREDEF_TYPE_IDS) - TypeOffsets.push_back(S.GetCurrentBitNo()); + TypeOffsets.push_back(Stream.GetCurrentBitNo()); else if (TypeOffsets.size() < ID - pch::NUM_PREDEF_TYPE_IDS) { TypeOffsets.resize(ID + 1 - pch::NUM_PREDEF_TYPE_IDS); - TypeOffsets[ID - pch::NUM_PREDEF_TYPE_IDS] = S.GetCurrentBitNo(); + TypeOffsets[ID - pch::NUM_PREDEF_TYPE_IDS] = Stream.GetCurrentBitNo(); } RecordData Record; @@ -1161,16 +1161,16 @@ void PCHWriter::WriteType(const Type *T) { } // Emit the serialized record. - S.EmitRecord(W.Code, Record); + Stream.EmitRecord(W.Code, Record); // Flush any expressions that were written as part of this type. - FlushExprs(); + FlushStmts(); } /// \brief Write a block containing all of the types. void PCHWriter::WriteTypesBlock(ASTContext &Context) { // Enter the types block. - S.EnterSubblock(pch::TYPES_BLOCK_ID, 2); + Stream.EnterSubblock(pch::TYPES_BLOCK_ID, 2); // Emit all of the types in the ASTContext for (std::vector::const_iterator T = Context.getTypes().begin(), @@ -1184,7 +1184,7 @@ void PCHWriter::WriteTypesBlock(ASTContext &Context) { } // Exit the types block - S.ExitBlock(); + Stream.ExitBlock(); } /// \brief Write the block containing all of the declaration IDs @@ -1197,14 +1197,14 @@ uint64_t PCHWriter::WriteDeclContextLexicalBlock(ASTContext &Context, if (DC->decls_empty(Context)) return 0; - uint64_t Offset = S.GetCurrentBitNo(); + uint64_t Offset = Stream.GetCurrentBitNo(); RecordData Record; for (DeclContext::decl_iterator D = DC->decls_begin(Context), DEnd = DC->decls_end(Context); D != DEnd; ++D) AddDeclRef(*D, Record); - S.EmitRecord(pch::DECL_CONTEXT_LEXICAL, Record); + Stream.EmitRecord(pch::DECL_CONTEXT_LEXICAL, Record); return Offset; } @@ -1226,7 +1226,7 @@ uint64_t PCHWriter::WriteDeclContextVisibleBlock(ASTContext &Context, // representation is the same for both cases: a declaration name, // followed by a size, followed by references to the visible // declarations that have that name. - uint64_t Offset = S.GetCurrentBitNo(); + uint64_t Offset = Stream.GetCurrentBitNo(); RecordData Record; StoredDeclsMap *Map = static_cast(DC->getLookupPtr()); if (!Map) @@ -1244,14 +1244,14 @@ uint64_t PCHWriter::WriteDeclContextVisibleBlock(ASTContext &Context, if (Record.size() == 0) return 0; - S.EmitRecord(pch::DECL_CONTEXT_VISIBLE, Record); + Stream.EmitRecord(pch::DECL_CONTEXT_VISIBLE, Record); return Offset; } /// \brief Write a block containing all of the declarations. void PCHWriter::WriteDeclsBlock(ASTContext &Context) { // Enter the declarations block. - S.EnterSubblock(pch::DECLS_BLOCK_ID, 2); + Stream.EnterSubblock(pch::DECLS_BLOCK_ID, 2); // Emit all of the declarations. RecordData Record; @@ -1283,10 +1283,10 @@ void PCHWriter::WriteDeclsBlock(ASTContext &Context) { // Record the offset for this declaration if (DeclOffsets.size() == Index) - DeclOffsets.push_back(S.GetCurrentBitNo()); + DeclOffsets.push_back(Stream.GetCurrentBitNo()); else if (DeclOffsets.size() < Index) { DeclOffsets.resize(Index+1); - DeclOffsets[Index] = S.GetCurrentBitNo(); + DeclOffsets[Index] = Stream.GetCurrentBitNo(); } // Build and emit a record for this declaration @@ -1295,14 +1295,14 @@ void PCHWriter::WriteDeclsBlock(ASTContext &Context) { W.Visit(D); if (DC) W.VisitDeclContext(DC, LexicalOffset, VisibleOffset); assert(W.Code && "Unhandled declaration kind while generating PCH"); - S.EmitRecord(W.Code, Record); + Stream.EmitRecord(W.Code, Record); // If the declaration had any attributes, write them now. if (D->hasAttrs()) WriteAttributeRecord(D->getAttrs()); // Flush any expressions that were written as part of this declaration. - FlushExprs(); + FlushStmts(); // Note external declarations so that we can add them to a record // in the PCH file later. @@ -1327,7 +1327,7 @@ void PCHWriter::WriteDeclsBlock(ASTContext &Context) { } // Exit the declarations block - S.ExitBlock(); + Stream.ExitBlock(); } /// \brief Write the identifier table into the PCH file. @@ -1367,16 +1367,16 @@ void PCHWriter::WriteIdentifierTable() { BitCodeAbbrev *Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(pch::IDENTIFIER_TABLE)); Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Triple name - unsigned IDTableAbbrev = S.EmitAbbrev(Abbrev); + unsigned IDTableAbbrev = Stream.EmitAbbrev(Abbrev); // Write the identifier table RecordData Record; Record.push_back(pch::IDENTIFIER_TABLE); - S.EmitRecordWithBlob(IDTableAbbrev, Record, &Data.front(), Data.size()); + Stream.EmitRecordWithBlob(IDTableAbbrev, Record, &Data.front(), Data.size()); } // Write the offsets table for identifier IDs. - S.EmitRecord(pch::IDENTIFIER_OFFSET, IdentOffsets); + Stream.EmitRecord(pch::IDENTIFIER_OFFSET, IdentOffsets); } /// \brief Write a record containing the given attributes. @@ -1497,7 +1497,7 @@ void PCHWriter::WriteAttributeRecord(const Attr *Attr) { } } - S.EmitRecord(pch::DECL_ATTR, Record); + Stream.EmitRecord(pch::DECL_ATTR, Record); } void PCHWriter::AddString(const std::string &Str, RecordData &Record) { @@ -1505,22 +1505,22 @@ void PCHWriter::AddString(const std::string &Str, RecordData &Record) { Record.insert(Record.end(), Str.begin(), Str.end()); } -PCHWriter::PCHWriter(llvm::BitstreamWriter &S) - : S(S), NextTypeID(pch::NUM_PREDEF_TYPE_IDS) { } +PCHWriter::PCHWriter(llvm::BitstreamWriter &Stream) + : Stream(Stream), NextTypeID(pch::NUM_PREDEF_TYPE_IDS) { } void PCHWriter::WritePCH(ASTContext &Context, const Preprocessor &PP) { // Emit the file header. - S.Emit((unsigned)'C', 8); - S.Emit((unsigned)'P', 8); - S.Emit((unsigned)'C', 8); - S.Emit((unsigned)'H', 8); + Stream.Emit((unsigned)'C', 8); + Stream.Emit((unsigned)'P', 8); + Stream.Emit((unsigned)'C', 8); + Stream.Emit((unsigned)'H', 8); // The translation unit is the first declaration we'll emit. DeclIDs[Context.getTranslationUnitDecl()] = 1; DeclsToEmit.push(Context.getTranslationUnitDecl()); // Write the remaining PCH contents. - S.EnterSubblock(pch::PCH_BLOCK_ID, 3); + Stream.EnterSubblock(pch::PCH_BLOCK_ID, 3); WriteTargetTriple(Context.Target); WriteLanguageOptions(Context.getLangOptions()); WriteSourceManagerBlock(Context.getSourceManager()); @@ -1528,11 +1528,11 @@ void PCHWriter::WritePCH(ASTContext &Context, const Preprocessor &PP) { WriteTypesBlock(Context); WriteDeclsBlock(Context); WriteIdentifierTable(); - S.EmitRecord(pch::TYPE_OFFSET, TypeOffsets); - S.EmitRecord(pch::DECL_OFFSET, DeclOffsets); + Stream.EmitRecord(pch::TYPE_OFFSET, TypeOffsets); + Stream.EmitRecord(pch::DECL_OFFSET, DeclOffsets); if (!ExternalDefinitions.empty()) - S.EmitRecord(pch::EXTERNAL_DEFINITIONS, ExternalDefinitions); - S.ExitBlock(); + Stream.EmitRecord(pch::EXTERNAL_DEFINITIONS, ExternalDefinitions); + Stream.ExitBlock(); } void PCHWriter::AddSourceLocation(SourceLocation Loc, RecordData &Record) { @@ -1658,52 +1658,53 @@ void PCHWriter::AddDeclarationName(DeclarationName Name, RecordData &Record) { } } -/// \brief Write the given subexpression to the bitstream. -void PCHWriter::WriteSubExpr(Expr *E) { +/// \brief Write the given substatement or subexpression to the +/// bitstream. +void PCHWriter::WriteSubStmt(Stmt *S) { RecordData Record; PCHStmtWriter Writer(*this, Record); - if (!E) { - S.EmitRecord(pch::EXPR_NULL, Record); + if (!S) { + Stream.EmitRecord(pch::STMT_NULL_PTR, Record); return; } - Writer.Code = pch::EXPR_NULL; - Writer.Visit(E); - assert(Writer.Code != pch::EXPR_NULL && + Writer.Code = pch::STMT_NULL_PTR; + Writer.Visit(S); + assert(Writer.Code != pch::STMT_NULL_PTR && "Unhandled expression writing PCH file"); - S.EmitRecord(Writer.Code, Record); + Stream.EmitRecord(Writer.Code, Record); } -/// \brief Flush all of the expressions that have been added to the -/// queue via AddExpr(). -void PCHWriter::FlushExprs() { +/// \brief Flush all of the statements that have been added to the +/// queue via AddStmt(). +void PCHWriter::FlushStmts() { RecordData Record; PCHStmtWriter Writer(*this, Record); - for (unsigned I = 0, N = ExprsToEmit.size(); I != N; ++I) { - Expr *E = ExprsToEmit[I]; + for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { + Stmt *S = StmtsToEmit[I]; - if (!E) { - S.EmitRecord(pch::EXPR_NULL, Record); + if (!S) { + Stream.EmitRecord(pch::STMT_NULL_PTR, Record); continue; } - Writer.Code = pch::EXPR_NULL; - Writer.Visit(E); - assert(Writer.Code != pch::EXPR_NULL && + Writer.Code = pch::STMT_NULL_PTR; + Writer.Visit(S); + assert(Writer.Code != pch::STMT_NULL_PTR && "Unhandled expression writing PCH file"); - S.EmitRecord(Writer.Code, Record); + Stream.EmitRecord(Writer.Code, Record); - assert(N == ExprsToEmit.size() && - "Subexpression writen via AddExpr rather than WriteSubExpr!"); + assert(N == StmtsToEmit.size() && + "Substatement writen via AddStmt rather than WriteSubStmt!"); // Note that we are at the end of a full expression. Any // expression records that follow this one are part of a different // expression. Record.clear(); - S.EmitRecord(pch::EXPR_STOP, Record); + Stream.EmitRecord(pch::STMT_STOP, Record); } - ExprsToEmit.clear(); + StmtsToEmit.clear(); }