From: Argyrios Kyrtzidis Date: Mon, 28 Jun 2010 09:31:48 +0000 (+0000) Subject: Refactor PCH reading/writing of template arguments passed to expressions. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=36c76f0bea0d3595a25a5362225c642019cc3176;p=clang Refactor PCH reading/writing of template arguments passed to expressions. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@106997 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h index d9058ac326..534ffa4e55 100644 --- a/include/clang/AST/ExprCXX.h +++ b/include/clang/AST/ExprCXX.h @@ -1947,20 +1947,6 @@ class CXXDependentScopeMemberExpr : public Expr { /// \brief The location of the member name. SourceLocation MemberLoc; - /// \brief Retrieve the explicit template argument list that followed the - /// member template name, if any. - ExplicitTemplateArgumentList *getExplicitTemplateArgumentList() { - assert(HasExplicitTemplateArgs); - return reinterpret_cast(this + 1); - } - - /// \brief Retrieve the explicit template argument list that followed the - /// member template name, if any. - const ExplicitTemplateArgumentList *getExplicitTemplateArgumentList() const { - return const_cast(this) - ->getExplicitTemplateArgumentList(); - } - CXXDependentScopeMemberExpr(ASTContext &C, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, @@ -2071,6 +2057,20 @@ public: return HasExplicitTemplateArgs; } + /// \brief Retrieve the explicit template argument list that followed the + /// member template name, if any. + ExplicitTemplateArgumentList *getExplicitTemplateArgumentList() { + assert(HasExplicitTemplateArgs); + return reinterpret_cast(this + 1); + } + + /// \brief Retrieve the explicit template argument list that followed the + /// member template name, if any. + const ExplicitTemplateArgumentList *getExplicitTemplateArgumentList() const { + return const_cast(this) + ->getExplicitTemplateArgumentList(); + } + /// \brief Copies the template arguments (if present) into the given /// structure. void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const { diff --git a/lib/Frontend/PCHReaderStmt.cpp b/lib/Frontend/PCHReaderStmt.cpp index 1cdade5cc1..a2334d7330 100644 --- a/lib/Frontend/PCHReaderStmt.cpp +++ b/lib/Frontend/PCHReaderStmt.cpp @@ -19,14 +19,6 @@ using namespace clang; namespace { - class StmtStackExprReader : public PCHReader::ExprReader { - llvm::SmallVectorImpl::iterator StmtI; - public: - StmtStackExprReader(const llvm::SmallVectorImpl::iterator &stmtI) - : StmtI(stmtI) { } - virtual Expr *Read() { return cast_or_null(*StmtI++); } - }; - class PCHStmtReader : public StmtVisitor { PCHReader &Reader; const PCHReader::RecordData &Record; @@ -45,6 +37,13 @@ namespace { /// \brief The number of record fields required for the Expr class /// itself. static const unsigned NumExprFields = NumStmtFields + 3; + + /// \brief Read and initialize a ExplicitTemplateArgumentList structure. + /// \return the number of Exprs that were read. + unsigned + ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList, + unsigned NumTemplateArgs, + llvm::SmallVectorImpl::iterator EndOfExprs); // Each of the Visit* functions reads in part of the expression // from the given record and the current expression stack, then @@ -156,6 +155,34 @@ namespace { }; } +unsigned PCHStmtReader:: +ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList, + unsigned NumTemplateArgs, + llvm::SmallVectorImpl::iterator EndOfExprs) { + + class StmtStackExprReader : public PCHReader::ExprReader { + llvm::SmallVectorImpl::iterator StmtI; + public: + StmtStackExprReader(const llvm::SmallVectorImpl::iterator &stmtI) + : StmtI(stmtI) { } + virtual Expr *Read() { return cast_or_null(*StmtI++); } + }; + + unsigned NumExprs = Record[Idx++]; + + TemplateArgumentListInfo ArgInfo; + ArgInfo.setLAngleLoc(Reader.ReadSourceLocation(Record, Idx)); + ArgInfo.setRAngleLoc(Reader.ReadSourceLocation(Record, Idx)); + + StmtStackExprReader ExprReader(EndOfExprs - NumExprs); + for (unsigned i = 0; i != NumTemplateArgs; ++i) + ArgInfo.addArgument(Reader.ReadTemplateArgumentLoc(Record, Idx, + ExprReader)); + ArgList.initializeFrom(ArgInfo); + + return NumExprs; +} + unsigned PCHStmtReader::VisitStmt(Stmt *S) { assert(Idx == NumStmtFields && "Incorrect statement field count"); return 0; @@ -1138,23 +1165,10 @@ PCHStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ unsigned NumTemplateArgs = Record[Idx++]; assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && "Read wrong record during creation ?"); - if (E->hasExplicitTemplateArgs()) { - TemplateArgumentListInfo ArgInfo; - ArgInfo.setLAngleLoc(Reader.ReadSourceLocation(Record, Idx)); - ArgInfo.setRAngleLoc(Reader.ReadSourceLocation(Record, Idx)); - - NumExprs = Record[Idx++]; - llvm::SmallVectorImpl::iterator - StartOfExprs = StmtStack.end() - NumExprs; - if (isa(E)) - --StartOfExprs; // UnresolvedMemberExpr contains an Expr; - StmtStackExprReader ExprReader(StartOfExprs); - for (unsigned i = 0; i != NumTemplateArgs; ++i) - ArgInfo.addArgument(Reader.ReadTemplateArgumentLoc(Record, Idx, - ExprReader)); - - E->initializeTemplateArgumentsFrom(ArgInfo); - } + if (E->hasExplicitTemplateArgs()) + NumExprs + = ReadExplicitTemplateArgumentList(*E->getExplicitTemplateArgumentList(), + NumTemplateArgs, StmtStack.end()); E->setBase(cast_or_null(StmtStack.back())); E->setBaseType(Reader.GetType(Record[Idx++])); @@ -1192,21 +1206,11 @@ unsigned PCHStmtReader::VisitOverloadExpr(OverloadExpr *E) { assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() && "Read wrong record during creation ?"); if (E->hasExplicitTemplateArgs()) { - TemplateArgumentListInfo ArgInfo; - ArgInfo.setLAngleLoc(Reader.ReadSourceLocation(Record, Idx)); - ArgInfo.setRAngleLoc(Reader.ReadSourceLocation(Record, Idx)); - - NumExprs = Record[Idx++]; - llvm::SmallVectorImpl::iterator - StartOfExprs = StmtStack.end() - NumExprs; + llvm::SmallVectorImpl::iterator EndOfExprs = StmtStack.end(); if (isa(E)) - --StartOfExprs; // UnresolvedMemberExpr contains an Expr; - StmtStackExprReader ExprReader(StartOfExprs); - for (unsigned i = 0; i != NumTemplateArgs; ++i) - ArgInfo.addArgument(Reader.ReadTemplateArgumentLoc(Record, Idx, - ExprReader)); - - E->getExplicitTemplateArgs().initializeFrom(ArgInfo); + --EndOfExprs; // UnresolvedMemberExpr contains an Expr. + NumExprs = ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(), + NumTemplateArgs, EndOfExprs); } unsigned NumDecls = Record[Idx++]; diff --git a/lib/Frontend/PCHWriterStmt.cpp b/lib/Frontend/PCHWriterStmt.cpp index cd58bd0236..a3f18dea39 100644 --- a/lib/Frontend/PCHWriterStmt.cpp +++ b/lib/Frontend/PCHWriterStmt.cpp @@ -32,6 +32,9 @@ namespace { PCHStmtWriter(PCHWriter &Writer, PCHWriter::RecordData &Record) : Writer(Writer), Record(Record) { } + + void + AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args); void VisitStmt(Stmt *S); void VisitNullStmt(NullStmt *S); @@ -142,6 +145,49 @@ namespace { }; } +/// \brief Return the number of Exprs contained in the given TemplateArgument. +static unsigned NumExprsContainedIn(const TemplateArgument &Arg) { + switch (Arg.getKind()) { + default: break; + case TemplateArgument::Expression: + return 1; + case TemplateArgument::Pack: { + unsigned Count = 0; + for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); + I != E; ++I) + Count += NumExprsContainedIn(*I); + return Count; + } + } + + return 0; +} + +/// \brief Return the number of Exprs contained in the given +/// ExplicitTemplateArgumentList. +static unsigned NumExprsContainedIn(const ExplicitTemplateArgumentList &Args) { + unsigned Count = 0; + for (unsigned i=0; i != Args.NumTemplateArgs; ++i) { + const TemplateArgumentLoc &ArgLoc = Args.getTemplateArgs()[i]; + const TemplateArgument &TemplA = ArgLoc.getArgument(); + Count += NumExprsContainedIn(TemplA); + if (TemplA.getKind() == TemplateArgument::Expression && + TemplA.getAsExpr() != ArgLoc.getLocInfo().getAsExpr()) + ++Count; // 1 in TemplateArgumentLocInfo. + } + + return Count; +} + +void PCHStmtWriter:: +AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args) { + Record.push_back(NumExprsContainedIn(Args)); + Writer.AddSourceLocation(Args.LAngleLoc, Record); + Writer.AddSourceLocation(Args.RAngleLoc, Record); + for (unsigned i=0; i != Args.NumTemplateArgs; ++i) + Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record); +} + void PCHStmtWriter::VisitStmt(Stmt *S) { } @@ -1025,54 +1071,19 @@ void PCHStmtWriter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { Code = pch::EXPR_CXX_EXPR_WITH_TEMPORARIES; } -/// \brief Return the number of Exprs contained in the given TemplateArgument. -static unsigned NumExprsContainedIn(const TemplateArgument Arg) { - switch (Arg.getKind()) { - default: break; - case TemplateArgument::Expression: - return 1; - case TemplateArgument::Pack: { - unsigned Count = 0; - for (TemplateArgument::pack_iterator I=Arg.pack_begin(), E=Arg.pack_end(); - I != E; ++I) - Count += NumExprsContainedIn(*I); - return Count; - } - } - - return 0; -} - -/// \brief Return the number of Exprs contained in the given -/// TemplateArgumentLoc. -static -unsigned NumExprsContainedIn(const TemplateArgumentLoc *Args,unsigned NumArgs) { - unsigned Count = 0; - for (unsigned i=0; i != NumArgs; ++i) { - const TemplateArgument &TemplA = Args[i].getArgument(); - Count += NumExprsContainedIn(TemplA); - if (TemplA.getKind() == TemplateArgument::Expression && - TemplA.getAsExpr() != Args[i].getLocInfo().getAsExpr()) - ++Count; // 1 in TemplateArgumentLocInfo. - } - - return Count; -} - void PCHStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){ VisitExpr(E); + + // Don't emit anything here, NumTemplateArgs must be emitted first. if (E->hasExplicitTemplateArgs()) { - assert(E->getNumTemplateArgs() && + const ExplicitTemplateArgumentList &Args + = *E->getExplicitTemplateArgumentList(); + assert(Args.NumTemplateArgs && "Num of template args was zero! PCH reading will mess up!"); - Record.push_back(E->getNumTemplateArgs()); - Writer.AddSourceLocation(E->getLAngleLoc(), Record); - Writer.AddSourceLocation(E->getRAngleLoc(), Record); - Record.push_back(NumExprsContainedIn(E->getTemplateArgs(), - E->getNumTemplateArgs())); - for (int i=0, e = E->getNumTemplateArgs(); i != e; ++i) - Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record); + Record.push_back(Args.NumTemplateArgs); + AddExplicitTemplateArgumentList(Args); } else { Record.push_back(0); } @@ -1108,18 +1119,15 @@ PCHStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) { void PCHStmtWriter::VisitOverloadExpr(OverloadExpr *E) { VisitExpr(E); + + // Don't emit anything here, NumTemplateArgs must be emitted first. if (E->hasExplicitTemplateArgs()) { const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs(); assert(Args.NumTemplateArgs && "Num of template args was zero! PCH reading will mess up!"); Record.push_back(Args.NumTemplateArgs); - Writer.AddSourceLocation(Args.LAngleLoc, Record); - Writer.AddSourceLocation(Args.RAngleLoc, Record); - Record.push_back(NumExprsContainedIn(Args.getTemplateArgs(), - Args.NumTemplateArgs)); - for (unsigned i=0; i != Args.NumTemplateArgs; ++i) - Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record); + AddExplicitTemplateArgumentList(Args); } else { Record.push_back(0); }