From cc324ad80ab940efca006b0064f7ca70a6181816 Mon Sep 17 00:00:00 2001 From: Peter Collingbourne Date: Tue, 8 Feb 2011 21:18:02 +0000 Subject: [PATCH] AST: support for pre-arg expressions on CallExpr subclasses git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@125115 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/AST/Expr.h | 49 ++++++++++++++++++++++++++++--------- include/clang/AST/ExprCXX.h | 4 +-- include/clang/AST/Stmt.h | 8 ++++++ lib/AST/Expr.cpp | 35 +++++++++++++++++--------- 4 files changed, 71 insertions(+), 25 deletions(-) diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h index 247a4d10ba..8c28d52f49 100644 --- a/include/clang/AST/Expr.h +++ b/include/clang/AST/Expr.h @@ -1666,15 +1666,32 @@ public: /// a subclass for overloaded operator calls that use operator syntax, e.g., /// "str1 + str2" to resolve to a function call. class CallExpr : public Expr { - enum { FN=0, ARGS_START=1 }; + enum { FN=0, PREARGS_START=1 }; Stmt **SubExprs; unsigned NumArgs; SourceLocation RParenLoc; protected: - // This version of the constructor is for derived classes. - CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, unsigned numargs, - QualType t, ExprValueKind VK, SourceLocation rparenloc); + // These versions of the constructor are for derived classes. + CallExpr(ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs, + Expr **args, unsigned numargs, QualType t, ExprValueKind VK, + SourceLocation rparenloc); + CallExpr(ASTContext &C, StmtClass SC, unsigned NumPreArgs, EmptyShell Empty); + + Stmt *getPreArg(unsigned i) { + assert(i < getNumPreArgs() && "Prearg access out of range!"); + return SubExprs[PREARGS_START+i]; + } + const Stmt *getPreArg(unsigned i) const { + assert(i < getNumPreArgs() && "Prearg access out of range!"); + return SubExprs[PREARGS_START+i]; + } + void setPreArg(unsigned i, Stmt *PreArg) { + assert(i < getNumPreArgs() && "Prearg access out of range!"); + SubExprs[PREARGS_START+i] = PreArg; + } + + unsigned getNumPreArgs() const { return CallExprBits.NumPreArgs; } public: CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, QualType t, @@ -1703,22 +1720,24 @@ public: unsigned getNumArgs() const { return NumArgs; } /// \brief Retrieve the call arguments. - Expr **getArgs() { return reinterpret_cast(SubExprs + ARGS_START); } + Expr **getArgs() { + return reinterpret_cast(SubExprs+getNumPreArgs()+PREARGS_START); + } /// getArg - Return the specified argument. Expr *getArg(unsigned Arg) { assert(Arg < NumArgs && "Arg access out of range!"); - return cast(SubExprs[Arg+ARGS_START]); + return cast(SubExprs[Arg+getNumPreArgs()+PREARGS_START]); } const Expr *getArg(unsigned Arg) const { assert(Arg < NumArgs && "Arg access out of range!"); - return cast(SubExprs[Arg+ARGS_START]); + return cast(SubExprs[Arg+getNumPreArgs()+PREARGS_START]); } /// setArg - Set the specified argument. void setArg(unsigned Arg, Expr *ArgExpr) { assert(Arg < NumArgs && "Arg access out of range!"); - SubExprs[Arg+ARGS_START] = ArgExpr; + SubExprs[Arg+getNumPreArgs()+PREARGS_START] = ArgExpr; } /// setNumArgs - This changes the number of arguments present in this call. @@ -1729,10 +1748,16 @@ public: typedef ExprIterator arg_iterator; typedef ConstExprIterator const_arg_iterator; - arg_iterator arg_begin() { return SubExprs+ARGS_START; } - arg_iterator arg_end() { return SubExprs+ARGS_START+getNumArgs(); } - const_arg_iterator arg_begin() const { return SubExprs+ARGS_START; } - const_arg_iterator arg_end() const { return SubExprs+ARGS_START+getNumArgs();} + arg_iterator arg_begin() { return SubExprs+PREARGS_START+getNumPreArgs(); } + arg_iterator arg_end() { + return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs(); + } + const_arg_iterator arg_begin() const { + return SubExprs+PREARGS_START+getNumPreArgs(); + } + const_arg_iterator arg_end() const { + return SubExprs+PREARGS_START+getNumPreArgs()+getNumArgs(); + } /// getNumCommas - Return the number of commas that must have been present in /// this function call. diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h index 7c8ac95203..c0e35e3c89 100644 --- a/include/clang/AST/ExprCXX.h +++ b/include/clang/AST/ExprCXX.h @@ -52,7 +52,7 @@ public: CXXOperatorCallExpr(ASTContext& C, OverloadedOperatorKind Op, Expr *fn, Expr **args, unsigned numargs, QualType t, ExprValueKind VK, SourceLocation operatorloc) - : CallExpr(C, CXXOperatorCallExprClass, fn, args, numargs, t, VK, + : CallExpr(C, CXXOperatorCallExprClass, fn, 0, args, numargs, t, VK, operatorloc), Operator(Op) {} explicit CXXOperatorCallExpr(ASTContext& C, EmptyShell Empty) : @@ -91,7 +91,7 @@ class CXXMemberCallExpr : public CallExpr { public: CXXMemberCallExpr(ASTContext &C, Expr *fn, Expr **args, unsigned numargs, QualType t, ExprValueKind VK, SourceLocation RP) - : CallExpr(C, CXXMemberCallExprClass, fn, args, numargs, t, VK, RP) {} + : CallExpr(C, CXXMemberCallExprClass, fn, 0, args, numargs, t, VK, RP) {} CXXMemberCallExpr(ASTContext &C, EmptyShell Empty) : CallExpr(C, CXXMemberCallExprClass, Empty) { } diff --git a/include/clang/AST/Stmt.h b/include/clang/AST/Stmt.h index f68f78bd44..9662f1e4d1 100644 --- a/include/clang/AST/Stmt.h +++ b/include/clang/AST/Stmt.h @@ -174,12 +174,20 @@ protected: unsigned BasePathSize : 32 - 6 - NumExprBits; }; + class CallExprBitfields { + friend class CallExpr; + unsigned : NumExprBits; + + unsigned NumPreArgs : 1; + }; + union { StmtBitfields StmtBits; CompoundStmtBitfields CompoundStmtBits; LabelStmtBitfields LabelStmtBits; ExprBitfields ExprBits; CastExprBitfields CastExprBits; + CallExprBitfields CallExprBits; }; friend class ASTStmtReader; diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp index b22d9d5452..747f786542 100644 --- a/lib/AST/Expr.cpp +++ b/lib/AST/Expr.cpp @@ -647,8 +647,8 @@ OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) { // Postfix Operators. //===----------------------------------------------------------------------===// -CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, - unsigned numargs, QualType t, ExprValueKind VK, +CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs, + Expr **args, unsigned numargs, QualType t, ExprValueKind VK, SourceLocation rparenloc) : Expr(SC, t, VK, OK_Ordinary, fn->isTypeDependent(), @@ -656,7 +656,7 @@ CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, fn->containsUnexpandedParameterPack()), NumArgs(numargs) { - SubExprs = new (C) Stmt*[numargs+1]; + SubExprs = new (C) Stmt*[numargs+PREARGS_START+NumPreArgs]; SubExprs[FN] = fn; for (unsigned i = 0; i != numargs; ++i) { if (args[i]->isTypeDependent()) @@ -666,9 +666,10 @@ CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args, if (args[i]->containsUnexpandedParameterPack()) ExprBits.ContainsUnexpandedParameterPack = true; - SubExprs[i+ARGS_START] = args[i]; + SubExprs[i+PREARGS_START+NumPreArgs] = args[i]; } + CallExprBits.NumPreArgs = NumPreArgs; RParenLoc = rparenloc; } @@ -680,7 +681,7 @@ CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, fn->containsUnexpandedParameterPack()), NumArgs(numargs) { - SubExprs = new (C) Stmt*[numargs+1]; + SubExprs = new (C) Stmt*[numargs+PREARGS_START]; SubExprs[FN] = fn; for (unsigned i = 0; i != numargs; ++i) { if (args[i]->isTypeDependent()) @@ -690,16 +691,26 @@ CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs, if (args[i]->containsUnexpandedParameterPack()) ExprBits.ContainsUnexpandedParameterPack = true; - SubExprs[i+ARGS_START] = args[i]; + SubExprs[i+PREARGS_START] = args[i]; } + CallExprBits.NumPreArgs = 0; RParenLoc = rparenloc; } CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty) : Expr(SC, Empty), SubExprs(0), NumArgs(0) { // FIXME: Why do we allocate this? - SubExprs = new (C) Stmt*[1]; + SubExprs = new (C) Stmt*[PREARGS_START]; + CallExprBits.NumPreArgs = 0; +} + +CallExpr::CallExpr(ASTContext &C, StmtClass SC, unsigned NumPreArgs, + EmptyShell Empty) + : Expr(SC, Empty), SubExprs(0), NumArgs(0) { + // FIXME: Why do we allocate this? + SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs]; + CallExprBits.NumPreArgs = NumPreArgs; } Decl *CallExpr::getCalleeDecl() { @@ -738,12 +749,14 @@ void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) { } // Otherwise, we are growing the # arguments. New an bigger argument array. - Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1]; + unsigned NumPreArgs = getNumPreArgs(); + Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs]; // Copy over args. - for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i) + for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i) NewSubExprs[i] = SubExprs[i]; // Null out new args. - for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i) + for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs; + i != NumArgs+PREARGS_START+NumPreArgs; ++i) NewSubExprs[i] = 0; if (SubExprs) C.Deallocate(SubExprs); @@ -2823,7 +2836,7 @@ Stmt::child_iterator CallExpr::child_begin() { return &SubExprs[0]; } Stmt::child_iterator CallExpr::child_end() { - return &SubExprs[0]+NumArgs+ARGS_START; + return &SubExprs[0]+NumArgs+getNumPreArgs()+PREARGS_START; } // MemberExpr -- 2.40.0