diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 78c3050..496afd6 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -92,7 +92,7 @@
 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 @@
   }
 
   // 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 @@
   : 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 @@
   : 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 @@
   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_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_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 @@
 
 // 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_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 @@
 }
 
 // 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 @@
 
 // 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/lib/AST/StmtSerialization.cpp b/lib/AST/StmtSerialization.cpp
index 6fcc1ef..cc794f0 100644
--- a/lib/AST/StmtSerialization.cpp
+++ b/lib/AST/StmtSerialization.cpp
@@ -338,7 +338,7 @@
   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/lib/Analysis/CFRefCount.cpp b/lib/Analysis/CFRefCount.cpp
index 24971ed..7207c13 100644
--- a/lib/Analysis/CFRefCount.cpp
+++ b/lib/Analysis/CFRefCount.cpp
@@ -194,10 +194,10 @@
     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 @@
                    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 @@
                              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 @@
   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 @@
       
     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/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp
index f8132f4..cd6b742 100644
--- a/lib/CodeGen/CGBuiltin.cpp
+++ b/lib/CodeGen/CGBuiltin.cpp
@@ -42,7 +42,7 @@
     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/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 05a8972..5856531 100644
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -650,13 +650,15 @@
         
   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 @@
 }
 
 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 @@
     // 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 @@
     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/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index 924a5cf..748ddde 100644
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -206,7 +206,8 @@
 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/lib/CodeGen/CGExprComplex.cpp b/lib/CodeGen/CGExprComplex.cpp
index 8a8e798..6bf0d48 100644
--- a/lib/CodeGen/CGExprComplex.cpp
+++ b/lib/CodeGen/CGExprComplex.cpp
@@ -246,8 +246,8 @@
 }
 
 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/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index ea92828..47bbd88 100644
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -1095,7 +1095,7 @@
 
 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/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index 313d2d1..6712d2f 100644
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/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 @@
   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 @@
   //===--------------------------------------------------------------------===//
 
   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);