summaryrefslogtreecommitdiffstats
path: root/clang
diff options
context:
space:
mode:
Diffstat (limited to 'clang')
-rw-r--r--clang/include/clang/AST/Expr.h197
-rw-r--r--clang/include/clang/AST/ExprObjC.h26
-rw-r--r--clang/lib/AST/Expr.cpp156
-rw-r--r--clang/lib/AST/StmtSerialization.cpp2
-rw-r--r--clang/lib/Analysis/CFRefCount.cpp16
-rw-r--r--clang/lib/CodeGen/CGBuiltin.cpp2
-rw-r--r--clang/lib/CodeGen/CGExpr.cpp30
-rw-r--r--clang/lib/CodeGen/CGExprAgg.cpp3
-rw-r--r--clang/lib/CodeGen/CGExprComplex.cpp4
-rw-r--r--clang/lib/CodeGen/CGExprScalar.cpp2
-rw-r--r--clang/lib/CodeGen/CodeGenFunction.h57
11 files changed, 226 insertions, 269 deletions
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index 0314a66a1d3..e5fd7521eee 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -142,6 +142,50 @@ public:
};
//===----------------------------------------------------------------------===//
+// ExprIterator - Iterators for iterating over Stmt* arrays that contain
+// only Expr*. This is needed because AST nodes use Stmt* arrays to store
+// references to children (to be compatible with StmtIterator).
+//===----------------------------------------------------------------------===//
+
+class ExprIterator {
+ Stmt** I;
+public:
+ ExprIterator(Stmt** i) : I(i) {}
+ ExprIterator() : I(0) {}
+ ExprIterator& operator++() { ++I; return *this; }
+ ExprIterator operator-(size_t i) { return I-i; }
+ ExprIterator operator+(size_t i) { return I+i; }
+ Expr* operator[](size_t idx) { return cast<Expr>(I[idx]); }
+ // FIXME: Verify that this will correctly return a signed distance.
+ signed operator-(const ExprIterator& R) const { return I - R.I; }
+ Expr* operator*() const { return cast<Expr>(*I); }
+ Expr* operator->() const { return cast<Expr>(*I); }
+ bool operator==(const ExprIterator& R) const { return I == R.I; }
+ bool operator!=(const ExprIterator& R) const { return I != R.I; }
+ bool operator>(const ExprIterator& R) const { return I > R.I; }
+ bool operator>=(const ExprIterator& R) const { return I >= R.I; }
+};
+
+class ConstExprIterator {
+ Stmt* const * I;
+public:
+ ConstExprIterator(Stmt* const* i) : I(i) {}
+ ConstExprIterator() : I(0) {}
+ ConstExprIterator& operator++() { ++I; return *this; }
+ ConstExprIterator operator+(size_t i) { return I+i; }
+ ConstExprIterator operator-(size_t i) { return I-i; }
+ Expr * const operator[](size_t idx) { return cast<Expr>(I[idx]); }
+ signed operator-(const ConstExprIterator& R) const { return I - R.I; }
+ Expr * const operator*() const { return cast<Expr>(*I); }
+ Expr * const operator->() const { return cast<Expr>(*I); }
+ bool operator==(const ConstExprIterator& R) const { return I == R.I; }
+ bool operator!=(const ConstExprIterator& R) const { return I != R.I; }
+ bool operator>(const ConstExprIterator& R) const { return I > R.I; }
+ bool operator>=(const ConstExprIterator& R) const { return I >= R.I; }
+};
+
+
+//===----------------------------------------------------------------------===//
// Primary Expressions.
//===----------------------------------------------------------------------===//
@@ -299,13 +343,13 @@ public:
/// whose element type matches the subexpression.
///
class ImaginaryLiteral : public Expr {
- Expr *Val;
+ Stmt *Val;
public:
ImaginaryLiteral(Expr *val, QualType Ty)
: Expr(ImaginaryLiteralClass, Ty), Val(val) {}
- const Expr *getSubExpr() const { return Val; }
- Expr *getSubExpr() { return Val; }
+ const Expr *getSubExpr() const { return cast<Expr>(Val); }
+ Expr *getSubExpr() { return cast<Expr>(Val); }
virtual SourceRange getSourceRange() const { return Val->getSourceRange(); }
static bool classof(const Stmt *T) {
@@ -363,13 +407,13 @@ public:
/// AST node is only formed if full location information is requested.
class ParenExpr : public Expr {
SourceLocation L, R;
- Expr *Val;
+ Stmt *Val;
public:
ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
: Expr(ParenExprClass, val->getType()), L(l), R(r), Val(val) {}
- const Expr *getSubExpr() const { return Val; }
- Expr *getSubExpr() { return Val; }
+ const Expr *getSubExpr() const { return cast<Expr>(Val); }
+ Expr *getSubExpr() { return cast<Expr>(Val); }
virtual SourceRange getSourceRange() const { return SourceRange(L, R); }
static bool classof(const Stmt *T) {
@@ -415,7 +459,7 @@ public:
OffsetOf // __builtin_offsetof
};
private:
- Expr *Val;
+ Stmt *Val;
Opcode Opc;
SourceLocation Loc;
public:
@@ -424,7 +468,7 @@ public:
: Expr(UnaryOperatorClass, type), Val(input), Opc(opc), Loc(l) {}
Opcode getOpcode() const { return Opc; }
- Expr *getSubExpr() const { return Val; }
+ Expr *getSubExpr() const { return cast<Expr>(Val); }
/// getOperatorLoc - Return the location of the operator.
SourceLocation getOperatorLoc() const { return Loc; }
@@ -507,7 +551,7 @@ public:
/// ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
class ArraySubscriptExpr : public Expr {
enum { LHS, RHS, END_EXPR=2 };
- Expr* SubExprs[END_EXPR];
+ Stmt* SubExprs[END_EXPR];
SourceLocation RBracketLoc;
public:
ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t,
@@ -526,26 +570,26 @@ public:
/// predicate the format conversion in getBase and getIdx only on the
/// the type of the RHS, as it is possible for the LHS to be a vector of
/// integer type
- Expr *getLHS() { return SubExprs[LHS]; }
- const Expr *getLHS() const { return SubExprs[LHS]; }
+ Expr *getLHS() { return cast<Expr>(SubExprs[LHS]); }
+ const Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
- Expr *getRHS() { return SubExprs[RHS]; }
- const Expr *getRHS() const { return SubExprs[RHS]; }
+ Expr *getRHS() { return cast<Expr>(SubExprs[RHS]); }
+ const Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
Expr *getBase() {
- return (getRHS()->getType()->isIntegerType()) ? getLHS() : getRHS();
+ return cast<Expr>(getRHS()->getType()->isIntegerType() ? getLHS():getRHS());
}
const Expr *getBase() const {
- return (getRHS()->getType()->isIntegerType()) ? getLHS() : getRHS();
+ return cast<Expr>(getRHS()->getType()->isIntegerType() ? getLHS():getRHS());
}
Expr *getIdx() {
- return (getRHS()->getType()->isIntegerType()) ? getRHS() : getLHS();
+ return cast<Expr>(getRHS()->getType()->isIntegerType() ? getRHS():getLHS());
}
const Expr *getIdx() const {
- return (getRHS()->getType()->isIntegerType()) ? getRHS() : getLHS();
+ return cast<Expr>(getRHS()->getType()->isIntegerType() ? getRHS():getLHS());
}
virtual SourceRange getSourceRange() const {
@@ -572,12 +616,12 @@ public:
///
class CallExpr : public Expr {
enum { FN=0, ARGS_START=1 };
- Expr **SubExprs;
+ Stmt **SubExprs;
unsigned NumArgs;
SourceLocation RParenLoc;
// This version of the ctor is for deserialization.
- CallExpr(Expr** subexprs, unsigned numargs, QualType t,
+ CallExpr(Stmt** subexprs, unsigned numargs, QualType t,
SourceLocation rparenloc)
: Expr(CallExprClass,t), SubExprs(subexprs),
NumArgs(numargs), RParenLoc(rparenloc) {}
@@ -589,8 +633,8 @@ public:
delete [] SubExprs;
}
- const Expr *getCallee() const { return SubExprs[FN]; }
- Expr *getCallee() { return SubExprs[FN]; }
+ const Expr *getCallee() const { return cast<Expr>(SubExprs[FN]); }
+ Expr *getCallee() { return cast<Expr>(SubExprs[FN]); }
void setCallee(Expr *F) { SubExprs[FN] = F; }
/// getNumArgs - Return the number of actual arguments to this call.
@@ -600,11 +644,11 @@ public:
/// getArg - Return the specified argument.
Expr *getArg(unsigned Arg) {
assert(Arg < NumArgs && "Arg access out of range!");
- return SubExprs[Arg+ARGS_START];
+ return cast<Expr>(SubExprs[Arg+ARGS_START]);
}
const Expr *getArg(unsigned Arg) const {
assert(Arg < NumArgs && "Arg access out of range!");
- return SubExprs[Arg+ARGS_START];
+ return cast<Expr>(SubExprs[Arg+ARGS_START]);
}
/// setArg - Set the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr) {
@@ -617,13 +661,13 @@ public:
/// to null.
void setNumArgs(unsigned NumArgs);
- typedef Expr **arg_iterator;
- typedef Expr * const *arg_const_iterator;
+ 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(); }
- arg_const_iterator arg_begin() const { return SubExprs+ARGS_START; }
- arg_const_iterator arg_end() const { 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();}
/// getNumCommas - Return the number of commas that must have been present in
/// this function call.
@@ -656,7 +700,7 @@ public:
/// MemberExpr - [C99 6.5.2.3] Structure and Union Members.
///
class MemberExpr : public Expr {
- Expr *Base;
+ Stmt *Base;
FieldDecl *MemberDecl;
SourceLocation MemberLoc;
bool IsArrow; // True if this is "X->F", false if this is "X.F".
@@ -666,7 +710,7 @@ public:
: Expr(MemberExprClass, ty),
Base(base), MemberDecl(memberdecl), MemberLoc(l), IsArrow(isarrow) {}
- Expr *getBase() const { return Base; }
+ Expr *getBase() const { return cast<Expr>(Base); }
FieldDecl *getMemberDecl() const { return MemberDecl; }
bool isArrow() const { return IsArrow; }
@@ -694,7 +738,7 @@ public:
/// the following is legal: "V.xy = V.zw" if V is a 4 element extended vector.
///
class ExtVectorElementExpr : public Expr {
- Expr *Base;
+ Stmt *Base;
IdentifierInfo &Accessor;
SourceLocation AccessorLoc;
public:
@@ -703,8 +747,8 @@ public:
: Expr(ExtVectorElementExprClass, ty),
Base(base), Accessor(accessor), AccessorLoc(loc) {}
- const Expr *getBase() const { return Base; }
- Expr *getBase() { return Base; }
+ const Expr *getBase() const { return cast<Expr>(Base); }
+ Expr *getBase() { return cast<Expr>(Base); }
IdentifierInfo &getAccessor() const { return Accessor; }
@@ -740,14 +784,14 @@ class CompoundLiteralExpr : public Expr {
/// compound literal like "(int){4}". This can be null if this is a
/// synthesized compound expression.
SourceLocation LParenLoc;
- Expr *Init;
+ Stmt *Init;
bool FileScope;
public:
CompoundLiteralExpr(SourceLocation lparenloc, QualType ty, Expr *init, bool fileScope) :
Expr(CompoundLiteralExprClass, ty), LParenLoc(lparenloc), Init(init), FileScope(fileScope) {}
- const Expr *getInitializer() const { return Init; }
- Expr *getInitializer() { return Init; }
+ const Expr *getInitializer() const { return cast<Expr>(Init); }
+ Expr *getInitializer() { return cast<Expr>(Init); }
bool isFileScope() const { return FileScope; }
@@ -780,13 +824,13 @@ public:
/// float->double, short->int, etc.
///
class ImplicitCastExpr : public Expr {
- Expr *Op;
+ Stmt *Op;
public:
ImplicitCastExpr(QualType ty, Expr *op) :
Expr(ImplicitCastExprClass, ty), Op(op) {}
- Expr *getSubExpr() { return Op; }
- const Expr *getSubExpr() const { return Op; }
+ Expr *getSubExpr() { return cast<Expr>(Op); }
+ const Expr *getSubExpr() const { return cast<Expr>(Op); }
virtual SourceRange getSourceRange() const { return Op->getSourceRange(); }
@@ -806,7 +850,7 @@ public:
/// CastExpr - [C99 6.5.4] Cast Operators.
///
class CastExpr : public Expr {
- Expr *Op;
+ Stmt *Op;
SourceLocation Loc; // the location of the left paren
public:
CastExpr(QualType ty, Expr *op, SourceLocation l) :
@@ -814,7 +858,7 @@ public:
SourceLocation getLParenLoc() const { return Loc; }
- Expr *getSubExpr() const { return Op; }
+ Expr *getSubExpr() const { return cast<Expr>(Op); }
virtual SourceRange getSourceRange() const {
return SourceRange(Loc, getSubExpr()->getSourceRange().getEnd());
@@ -857,7 +901,7 @@ public:
};
private:
enum { LHS, RHS, END_EXPR };
- Expr* SubExprs[END_EXPR];
+ Stmt* SubExprs[END_EXPR];
Opcode Opc;
SourceLocation OpLoc;
public:
@@ -873,8 +917,8 @@ public:
SourceLocation getOperatorLoc() const { return OpLoc; }
Opcode getOpcode() const { return Opc; }
- Expr *getLHS() const { return SubExprs[LHS]; }
- Expr *getRHS() const { return SubExprs[RHS]; }
+ Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
+ Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
virtual SourceRange getSourceRange() const {
return SourceRange(getLHS()->getLocStart(), getRHS()->getLocEnd());
}
@@ -952,7 +996,7 @@ public:
///
class ConditionalOperator : public Expr {
enum { COND, LHS, RHS, END_EXPR };
- Expr* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
+ Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
public:
ConditionalOperator(Expr *cond, Expr *lhs, Expr *rhs, QualType t)
: Expr(ConditionalOperatorClass, t) {
@@ -963,7 +1007,7 @@ public:
// getCond - Return the expression representing the condition for
// the ?: operator.
- Expr *getCond() const { return SubExprs[COND]; }
+ Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
// getTrueExpr - Return the subexpression representing the value of the ?:
// expression if the condition evaluates to true. In most cases this value
@@ -972,15 +1016,15 @@ public:
// e.g: x ?: y is shorthand for x ? x : y, except that the expression "x"
// is only evaluated once.
Expr *getTrueExpr() const {
- return SubExprs[LHS] ? SubExprs[LHS] : SubExprs[COND];
+ return cast<Expr>(SubExprs[LHS] ? SubExprs[LHS] : SubExprs[COND]);
}
// getTrueExpr - Return the subexpression representing the value of the ?:
// expression if the condition evaluates to false. This is the same as getRHS.
- Expr *getFalseExpr() const { return SubExprs[RHS]; }
+ Expr *getFalseExpr() const { return cast<Expr>(SubExprs[RHS]); }
- Expr *getLHS() const { return SubExprs[LHS]; }
- Expr *getRHS() const { return SubExprs[RHS]; }
+ Expr *getLHS() const { return cast_or_null<Expr>(SubExprs[LHS]); }
+ Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
virtual SourceRange getSourceRange() const {
return SourceRange(getCond()->getLocStart(), getRHS()->getLocEnd());
@@ -1030,15 +1074,15 @@ public:
/// The StmtExpr contains a single CompoundStmt node, which it evaluates and
/// takes the value of the last subexpression.
class StmtExpr : public Expr {
- CompoundStmt *SubStmt;
+ Stmt *SubStmt;
SourceLocation LParenLoc, RParenLoc;
public:
StmtExpr(CompoundStmt *substmt, QualType T,
SourceLocation lp, SourceLocation rp) :
Expr(StmtExprClass, T), SubStmt(substmt), LParenLoc(lp), RParenLoc(rp) { }
- CompoundStmt *getSubStmt() { return SubStmt; }
- const CompoundStmt *getSubStmt() const { return SubStmt; }
+ CompoundStmt *getSubStmt() { return cast<CompoundStmt>(SubStmt); }
+ const CompoundStmt *getSubStmt() const { return cast<CompoundStmt>(SubStmt); }
virtual SourceRange getSourceRange() const {
return SourceRange(LParenLoc, RParenLoc);
@@ -1100,7 +1144,7 @@ class ShuffleVectorExpr : public Expr {
// function. The first two are vectors, and the rest are constant
// indices. The number of values in this list is always
// 2+the number of indices in the vector type.
- Expr **SubExprs;
+ Stmt **SubExprs;
unsigned NumExprs;
public:
@@ -1110,7 +1154,7 @@ public:
Expr(ShuffleVectorExprClass, Type), BuiltinLoc(BLoc),
RParenLoc(RP), NumExprs(nexpr) {
- SubExprs = new Expr*[nexpr];
+ SubExprs = new Stmt*[nexpr];
for (unsigned i = 0; i < nexpr; i++)
SubExprs[i] = args[i];
}
@@ -1135,11 +1179,11 @@ public:
/// getExpr - Return the Expr at the specified index.
Expr *getExpr(unsigned Index) {
assert((Index < NumExprs) && "Arg access out of range!");
- return SubExprs[Index];
+ return cast<Expr>(SubExprs[Index]);
}
const Expr *getExpr(unsigned Index) const {
assert((Index < NumExprs) && "Arg access out of range!");
- return SubExprs[Index];
+ return cast<Expr>(SubExprs[Index]);
}
unsigned getShuffleMaskIdx(ASTContext &Ctx, unsigned N) {
@@ -1163,7 +1207,7 @@ public:
/// - does not evaluate the expression that was not chosen.
class ChooseExpr : public Expr {
enum { COND, LHS, RHS, END_EXPR };
- Expr* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
+ Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
SourceLocation BuiltinLoc, RParenLoc;
public:
ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t,
@@ -1179,9 +1223,9 @@ public:
/// statically knowable for a well-formed choosexpr.
bool isConditionTrue(ASTContext &C) const;
- Expr *getCond() const { return SubExprs[COND]; }
- Expr *getLHS() const { return SubExprs[LHS]; }
- Expr *getRHS() const { return SubExprs[RHS]; }
+ Expr *getCond() const { return cast<Expr>(SubExprs[COND]); }
+ Expr *getLHS() const { return cast<Expr>(SubExprs[LHS]); }
+ Expr *getRHS() const { return cast<Expr>(SubExprs[RHS]); }
virtual SourceRange getSourceRange() const {
return SourceRange(BuiltinLoc, RParenLoc);
@@ -1219,7 +1263,7 @@ class OverloadExpr : public Expr {
// SubExpr[0] is a constant expression
// SubExpr[1-N] are the parameters to pass to the matching function call
// SubExpr[N-...] are the candidate functions, of type pointer to function.
- Expr **SubExprs;
+ Stmt **SubExprs;
// NumExprs - the size of the SubExprs array
unsigned NumExprs;
@@ -1234,7 +1278,7 @@ public:
SourceLocation bloc, SourceLocation rploc)
: Expr(OverloadExprClass, t), NumExprs(nexprs), FnIndex(idx),
BuiltinLoc(bloc), RParenLoc(rploc) {
- SubExprs = new Expr*[nexprs];
+ SubExprs = new Stmt*[nexprs];
for (unsigned i = 0; i != nexprs; ++i)
SubExprs[i] = args[i];
}
@@ -1245,14 +1289,17 @@ public:
/// arg_begin - Return a pointer to the list of arguments that will be passed
/// to the matching candidate function, skipping over the initial constant
/// expression.
- typedef Expr * const *arg_const_iterator;
- arg_const_iterator arg_begin() const { return SubExprs+1; }
-
+ typedef ConstExprIterator const_arg_iterator;
+ const_arg_iterator arg_begin() const { return &SubExprs[0]+1; }
+ const_arg_iterator arg_end(ASTContext& Ctx) const {
+ return &SubExprs[0]+1+getNumArgs(Ctx);
+ }
+
/// getNumArgs - Return the number of arguments to pass to the candidate
/// functions.
unsigned getNumArgs(ASTContext &Ctx) const {
llvm::APSInt constEval(32);
- (void) SubExprs[0]->isIntegerConstantExpr(constEval, Ctx);
+ (void) cast<Expr>(SubExprs[0])->isIntegerConstantExpr(constEval, Ctx);
return constEval.getZExtValue();
}
@@ -1264,11 +1311,11 @@ public:
/// getExpr - Return the Expr at the specified index.
Expr *getExpr(unsigned Index) {
assert((Index < NumExprs) && "Arg access out of range!");
- return SubExprs[Index];
+ return cast<Expr>(SubExprs[Index]);
}
/// getFn - Return the matching candidate function for this OverloadExpr.
- Expr *getFn() const { return SubExprs[FnIndex]; }
+ Expr *getFn() const { return cast<Expr>(SubExprs[FnIndex]); }
virtual SourceRange getSourceRange() const {
return SourceRange(BuiltinLoc, RParenLoc);
@@ -1285,7 +1332,7 @@ public:
/// VAArgExpr, used for the builtin function __builtin_va_start.
class VAArgExpr : public Expr {
- Expr *Val;
+ Stmt *Val;
SourceLocation BuiltinLoc, RParenLoc;
public:
VAArgExpr(SourceLocation BLoc, Expr* e, QualType t, SourceLocation RPLoc)
@@ -1294,8 +1341,8 @@ public:
BuiltinLoc(BLoc),
RParenLoc(RPLoc) { }
- const Expr *getSubExpr() const { return Val; }
- Expr *getSubExpr() { return Val; }
+ const Expr *getSubExpr() const { return cast<Expr>(Val); }
+ Expr *getSubExpr() { return cast<Expr>(Val); }
virtual SourceRange getSourceRange() const {
return SourceRange(BuiltinLoc, RParenLoc);
}
@@ -1329,7 +1376,7 @@ public:
/// int x = { 1 }; int y[2] = { {1}, {2} };
///
class InitListExpr : public Expr {
- std::vector<Expr *> InitExprs;
+ std::vector<Stmt *> InitExprs;
SourceLocation LBraceLoc, RBraceLoc;
public:
InitListExpr(SourceLocation lbraceloc, Expr **initexprs, unsigned numinits,
@@ -1339,12 +1386,12 @@ public:
const Expr* getInit(unsigned Init) const {
assert(Init < getNumInits() && "Initializer access out of range!");
- return InitExprs[Init];
+ return cast<Expr>(InitExprs[Init]);
}
Expr* getInit(unsigned Init) {
assert(Init < getNumInits() && "Initializer access out of range!");
- return InitExprs[Init];
+ return cast<Expr>(InitExprs[Init]);
}
void setInit(unsigned Init, Expr *expr) {
diff --git a/clang/include/clang/AST/ExprObjC.h b/clang/include/clang/AST/ExprObjC.h
index 0118c38a7aa..12c5afc80a1 100644
--- a/clang/include/clang/AST/ExprObjC.h
+++ b/clang/include/clang/AST/ExprObjC.h
@@ -152,7 +152,7 @@ public:
class ObjCIvarRefExpr : public Expr {
class ObjCIvarDecl *D;
SourceLocation Loc;
- Expr *Base;
+ Stmt *Base;
bool IsArrow:1; // True if this is "X->F", false if this is "X.F".
bool IsFreeIvar:1; // True if ivar reference has no base (self assumed).
@@ -168,8 +168,8 @@ public:
return isFreeIvar() ? SourceRange(Loc)
: SourceRange(getBase()->getLocStart(), Loc);
}
- const Expr *getBase() const { return Base; }
- Expr *getBase() { return Base; }
+ const Expr *getBase() const { return cast<Expr>(Base); }
+ Expr *getBase() { return cast<Expr>(Base); }
void setBase(Expr * base) { Base = base; }
bool isArrow() const { return IsArrow; }
bool isFreeIvar() const { return IsFreeIvar; }
@@ -193,7 +193,7 @@ public:
class ObjCPropertyRefExpr : public Expr {
class Decl *D; // an ObjCMethodDecl or ObjCPropertyDecl
SourceLocation Loc;
- Expr *Base;
+ Stmt *Base;
public:
ObjCPropertyRefExpr(Decl *d, QualType t, SourceLocation l, Expr *base) :
@@ -205,8 +205,8 @@ public:
virtual SourceRange getSourceRange() const {
return SourceRange(getBase()->getLocStart(), Loc);
}
- const Expr *getBase() const { return Base; }
- Expr *getBase() { return Base; }
+ const Expr *getBase() const { return cast<Expr>(Base); }
+ Expr *getBase() { return cast<Expr>(Base); }
void setBase(Expr * base) { Base = base; }
SourceLocation getLocation() const { return Loc; }
@@ -227,7 +227,7 @@ public:
class ObjCMessageExpr : public Expr {
enum { RECEIVER=0, ARGS_START=1 };
- Expr **SubExprs;
+ Stmt **SubExprs;
unsigned NumArgs;
@@ -297,11 +297,11 @@ public:
/// getArg - Return the specified argument.
Expr *getArg(unsigned Arg) {
assert(Arg < NumArgs && "Arg access out of range!");
- return SubExprs[Arg+ARGS_START];
+ return cast<Expr>(SubExprs[Arg+ARGS_START]);
}
const Expr *getArg(unsigned Arg) const {
assert(Arg < NumArgs && "Arg access out of range!");
- return SubExprs[Arg+ARGS_START];
+ return cast<Expr>(SubExprs[Arg+ARGS_START]);
}
/// setArg - Set the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr) {
@@ -322,13 +322,13 @@ public:
virtual child_iterator child_begin();
virtual child_iterator child_end();
- typedef Expr** arg_iterator;
- typedef const Expr* const* const_arg_iterator;
+ typedef ExprIterator arg_iterator;
+ typedef ConstExprIterator const_arg_iterator;
arg_iterator arg_begin() { return &SubExprs[ARGS_START]; }
- arg_iterator arg_end() { return arg_begin() + NumArgs; }
+ arg_iterator arg_end() { return &SubExprs[ARGS_START] + NumArgs; }
const_arg_iterator arg_begin() const { return &SubExprs[ARGS_START]; }
- const_arg_iterator arg_end() const { return arg_begin() + NumArgs; }
+ const_arg_iterator arg_end() const { return &SubExprs[ARGS_START] + NumArgs; }
// Serialization.
virtual void EmitImpl(llvm::Serializer& S) const;
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index 78c305051ee..496afd6457f 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -92,7 +92,7 @@ const char *UnaryOperator::getOpcodeStr(Opcode Op) {
CallExpr::CallExpr(Expr *fn, Expr **args, unsigned numargs, QualType t,
SourceLocation rparenloc)
: Expr(CallExprClass, t), NumArgs(numargs) {
- SubExprs = new Expr*[numargs+1];
+ SubExprs = new Stmt*[numargs+1];
SubExprs[FN] = fn;
for (unsigned i = 0; i != numargs; ++i)
SubExprs[i+ARGS_START] = args[i];
@@ -115,7 +115,7 @@ void CallExpr::setNumArgs(unsigned NumArgs) {
}
// Otherwise, we are growing the # arguments. New an bigger argument array.
- Expr **NewSubExprs = new Expr*[NumArgs+1];
+ Stmt **NewSubExprs = new Stmt*[NumArgs+1];
// Copy over args.
for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
NewSubExprs[i] = SubExprs[i];
@@ -1109,7 +1109,7 @@ ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
MethodProto(mproto) {
NumArgs = nargs;
- SubExprs = new Expr*[NumArgs+1];
+ SubExprs = new Stmt*[NumArgs+1];
SubExprs[RECEIVER] = receiver;
if (NumArgs) {
for (unsigned i = 0; i != NumArgs; ++i)
@@ -1128,7 +1128,7 @@ ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
MethodProto(mproto) {
NumArgs = nargs;
- SubExprs = new Expr*[NumArgs+1];
+ SubExprs = new Stmt*[NumArgs+1];
SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | 0x1);
if (NumArgs) {
for (unsigned i = 0; i != NumArgs; ++i)
@@ -1184,7 +1184,7 @@ int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const
assert(Opc == OffsetOf && "Unary operator not offsetof!");
unsigned CharSize = C.Target.getCharWidth();
- return ::evaluateOffsetOf(C, Val) / CharSize;
+ return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize;
}
//===----------------------------------------------------------------------===//
@@ -1196,22 +1196,12 @@ Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
// ObjCIvarRefExpr
-Stmt::child_iterator ObjCIvarRefExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Base);
-}
-
-Stmt::child_iterator ObjCIvarRefExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
+Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
// ObjCPropertyRefExpr
-Stmt::child_iterator ObjCPropertyRefExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Base);
-}
-
-Stmt::child_iterator ObjCPropertyRefExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
+Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
// ObjCSuperRefExpr
Stmt::child_iterator ObjCSuperRefExpr::child_begin() { return child_iterator();}
@@ -1234,32 +1224,20 @@ Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
// ImaginaryLiteral
-Stmt::child_iterator ImaginaryLiteral::child_begin() {
- return reinterpret_cast<Stmt**>(&Val);
-}
-Stmt::child_iterator ImaginaryLiteral::child_end() {
- return reinterpret_cast<Stmt**>(&Val)+1;
-}
+Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
+Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
// StringLiteral
Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
// ParenExpr
-Stmt::child_iterator ParenExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Val);
-}
-Stmt::child_iterator ParenExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Val)+1;
-}
+Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
+Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
// UnaryOperator
-Stmt::child_iterator UnaryOperator::child_begin() {
- return reinterpret_cast<Stmt**>(&Val);
-}
-Stmt::child_iterator UnaryOperator::child_end() {
- return reinterpret_cast<Stmt**>(&Val+1);
-}
+Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
+Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
// SizeOfAlignOfTypeExpr
Stmt::child_iterator SizeOfAlignOfTypeExpr::child_begin() {
@@ -1276,74 +1254,54 @@ Stmt::child_iterator SizeOfAlignOfTypeExpr::child_end() {
// ArraySubscriptExpr
Stmt::child_iterator ArraySubscriptExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs);
+ return &SubExprs[0];
}
Stmt::child_iterator ArraySubscriptExpr::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
+ return &SubExprs[0]+END_EXPR;
}
// CallExpr
Stmt::child_iterator CallExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs[0]);
+ return &SubExprs[0];
}
Stmt::child_iterator CallExpr::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs[NumArgs+ARGS_START]);
+ return &SubExprs[0]+NumArgs+ARGS_START;
}
// MemberExpr
-Stmt::child_iterator MemberExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Base);
-}
-Stmt::child_iterator MemberExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
+Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
// ExtVectorElementExpr
-Stmt::child_iterator ExtVectorElementExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Base);
-}
-Stmt::child_iterator ExtVectorElementExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Base)+1;
-}
+Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
+Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
// CompoundLiteralExpr
-Stmt::child_iterator CompoundLiteralExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Init);
-}
-Stmt::child_iterator CompoundLiteralExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Init)+1;
-}
+Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
+Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
// ImplicitCastExpr
-Stmt::child_iterator ImplicitCastExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Op);
-}
-Stmt::child_iterator ImplicitCastExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Op)+1;
-}
+Stmt::child_iterator ImplicitCastExpr::child_begin() { return &Op; }
+Stmt::child_iterator ImplicitCastExpr::child_end() { return &Op+1; }
// CastExpr
-Stmt::child_iterator CastExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Op);
-}
-Stmt::child_iterator CastExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Op)+1;
-}
+Stmt::child_iterator CastExpr::child_begin() { return &Op; }
+Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
// BinaryOperator
Stmt::child_iterator BinaryOperator::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs);
+ return &SubExprs[0];
}
Stmt::child_iterator BinaryOperator::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
+ return &SubExprs[0]+END_EXPR;
}
// ConditionalOperator
Stmt::child_iterator ConditionalOperator::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs);
+ return &SubExprs[0];
}
Stmt::child_iterator ConditionalOperator::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
+ return &SubExprs[0]+END_EXPR;
}
// AddrLabelExpr
@@ -1351,12 +1309,8 @@ Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
// StmtExpr
-Stmt::child_iterator StmtExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&SubStmt);
-}
-Stmt::child_iterator StmtExpr::child_end() {
- return reinterpret_cast<Stmt**>(&SubStmt)+1;
-}
+Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
+Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
// TypesCompatibleExpr
Stmt::child_iterator TypesCompatibleExpr::child_begin() {
@@ -1368,47 +1322,31 @@ Stmt::child_iterator TypesCompatibleExpr::child_end() {
}
// ChooseExpr
-Stmt::child_iterator ChooseExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs);
-}
-
-Stmt::child_iterator ChooseExpr::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs)+END_EXPR;
-}
+Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
+Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
// OverloadExpr
-Stmt::child_iterator OverloadExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs[0]);
-}
-Stmt::child_iterator OverloadExpr::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]);
-}
+Stmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; }
+Stmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; }
// ShuffleVectorExpr
Stmt::child_iterator ShuffleVectorExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs[0]);
+ return &SubExprs[0];
}
Stmt::child_iterator ShuffleVectorExpr::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs[NumExprs]);
+ return &SubExprs[0]+NumExprs;
}
// VAArgExpr
-Stmt::child_iterator VAArgExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&Val);
-}
-
-Stmt::child_iterator VAArgExpr::child_end() {
- return reinterpret_cast<Stmt**>(&Val)+1;
-}
+Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
+Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
// InitListExpr
Stmt::child_iterator InitListExpr::child_begin() {
- return reinterpret_cast<Stmt**>(InitExprs.size() ?
- &InitExprs[0] : 0);
+ return InitExprs.size() ? &InitExprs[0] : 0;
}
Stmt::child_iterator InitListExpr::child_end() {
- return reinterpret_cast<Stmt**>(InitExprs.size() ?
- &InitExprs[0] + InitExprs.size() : 0);
+ return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
}
// ObjCStringLiteral
@@ -1441,9 +1379,9 @@ Stmt::child_iterator ObjCProtocolExpr::child_end() {
// ObjCMessageExpr
Stmt::child_iterator ObjCMessageExpr::child_begin() {
- return reinterpret_cast<Stmt**>(&SubExprs[ getReceiver() ? 0 : ARGS_START ]);
+ return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
}
Stmt::child_iterator ObjCMessageExpr::child_end() {
- return reinterpret_cast<Stmt**>(&SubExprs[getNumArgs()+ARGS_START]);
+ return &SubExprs[0]+ARGS_START+getNumArgs();
}
diff --git a/clang/lib/AST/StmtSerialization.cpp b/clang/lib/AST/StmtSerialization.cpp
index 6fcc1ef4282..cc794f0c8d7 100644
--- a/clang/lib/AST/StmtSerialization.cpp
+++ b/clang/lib/AST/StmtSerialization.cpp
@@ -338,7 +338,7 @@ 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];
+ Stmt** SubExprs = new Stmt*[NumArgs+1];
D.BatchReadOwnedPtrs(NumArgs+1, SubExprs, C);
return new CallExpr(SubExprs,NumArgs,t,L);
diff --git a/clang/lib/Analysis/CFRefCount.cpp b/clang/lib/Analysis/CFRefCount.cpp
index 24971edcdde..7207c133ade 100644
--- a/clang/lib/Analysis/CFRefCount.cpp
+++ b/clang/lib/Analysis/CFRefCount.cpp
@@ -194,10 +194,10 @@ public:
return Receiver;
}
- typedef ArgEffects::const_iterator arg_iterator;
+ typedef ArgEffects::const_iterator ExprIterator;
- arg_iterator begin_args() const { return Args->begin(); }
- arg_iterator end_args() const { return Args->end(); }
+ ExprIterator begin_args() const { return Args->begin(); }
+ ExprIterator end_args() const { return Args->end(); }
static void Profile(llvm::FoldingSetNodeID& ID, ArgEffects* A,
RetEffect RetEff, ArgEffect DefaultEff,
@@ -998,7 +998,7 @@ public:
Expr* Ex,
Expr* Receiver,
RetainSummary* Summ,
- Expr** arg_beg, Expr** arg_end,
+ ExprIterator arg_beg, ExprIterator arg_end,
ExplodedNode<ValueState>* Pred);
virtual void EvalCall(ExplodedNodeSet<ValueState>& Dst,
@@ -1129,7 +1129,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<ValueState>& Dst,
Expr* Ex,
Expr* Receiver,
RetainSummary* Summ,
- Expr** arg_beg, Expr** arg_end,
+ ExprIterator arg_beg, ExprIterator arg_end,
ExplodedNode<ValueState>* Pred) {
@@ -1146,7 +1146,7 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<ValueState>& Dst,
Expr* ErrorExpr = NULL;
SymbolID ErrorSym = 0;
- for (Expr **I = arg_beg, **E = arg_end; I != E; ++I, ++idx) {
+ for (ExprIterator I = arg_beg; I != arg_end; ++I, ++idx) {
RVal V = StateMgr.GetRVal(St, *I);
@@ -1235,9 +1235,9 @@ void CFRefCount::EvalSummary(ExplodedNodeSet<ValueState>& Dst,
case RetEffect::Alias: {
unsigned idx = RE.getValue();
- assert ((arg_end - arg_beg) >= 0);
+ assert (arg_end >= arg_beg);
assert (idx < (unsigned) (arg_end - arg_beg));
- RVal V = StateMgr.GetRVal(St, arg_beg[idx]);
+ RVal V = StateMgr.GetRVal(St, *(arg_beg+idx));
St = StateMgr.SetRVal(St, Ex, V, Eng.getCFG().isBlkExpr(Ex), false);
break;
}
diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
index f8132f417de..cd6b742b625 100644
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -42,7 +42,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E) {
if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
return EmitCallExpr(CGM.getBuiltinLibFunction(BuiltinID),
E->getCallee()->getType(), E->arg_begin(),
- E->getNumArgs());
+ E->arg_end());
// See if we have a target specific intrinsic.
Intrinsic::ID IntrinsicID;
diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
index 05a8972a404..5856531f433 100644
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -650,13 +650,15 @@ RValue CodeGenFunction::EmitCallExpr(const CallExpr *E) {
llvm::Value *Callee = EmitScalarExpr(E->getCallee());
return EmitCallExpr(Callee, E->getCallee()->getType(),
- E->arg_begin(), E->getNumArgs());
+ E->arg_begin(), E->arg_end());
}
-RValue CodeGenFunction::EmitCallExpr(Expr *FnExpr, Expr *const *Args,
- unsigned NumArgs) {
+RValue CodeGenFunction::EmitCallExpr(Expr *FnExpr,
+ CallExpr::const_arg_iterator ArgBeg,
+ CallExpr::const_arg_iterator ArgEnd) {
+
llvm::Value *Callee = EmitScalarExpr(FnExpr);
- return EmitCallExpr(Callee, FnExpr->getType(), Args, NumArgs);
+ return EmitCallExpr(Callee, FnExpr->getType(), ArgBeg, ArgEnd);
}
LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
@@ -702,7 +704,9 @@ LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
}
RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType FnType,
- Expr *const *ArgExprs, unsigned NumArgs) {
+ CallExpr::const_arg_iterator ArgBeg,
+ CallExpr::const_arg_iterator ArgEnd) {
+
// The callee type will always be a pointer to function type, get the function
// type.
FnType = cast<PointerType>(FnType.getCanonicalType())->getPointeeType();
@@ -718,20 +722,20 @@ RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType FnType,
// FIXME: set the stret attribute on the argument.
}
- for (unsigned i = 0, e = NumArgs; i != e; ++i) {
- QualType ArgTy = ArgExprs[i]->getType();
+ for (CallExpr::const_arg_iterator I = ArgBeg; I != ArgEnd; ++I) {
+ QualType ArgTy = I->getType();
if (!hasAggregateLLVMType(ArgTy)) {
// Scalar argument is passed by-value.
- Args.push_back(EmitScalarExpr(ArgExprs[i]));
+ Args.push_back(EmitScalarExpr(*I));
} else if (ArgTy->isAnyComplexType()) {
// Make a temporary alloca to pass the argument.
llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy));
- EmitComplexExprIntoAddr(ArgExprs[i], DestMem, false);
+ EmitComplexExprIntoAddr(*I, DestMem, false);
Args.push_back(DestMem);
} else {
llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy));
- EmitAggExpr(ArgExprs[i], DestMem, false);
+ EmitAggExpr(*I, DestMem, false);
Args.push_back(DestMem);
}
}
@@ -744,8 +748,10 @@ RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType FnType,
ParamAttrList.push_back(
llvm::ParamAttrsWithIndex::get(1, llvm::ParamAttr::StructRet));
unsigned increment = hasAggregateLLVMType(ResultType) ? 2 : 1;
- for (unsigned i = 0; i < NumArgs; i++) {
- QualType ParamType = ArgExprs[i]->getType();
+
+ unsigned i = 0;
+ for (CallExpr::const_arg_iterator I = ArgBeg; I != ArgEnd; ++I, ++i) {
+ QualType ParamType = I->getType();
unsigned ParamAttrs = 0;
if (ParamType->isRecordType())
ParamAttrs |= llvm::ParamAttr::ByVal;
diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp
index 924a5cf46d8..748ddde7b7e 100644
--- a/clang/lib/CodeGen/CGExprAgg.cpp
+++ b/clang/lib/CodeGen/CGExprAgg.cpp
@@ -206,7 +206,8 @@ void AggExprEmitter::VisitCallExpr(const CallExpr *E)
void AggExprEmitter::VisitOverloadExpr(const OverloadExpr *E)
{
RValue RV = CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
- E->getNumArgs(CGF.getContext()));
+ E->arg_end(CGF.getContext()));
+
assert(RV.isAggregate() && "Return value must be aggregate value!");
// If the result is ignored, don't copy from the value.
diff --git a/clang/lib/CodeGen/CGExprComplex.cpp b/clang/lib/CodeGen/CGExprComplex.cpp
index 8a8e7986770..6bf0d48c1ec 100644
--- a/clang/lib/CodeGen/CGExprComplex.cpp
+++ b/clang/lib/CodeGen/CGExprComplex.cpp
@@ -246,8 +246,8 @@ ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
}
ComplexPairTy ComplexExprEmitter::VisitOverloadExpr(const OverloadExpr *E) {
- return CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
- E->getNumArgs(CGF.getContext())).getComplexVal();
+ return CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
+ E->arg_end(CGF.getContext())).getComplexVal();
}
ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp
index ea92828f729..47bbd8827d4 100644
--- a/clang/lib/CodeGen/CGExprScalar.cpp
+++ b/clang/lib/CodeGen/CGExprScalar.cpp
@@ -1095,7 +1095,7 @@ Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
Value *ScalarExprEmitter::VisitOverloadExpr(OverloadExpr *E) {
return CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
- E->getNumArgs(CGF.getContext())).getScalarVal();
+ E->arg_end(CGF.getContext())).getScalarVal();
}
Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index 313d2d1829a..6712d2f05f1 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -18,6 +18,9 @@
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/IRBuilder.h"
+#include "clang/AST/Expr.h"
+#include "clang/AST/ExprObjC.h"
+
#include <vector>
namespace llvm {
@@ -31,50 +34,7 @@ namespace clang {
class ObjCMethodDecl;
class TargetInfo;
class FunctionTypeProto;
-
- class Stmt;
- class CompoundStmt;
- class LabelStmt;
- class GotoStmt;
- class IfStmt;
- class WhileStmt;
- class DoStmt;
- class ForStmt;
- class ReturnStmt;
- class DeclStmt;
- class CaseStmt;
- class DefaultStmt;
- class SwitchStmt;
- class AsmStmt;
-
- class Expr;
- class DeclRefExpr;
- class StringLiteral;
- class IntegerLiteral;
- class FloatingLiteral;
- class CharacterLiteral;
- class TypesCompatibleExpr;
-
- class ImplicitCastExpr;
- class CastExpr;
- class CallExpr;
- class UnaryOperator;
- class BinaryOperator;
- class CompoundAssignOperator;
- class ArraySubscriptExpr;
- class ExtVectorElementExpr;
- class ConditionalOperator;
- class ChooseExpr;
- class PreDefinedExpr;
- class ObjCStringLiteral;
- class ObjCIvarRefExpr;
- class MemberExpr;
- class CompoundLiteralExpr;
-
- class VarDecl;
- class EnumConstantDecl;
- class ParmVarDecl;
- class FieldDecl;
+
namespace CodeGen {
class CodeGenModule;
class CodeGenTypes;
@@ -468,9 +428,14 @@ public:
//===--------------------------------------------------------------------===//
RValue EmitCallExpr(const CallExpr *E);
- RValue EmitCallExpr(Expr *FnExpr, Expr *const *Args, unsigned NumArgs);
+
+ RValue EmitCallExpr(Expr *FnExpr, CallExpr::const_arg_iterator ArgBeg,
+ CallExpr::const_arg_iterator ArgEnd);
+
RValue EmitCallExpr(llvm::Value *Callee, QualType FnType,
- Expr *const *Args, unsigned NumArgs);
+ CallExpr::const_arg_iterator ArgBeg,
+ CallExpr::const_arg_iterator ArgEnd);
+
RValue EmitBuiltinExpr(unsigned BuiltinID, const CallExpr *E);
llvm::Value *EmitX86BuiltinExpr(unsigned BuiltinID, const CallExpr *E);
OpenPOWER on IntegriCloud