Expr.cpp revision fa2192042f223b5122a9e17719930f77634fd31f 
1//===--- Expr.cpp - Expression AST Node Implementation --------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Expr class and subclasses.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/Expr.h"
15#include "clang/AST/APValue.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/AST/RecordLayout.h"
21#include "clang/AST/StmtVisitor.h"
22#include "clang/Basic/TargetInfo.h"
23using namespace clang;
24
25//===----------------------------------------------------------------------===//
26// Primary Expressions.
27//===----------------------------------------------------------------------===//
28
29IntegerLiteral* IntegerLiteral::Clone(ASTContext &C) const {
30  return new (C) IntegerLiteral(Value, getType(), Loc);
31}
32
33/// getValueAsApproximateDouble - This returns the value as an inaccurate
34/// double.  Note that this may cause loss of precision, but is useful for
35/// debugging dumps, etc.
36double FloatingLiteral::getValueAsApproximateDouble() const {
37  llvm::APFloat V = getValue();
38  bool ignored;
39  V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
40            &ignored);
41  return V.convertToDouble();
42}
43
44StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
45                                     unsigned ByteLength, bool Wide,
46                                     QualType Ty,
47                                     const SourceLocation *Loc,
48                                     unsigned NumStrs) {
49  // Allocate enough space for the StringLiteral plus an array of locations for
50  // any concatenated string tokens.
51  void *Mem = C.Allocate(sizeof(StringLiteral)+
52                         sizeof(SourceLocation)*(NumStrs-1),
53                         llvm::alignof<StringLiteral>());
54  StringLiteral *SL = new (Mem) StringLiteral(Ty);
55
56  // OPTIMIZE: could allocate this appended to the StringLiteral.
57  char *AStrData = new (C, 1) char[ByteLength];
58  memcpy(AStrData, StrData, ByteLength);
59  SL->StrData = AStrData;
60  SL->ByteLength = ByteLength;
61  SL->IsWide = Wide;
62  SL->TokLocs[0] = Loc[0];
63  SL->NumConcatenated = NumStrs;
64
65  if (NumStrs != 1)
66    memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
67  return SL;
68}
69
70StringLiteral* StringLiteral::Clone(ASTContext &C) const {
71  return Create(C, StrData, ByteLength, IsWide, getType(),
72                TokLocs, NumConcatenated);
73}
74
75void StringLiteral::Destroy(ASTContext &C) {
76  C.Deallocate(const_cast<char*>(StrData));
77  this->~StringLiteral();
78  C.Deallocate(this);
79}
80
81/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
82/// corresponds to, e.g. "sizeof" or "[pre]++".
83const char *UnaryOperator::getOpcodeStr(Opcode Op) {
84  switch (Op) {
85  default: assert(0 && "Unknown unary operator");
86  case PostInc: return "++";
87  case PostDec: return "--";
88  case PreInc:  return "++";
89  case PreDec:  return "--";
90  case AddrOf:  return "&";
91  case Deref:   return "*";
92  case Plus:    return "+";
93  case Minus:   return "-";
94  case Not:     return "~";
95  case LNot:    return "!";
96  case Real:    return "__real";
97  case Imag:    return "__imag";
98  case Extension: return "__extension__";
99  case OffsetOf: return "__builtin_offsetof";
100  }
101}
102
103UnaryOperator::Opcode
104UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
105  switch (OO) {
106  case OO_PlusPlus: return Postfix? PostInc : PreInc;
107  case OO_MinusMinus: return Postfix? PostDec : PreDec;
108  case OO_Amp: return AddrOf;
109  case OO_Star: return Deref;
110  case OO_Plus: return Plus;
111  case OO_Minus: return Minus;
112  case OO_Tilde: return Not;
113  case OO_Exclaim: return LNot;
114  default: assert(false && "No unary operator for overloaded function");
115  }
116}
117
118OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
119  switch (Opc) {
120  case PostInc: case PreInc: return OO_PlusPlus;
121  case PostDec: case PreDec: return OO_MinusMinus;
122  case AddrOf: return OO_Amp;
123  case Deref: return OO_Star;
124  case Plus: return OO_Plus;
125  case Minus: return OO_Minus;
126  case Not: return OO_Tilde;
127  case LNot: return OO_Exclaim;
128  default: return OO_None;
129  }
130}
131
132
133//===----------------------------------------------------------------------===//
134// Postfix Operators.
135//===----------------------------------------------------------------------===//
136
137CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args,
138                   unsigned numargs, QualType t, SourceLocation rparenloc)
139  : Expr(SC, t,
140         fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
141         fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
142    NumArgs(numargs) {
143
144  SubExprs = new (C) Stmt*[numargs+1];
145  SubExprs[FN] = fn;
146  for (unsigned i = 0; i != numargs; ++i)
147    SubExprs[i+ARGS_START] = args[i];
148
149  RParenLoc = rparenloc;
150}
151
152CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
153                   QualType t, SourceLocation rparenloc)
154  : Expr(CallExprClass, t,
155         fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
156         fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
157    NumArgs(numargs) {
158
159  SubExprs = new (C) Stmt*[numargs+1];
160  SubExprs[FN] = fn;
161  for (unsigned i = 0; i != numargs; ++i)
162    SubExprs[i+ARGS_START] = args[i];
163
164  RParenLoc = rparenloc;
165}
166
167void CallExpr::Destroy(ASTContext& C) {
168  DestroyChildren(C);
169  if (SubExprs) C.Deallocate(SubExprs);
170  this->~CallExpr();
171  C.Deallocate(this);
172}
173
174/// setNumArgs - This changes the number of arguments present in this call.
175/// Any orphaned expressions are deleted by this, and any new operands are set
176/// to null.
177void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
178  // No change, just return.
179  if (NumArgs == getNumArgs()) return;
180
181  // If shrinking # arguments, just delete the extras and forgot them.
182  if (NumArgs < getNumArgs()) {
183    for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i)
184      getArg(i)->Destroy(C);
185    this->NumArgs = NumArgs;
186    return;
187  }
188
189  // Otherwise, we are growing the # arguments.  New an bigger argument array.
190  Stmt **NewSubExprs = new Stmt*[NumArgs+1];
191  // Copy over args.
192  for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
193    NewSubExprs[i] = SubExprs[i];
194  // Null out new args.
195  for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
196    NewSubExprs[i] = 0;
197
198  delete [] SubExprs;
199  SubExprs = NewSubExprs;
200  this->NumArgs = NumArgs;
201}
202
203/// isBuiltinCall - If this is a call to a builtin, return the builtin ID.  If
204/// not, return 0.
205unsigned CallExpr::isBuiltinCall(ASTContext &Context) const {
206  // All simple function calls (e.g. func()) are implicitly cast to pointer to
207  // function. As a result, we try and obtain the DeclRefExpr from the
208  // ImplicitCastExpr.
209  const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
210  if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
211    return 0;
212
213  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
214  if (!DRE)
215    return 0;
216
217  const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
218  if (!FDecl)
219    return 0;
220
221  if (!FDecl->getIdentifier())
222    return 0;
223
224  return FDecl->getBuiltinID(Context);
225}
226
227
228/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
229/// corresponds to, e.g. "<<=".
230const char *BinaryOperator::getOpcodeStr(Opcode Op) {
231  switch (Op) {
232  case PtrMemD:   return ".*";
233  case PtrMemI:   return "->*";
234  case Mul:       return "*";
235  case Div:       return "/";
236  case Rem:       return "%";
237  case Add:       return "+";
238  case Sub:       return "-";
239  case Shl:       return "<<";
240  case Shr:       return ">>";
241  case LT:        return "<";
242  case GT:        return ">";
243  case LE:        return "<=";
244  case GE:        return ">=";
245  case EQ:        return "==";
246  case NE:        return "!=";
247  case And:       return "&";
248  case Xor:       return "^";
249  case Or:        return "|";
250  case LAnd:      return "&&";
251  case LOr:       return "||";
252  case Assign:    return "=";
253  case MulAssign: return "*=";
254  case DivAssign: return "/=";
255  case RemAssign: return "%=";
256  case AddAssign: return "+=";
257  case SubAssign: return "-=";
258  case ShlAssign: return "<<=";
259  case ShrAssign: return ">>=";
260  case AndAssign: return "&=";
261  case XorAssign: return "^=";
262  case OrAssign:  return "|=";
263  case Comma:     return ",";
264  }
265
266  return "";
267}
268
269BinaryOperator::Opcode
270BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
271  switch (OO) {
272  case OO_Plus: return Add;
273  case OO_Minus: return Sub;
274  case OO_Star: return Mul;
275  case OO_Slash: return Div;
276  case OO_Percent: return Rem;
277  case OO_Caret: return Xor;
278  case OO_Amp: return And;
279  case OO_Pipe: return Or;
280  case OO_Equal: return Assign;
281  case OO_Less: return LT;
282  case OO_Greater: return GT;
283  case OO_PlusEqual: return AddAssign;
284  case OO_MinusEqual: return SubAssign;
285  case OO_StarEqual: return MulAssign;
286  case OO_SlashEqual: return DivAssign;
287  case OO_PercentEqual: return RemAssign;
288  case OO_CaretEqual: return XorAssign;
289  case OO_AmpEqual: return AndAssign;
290  case OO_PipeEqual: return OrAssign;
291  case OO_LessLess: return Shl;
292  case OO_GreaterGreater: return Shr;
293  case OO_LessLessEqual: return ShlAssign;
294  case OO_GreaterGreaterEqual: return ShrAssign;
295  case OO_EqualEqual: return EQ;
296  case OO_ExclaimEqual: return NE;
297  case OO_LessEqual: return LE;
298  case OO_GreaterEqual: return GE;
299  case OO_AmpAmp: return LAnd;
300  case OO_PipePipe: return LOr;
301  case OO_Comma: return Comma;
302  case OO_ArrowStar: return PtrMemI;
303  default: assert(false && "Not an overloadable binary operator");
304  }
305}
306
307OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
308  static const OverloadedOperatorKind OverOps[] = {
309    /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
310    OO_Star, OO_Slash, OO_Percent,
311    OO_Plus, OO_Minus,
312    OO_LessLess, OO_GreaterGreater,
313    OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
314    OO_EqualEqual, OO_ExclaimEqual,
315    OO_Amp,
316    OO_Caret,
317    OO_Pipe,
318    OO_AmpAmp,
319    OO_PipePipe,
320    OO_Equal, OO_StarEqual,
321    OO_SlashEqual, OO_PercentEqual,
322    OO_PlusEqual, OO_MinusEqual,
323    OO_LessLessEqual, OO_GreaterGreaterEqual,
324    OO_AmpEqual, OO_CaretEqual,
325    OO_PipeEqual,
326    OO_Comma
327  };
328  return OverOps[Opc];
329}
330
331InitListExpr::InitListExpr(SourceLocation lbraceloc,
332                           Expr **initExprs, unsigned numInits,
333                           SourceLocation rbraceloc)
334  : Expr(InitListExprClass, QualType()),
335    LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
336    UnionFieldInit(0), HadArrayRangeDesignator(false) {
337
338  InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits);
339}
340
341void InitListExpr::reserveInits(unsigned NumInits) {
342  if (NumInits > InitExprs.size())
343    InitExprs.reserve(NumInits);
344}
345
346void InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) {
347  for (unsigned Idx = NumInits, LastIdx = InitExprs.size();
348       Idx < LastIdx; ++Idx)
349    InitExprs[Idx]->Destroy(Context);
350  InitExprs.resize(NumInits, 0);
351}
352
353Expr *InitListExpr::updateInit(unsigned Init, Expr *expr) {
354  if (Init >= InitExprs.size()) {
355    InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0);
356    InitExprs.back() = expr;
357    return 0;
358  }
359
360  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
361  InitExprs[Init] = expr;
362  return Result;
363}
364
365/// getFunctionType - Return the underlying function type for this block.
366///
367const FunctionType *BlockExpr::getFunctionType() const {
368  return getType()->getAsBlockPointerType()->
369                    getPointeeType()->getAsFunctionType();
370}
371
372SourceLocation BlockExpr::getCaretLocation() const {
373  return TheBlock->getCaretLocation();
374}
375const Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); }
376Stmt *BlockExpr::getBody() { return TheBlock->getBody(); }
377
378
379//===----------------------------------------------------------------------===//
380// Generic Expression Routines
381//===----------------------------------------------------------------------===//
382
383/// isUnusedResultAWarning - Return true if this immediate expression should
384/// be warned about if the result is unused.  If so, fill in Loc and Ranges
385/// with location to warn on and the source range[s] to report with the
386/// warning.
387bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
388                                  SourceRange &R2) const {
389  switch (getStmtClass()) {
390  default:
391    Loc = getExprLoc();
392    R1 = getSourceRange();
393    return true;
394  case ParenExprClass:
395    return cast<ParenExpr>(this)->getSubExpr()->
396      isUnusedResultAWarning(Loc, R1, R2);
397  case UnaryOperatorClass: {
398    const UnaryOperator *UO = cast<UnaryOperator>(this);
399
400    switch (UO->getOpcode()) {
401    default: break;
402    case UnaryOperator::PostInc:
403    case UnaryOperator::PostDec:
404    case UnaryOperator::PreInc:
405    case UnaryOperator::PreDec:                 // ++/--
406      return false;  // Not a warning.
407    case UnaryOperator::Deref:
408      // Dereferencing a volatile pointer is a side-effect.
409      if (getType().isVolatileQualified())
410        return false;
411      break;
412    case UnaryOperator::Real:
413    case UnaryOperator::Imag:
414      // accessing a piece of a volatile complex is a side-effect.
415      if (UO->getSubExpr()->getType().isVolatileQualified())
416        return false;
417      break;
418    case UnaryOperator::Extension:
419      return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2);
420    }
421    Loc = UO->getOperatorLoc();
422    R1 = UO->getSubExpr()->getSourceRange();
423    return true;
424  }
425  case BinaryOperatorClass: {
426    const BinaryOperator *BO = cast<BinaryOperator>(this);
427    // Consider comma to have side effects if the LHS or RHS does.
428    if (BO->getOpcode() == BinaryOperator::Comma)
429      return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2) ||
430             BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2);
431
432    if (BO->isAssignmentOp())
433      return false;
434    Loc = BO->getOperatorLoc();
435    R1 = BO->getLHS()->getSourceRange();
436    R2 = BO->getRHS()->getSourceRange();
437    return true;
438  }
439  case CompoundAssignOperatorClass:
440    return false;
441
442  case ConditionalOperatorClass: {
443    // The condition must be evaluated, but if either the LHS or RHS is a
444    // warning, warn about them.
445    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
446    if (Exp->getLHS() && Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2))
447      return true;
448    return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2);
449  }
450
451  case MemberExprClass:
452    // If the base pointer or element is to a volatile pointer/field, accessing
453    // it is a side effect.
454    if (getType().isVolatileQualified())
455      return false;
456    Loc = cast<MemberExpr>(this)->getMemberLoc();
457    R1 = SourceRange(Loc, Loc);
458    R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
459    return true;
460
461  case ArraySubscriptExprClass:
462    // If the base pointer or element is to a volatile pointer/field, accessing
463    // it is a side effect.
464    if (getType().isVolatileQualified())
465      return false;
466    Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
467    R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
468    R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
469    return true;
470
471  case CallExprClass:
472  case CXXOperatorCallExprClass: {
473    // If this is a direct call, get the callee.
474    const CallExpr *CE = cast<CallExpr>(this);
475    const Expr *CalleeExpr = CE->getCallee()->IgnoreParenCasts();
476    if (const DeclRefExpr *CalleeDRE = dyn_cast<DeclRefExpr>(CalleeExpr)) {
477      // If the callee has attribute pure, const, or warn_unused_result, warn
478      // about it. void foo() { strlen("bar"); } should warn.
479      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeDRE->getDecl()))
480        if (FD->getAttr<WarnUnusedResultAttr>() ||
481            FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
482          Loc = CE->getCallee()->getLocStart();
483          R1 = CE->getCallee()->getSourceRange();
484
485          if (unsigned NumArgs = CE->getNumArgs())
486            R2 = SourceRange(CE->getArg(0)->getLocStart(),
487                             CE->getArg(NumArgs-1)->getLocEnd());
488          return true;
489        }
490    }
491    return false;
492  }
493  case ObjCMessageExprClass:
494    return false;
495  case StmtExprClass: {
496    // Statement exprs don't logically have side effects themselves, but are
497    // sometimes used in macros in ways that give them a type that is unused.
498    // For example ({ blah; foo(); }) will end up with a type if foo has a type.
499    // however, if the result of the stmt expr is dead, we don't want to emit a
500    // warning.
501    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
502    if (!CS->body_empty())
503      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
504        return E->isUnusedResultAWarning(Loc, R1, R2);
505
506    Loc = cast<StmtExpr>(this)->getLParenLoc();
507    R1 = getSourceRange();
508    return true;
509  }
510  case CStyleCastExprClass:
511    // If this is a cast to void, check the operand.  Otherwise, the result of
512    // the cast is unused.
513    if (getType()->isVoidType())
514      return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc,
515                                                                        R1, R2);
516    Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
517    R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
518    return true;
519  case CXXFunctionalCastExprClass:
520    // If this is a cast to void, check the operand.  Otherwise, the result of
521    // the cast is unused.
522    if (getType()->isVoidType())
523      return cast<CastExpr>(this)->getSubExpr()->isUnusedResultAWarning(Loc,
524                                                                        R1, R2);
525    Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
526    R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
527    return true;
528
529  case ImplicitCastExprClass:
530    // Check the operand, since implicit casts are inserted by Sema
531    return cast<ImplicitCastExpr>(this)
532      ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2);
533
534  case CXXDefaultArgExprClass:
535    return cast<CXXDefaultArgExpr>(this)
536      ->getExpr()->isUnusedResultAWarning(Loc, R1, R2);
537
538  case CXXNewExprClass:
539    // FIXME: In theory, there might be new expressions that don't have side
540    // effects (e.g. a placement new with an uninitialized POD).
541  case CXXDeleteExprClass:
542    return false;
543  }
544}
545
546/// DeclCanBeLvalue - Determine whether the given declaration can be
547/// an lvalue. This is a helper routine for isLvalue.
548static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) {
549  // C++ [temp.param]p6:
550  //   A non-type non-reference template-parameter is not an lvalue.
551  if (const NonTypeTemplateParmDecl *NTTParm
552        = dyn_cast<NonTypeTemplateParmDecl>(Decl))
553    return NTTParm->getType()->isReferenceType();
554
555  return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) ||
556    // C++ 3.10p2: An lvalue refers to an object or function.
557    (Ctx.getLangOptions().CPlusPlus &&
558     (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl)));
559}
560
561/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
562/// incomplete type other than void. Nonarray expressions that can be lvalues:
563///  - name, where name must be a variable
564///  - e[i]
565///  - (e), where e must be an lvalue
566///  - e.name, where e must be an lvalue
567///  - e->name
568///  - *e, the type of e cannot be a function type
569///  - string-constant
570///  - (__real__ e) and (__imag__ e) where e is an lvalue  [GNU extension]
571///  - reference type [C++ [expr]]
572///
573Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const {
574  // first, check the type (C99 6.3.2.1). Expressions with function
575  // type in C are not lvalues, but they can be lvalues in C++.
576  if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
577    return LV_NotObjectType;
578
579  // Allow qualified void which is an incomplete type other than void (yuck).
580  if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers())
581    return LV_IncompleteVoidType;
582
583  assert(!TR->isReferenceType() && "Expressions can't have reference type.");
584
585  // the type looks fine, now check the expression
586  switch (getStmtClass()) {
587  case StringLiteralClass:  // C99 6.5.1p4
588  case ObjCEncodeExprClass: // @encode behaves like its string in every way.
589    return LV_Valid;
590  case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
591    // For vectors, make sure base is an lvalue (i.e. not a function call).
592    if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
593      return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx);
594    return LV_Valid;
595  case DeclRefExprClass:
596  case QualifiedDeclRefExprClass: { // C99 6.5.1p2
597    const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
598    if (DeclCanBeLvalue(RefdDecl, Ctx))
599      return LV_Valid;
600    break;
601  }
602  case BlockDeclRefExprClass: {
603    const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
604    if (isa<VarDecl>(BDR->getDecl()))
605      return LV_Valid;
606    break;
607  }
608  case MemberExprClass: {
609    const MemberExpr *m = cast<MemberExpr>(this);
610    if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4:
611      NamedDecl *Member = m->getMemberDecl();
612      // C++ [expr.ref]p4:
613      //   If E2 is declared to have type "reference to T", then E1.E2
614      //   is an lvalue.
615      if (ValueDecl *Value = dyn_cast<ValueDecl>(Member))
616        if (Value->getType()->isReferenceType())
617          return LV_Valid;
618
619      //   -- If E2 is a static data member [...] then E1.E2 is an lvalue.
620      if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord())
621        return LV_Valid;
622
623      //   -- If E2 is a non-static data member [...]. If E1 is an
624      //      lvalue, then E1.E2 is an lvalue.
625      if (isa<FieldDecl>(Member))
626        return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx);
627
628      //   -- If it refers to a static member function [...], then
629      //      E1.E2 is an lvalue.
630      //   -- Otherwise, if E1.E2 refers to a non-static member
631      //      function [...], then E1.E2 is not an lvalue.
632      if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member))
633        return Method->isStatic()? LV_Valid : LV_MemberFunction;
634
635      //   -- If E2 is a member enumerator [...], the expression E1.E2
636      //      is not an lvalue.
637      if (isa<EnumConstantDecl>(Member))
638        return LV_InvalidExpression;
639
640        // Not an lvalue.
641      return LV_InvalidExpression;
642    }
643
644    // C99 6.5.2.3p4
645    return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx);
646  }
647  case UnaryOperatorClass:
648    if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref)
649      return LV_Valid; // C99 6.5.3p4
650
651    if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real ||
652        cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag ||
653        cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension)
654      return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx);  // GNU.
655
656    if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1
657        (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc ||
658         cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec))
659      return LV_Valid;
660    break;
661  case ImplicitCastExprClass:
662    return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid
663                                                       : LV_InvalidExpression;
664  case ParenExprClass: // C99 6.5.1p5
665    return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx);
666  case BinaryOperatorClass:
667  case CompoundAssignOperatorClass: {
668    const BinaryOperator *BinOp = cast<BinaryOperator>(this);
669
670    if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1
671        BinOp->getOpcode() == BinaryOperator::Comma)
672      return BinOp->getRHS()->isLvalue(Ctx);
673
674    // C++ [expr.mptr.oper]p6
675    if ((BinOp->getOpcode() == BinaryOperator::PtrMemD ||
676         BinOp->getOpcode() == BinaryOperator::PtrMemI) &&
677        !BinOp->getType()->isFunctionType())
678      return BinOp->getLHS()->isLvalue(Ctx);
679
680    if (!BinOp->isAssignmentOp())
681      return LV_InvalidExpression;
682
683    if (Ctx.getLangOptions().CPlusPlus)
684      // C++ [expr.ass]p1:
685      //   The result of an assignment operation [...] is an lvalue.
686      return LV_Valid;
687
688
689    // C99 6.5.16:
690    //   An assignment expression [...] is not an lvalue.
691    return LV_InvalidExpression;
692  }
693  case CallExprClass:
694  case CXXOperatorCallExprClass:
695  case CXXMemberCallExprClass: {
696    // C++0x [expr.call]p10
697    //   A function call is an lvalue if and only if the result type
698    //   is an lvalue reference.
699    QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType();
700    if (const PointerType *FnTypePtr = CalleeType->getAsPointerType())
701      CalleeType = FnTypePtr->getPointeeType();
702    if (const FunctionType *FnType = CalleeType->getAsFunctionType())
703      if (FnType->getResultType()->isLValueReferenceType())
704        return LV_Valid;
705
706    break;
707  }
708  case CompoundLiteralExprClass: // C99 6.5.2.5p5
709    return LV_Valid;
710  case ChooseExprClass:
711    // __builtin_choose_expr is an lvalue if the selected operand is.
712    return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx);
713  case ExtVectorElementExprClass:
714    if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements())
715      return LV_DuplicateVectorComponents;
716    return LV_Valid;
717  case ObjCIvarRefExprClass: // ObjC instance variables are lvalues.
718    return LV_Valid;
719  case ObjCPropertyRefExprClass: // FIXME: check if read-only property.
720    return LV_Valid;
721  case ObjCKVCRefExprClass: // FIXME: check if read-only property.
722    return LV_Valid;
723  case PredefinedExprClass:
724    return LV_Valid;
725  case VAArgExprClass:
726    return LV_NotObjectType;
727  case CXXDefaultArgExprClass:
728    return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx);
729  case CXXConditionDeclExprClass:
730    return LV_Valid;
731  case CStyleCastExprClass:
732  case CXXFunctionalCastExprClass:
733  case CXXStaticCastExprClass:
734  case CXXDynamicCastExprClass:
735  case CXXReinterpretCastExprClass:
736  case CXXConstCastExprClass:
737    // The result of an explicit cast is an lvalue if the type we are
738    // casting to is an lvalue reference type. See C++ [expr.cast]p1,
739    // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2,
740    // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1.
741    if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->
742          isLValueReferenceType())
743      return LV_Valid;
744    break;
745  case CXXTypeidExprClass:
746    // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ...
747    return LV_Valid;
748  default:
749    break;
750  }
751  return LV_InvalidExpression;
752}
753
754/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
755/// does not have an incomplete type, does not have a const-qualified type, and
756/// if it is a structure or union, does not have any member (including,
757/// recursively, any member or element of all contained aggregates or unions)
758/// with a const-qualified type.
759Expr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const {
760  isLvalueResult lvalResult = isLvalue(Ctx);
761
762  switch (lvalResult) {
763  case LV_Valid:
764    // C++ 3.10p11: Functions cannot be modified, but pointers to
765    // functions can be modifiable.
766    if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
767      return MLV_NotObjectType;
768    break;
769
770  case LV_NotObjectType: return MLV_NotObjectType;
771  case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
772  case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
773  case LV_InvalidExpression:
774    // If the top level is a C-style cast, and the subexpression is a valid
775    // lvalue, then this is probably a use of the old-school "cast as lvalue"
776    // GCC extension.  We don't support it, but we want to produce good
777    // diagnostics when it happens so that the user knows why.
778    if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(this))
779      if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid)
780        return MLV_LValueCast;
781    return MLV_InvalidExpression;
782  case LV_MemberFunction: return MLV_MemberFunction;
783  }
784
785  QualType CT = Ctx.getCanonicalType(getType());
786
787  if (CT.isConstQualified())
788    return MLV_ConstQualified;
789  if (CT->isArrayType())
790    return MLV_ArrayType;
791  if (CT->isIncompleteType())
792    return MLV_IncompleteType;
793
794  if (const RecordType *r = CT->getAsRecordType()) {
795    if (r->hasConstFields())
796      return MLV_ConstQualified;
797  }
798  // The following is illegal:
799  //   void takeclosure(void (^C)(void));
800  //   void func() { int x = 1; takeclosure(^{ x = 7 }); }
801  //
802  if (getStmtClass() == BlockDeclRefExprClass) {
803    const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
804    if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl()))
805      return MLV_NotBlockQualified;
806  }
807
808  // Assigning to an 'implicit' property?
809  else if (getStmtClass() == ObjCKVCRefExprClass) {
810    const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this);
811    if (KVCExpr->getSetterMethod() == 0)
812      return MLV_NoSetterProperty;
813  }
814  return MLV_Valid;
815}
816
817/// hasGlobalStorage - Return true if this expression has static storage
818/// duration.  This means that the address of this expression is a link-time
819/// constant.
820bool Expr::hasGlobalStorage() const {
821  switch (getStmtClass()) {
822  default:
823    return false;
824  case ParenExprClass:
825    return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage();
826  case ImplicitCastExprClass:
827    return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage();
828  case CompoundLiteralExprClass:
829    return cast<CompoundLiteralExpr>(this)->isFileScope();
830  case DeclRefExprClass:
831  case QualifiedDeclRefExprClass: {
832    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
833    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
834      return VD->hasGlobalStorage();
835    if (isa<FunctionDecl>(D))
836      return true;
837    return false;
838  }
839  case MemberExprClass: {
840    const MemberExpr *M = cast<MemberExpr>(this);
841    return !M->isArrow() && M->getBase()->hasGlobalStorage();
842  }
843  case ArraySubscriptExprClass:
844    return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage();
845  case PredefinedExprClass:
846    return true;
847  case CXXDefaultArgExprClass:
848    return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage();
849  }
850}
851
852/// isOBJCGCCandidate - Check if an expression is objc gc'able.
853///
854bool Expr::isOBJCGCCandidate() const {
855  switch (getStmtClass()) {
856  default:
857    return false;
858  case ObjCIvarRefExprClass:
859    return true;
860  case Expr::UnaryOperatorClass:
861    return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate();
862  case ParenExprClass:
863    return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate();
864  case ImplicitCastExprClass:
865    return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate();
866  case DeclRefExprClass:
867  case QualifiedDeclRefExprClass: {
868    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
869    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
870      return VD->hasGlobalStorage();
871    return false;
872  }
873  case MemberExprClass: {
874    const MemberExpr *M = cast<MemberExpr>(this);
875    return !M->isArrow() && M->getBase()->isOBJCGCCandidate();
876  }
877  case ArraySubscriptExprClass:
878    return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate();
879  }
880}
881Expr* Expr::IgnoreParens() {
882  Expr* E = this;
883  while (ParenExpr* P = dyn_cast<ParenExpr>(E))
884    E = P->getSubExpr();
885
886  return E;
887}
888
889/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
890/// or CastExprs or ImplicitCastExprs, returning their operand.
891Expr *Expr::IgnoreParenCasts() {
892  Expr *E = this;
893  while (true) {
894    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
895      E = P->getSubExpr();
896    else if (CastExpr *P = dyn_cast<CastExpr>(E))
897      E = P->getSubExpr();
898    else
899      return E;
900  }
901}
902
903/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
904/// value (including ptr->int casts of the same size).  Strip off any
905/// ParenExpr or CastExprs, returning their operand.
906Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
907  Expr *E = this;
908  while (true) {
909    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
910      E = P->getSubExpr();
911      continue;
912    }
913
914    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
915      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
916      // ptr<->int casts of the same width.  We also ignore all identify casts.
917      Expr *SE = P->getSubExpr();
918
919      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
920        E = SE;
921        continue;
922      }
923
924      if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) &&
925          (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) &&
926          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
927        E = SE;
928        continue;
929      }
930    }
931
932    return E;
933  }
934}
935
936
937/// hasAnyTypeDependentArguments - Determines if any of the expressions
938/// in Exprs is type-dependent.
939bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
940  for (unsigned I = 0; I < NumExprs; ++I)
941    if (Exprs[I]->isTypeDependent())
942      return true;
943
944  return false;
945}
946
947/// hasAnyValueDependentArguments - Determines if any of the expressions
948/// in Exprs is value-dependent.
949bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
950  for (unsigned I = 0; I < NumExprs; ++I)
951    if (Exprs[I]->isValueDependent())
952      return true;
953
954  return false;
955}
956
957bool Expr::isConstantInitializer(ASTContext &Ctx) const {
958  // This function is attempting whether an expression is an initializer
959  // which can be evaluated at compile-time.  isEvaluatable handles most
960  // of the cases, but it can't deal with some initializer-specific
961  // expressions, and it can't deal with aggregates; we deal with those here,
962  // and fall back to isEvaluatable for the other cases.
963
964  // FIXME: This function assumes the variable being assigned to
965  // isn't a reference type!
966
967  switch (getStmtClass()) {
968  default: break;
969  case StringLiteralClass:
970  case ObjCEncodeExprClass:
971    return true;
972  case CompoundLiteralExprClass: {
973    // This handles gcc's extension that allows global initializers like
974    // "struct x {int x;} x = (struct x) {};".
975    // FIXME: This accepts other cases it shouldn't!
976    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
977    return Exp->isConstantInitializer(Ctx);
978  }
979  case InitListExprClass: {
980    // FIXME: This doesn't deal with fields with reference types correctly.
981    // FIXME: This incorrectly allows pointers cast to integers to be assigned
982    // to bitfields.
983    const InitListExpr *Exp = cast<InitListExpr>(this);
984    unsigned numInits = Exp->getNumInits();
985    for (unsigned i = 0; i < numInits; i++) {
986      if (!Exp->getInit(i)->isConstantInitializer(Ctx))
987        return false;
988    }
989    return true;
990  }
991  case ImplicitValueInitExprClass:
992    return true;
993  case ParenExprClass: {
994    return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
995  }
996  case UnaryOperatorClass: {
997    const UnaryOperator* Exp = cast<UnaryOperator>(this);
998    if (Exp->getOpcode() == UnaryOperator::Extension)
999      return Exp->getSubExpr()->isConstantInitializer(Ctx);
1000    break;
1001  }
1002  case CStyleCastExprClass:
1003    // Handle casts with a destination that's a struct or union; this
1004    // deals with both the gcc no-op struct cast extension and the
1005    // cast-to-union extension.
1006    if (getType()->isRecordType())
1007      return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1008    break;
1009  }
1010
1011  return isEvaluatable(Ctx);
1012}
1013
1014/// isIntegerConstantExpr - this recursive routine will test if an expression is
1015/// an integer constant expression.
1016
1017/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
1018/// comma, etc
1019///
1020/// FIXME: Handle offsetof.  Two things to do:  Handle GCC's __builtin_offsetof
1021/// to support gcc 4.0+  and handle the idiom GCC recognizes with a null pointer
1022/// cast+dereference.
1023
1024// CheckICE - This function does the fundamental ICE checking: the returned
1025// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation.
1026// Note that to reduce code duplication, this helper does no evaluation
1027// itself; the caller checks whether the expression is evaluatable, and
1028// in the rare cases where CheckICE actually cares about the evaluated
1029// value, it calls into Evalute.
1030//
1031// Meanings of Val:
1032// 0: This expression is an ICE if it can be evaluated by Evaluate.
1033// 1: This expression is not an ICE, but if it isn't evaluated, it's
1034//    a legal subexpression for an ICE. This return value is used to handle
1035//    the comma operator in C99 mode.
1036// 2: This expression is not an ICE, and is not a legal subexpression for one.
1037
1038struct ICEDiag {
1039  unsigned Val;
1040  SourceLocation Loc;
1041
1042  public:
1043  ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {}
1044  ICEDiag() : Val(0) {}
1045};
1046
1047ICEDiag NoDiag() { return ICEDiag(); }
1048
1049static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) {
1050  Expr::EvalResult EVResult;
1051  if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1052      !EVResult.Val.isInt()) {
1053    return ICEDiag(2, E->getLocStart());
1054  }
1055  return NoDiag();
1056}
1057
1058static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
1059  assert(!E->isValueDependent() && "Should not see value dependent exprs!");
1060  if (!E->getType()->isIntegralType()) {
1061    return ICEDiag(2, E->getLocStart());
1062  }
1063
1064  switch (E->getStmtClass()) {
1065  default:
1066    return ICEDiag(2, E->getLocStart());
1067  case Expr::ParenExprClass:
1068    return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
1069  case Expr::IntegerLiteralClass:
1070  case Expr::CharacterLiteralClass:
1071  case Expr::CXXBoolLiteralExprClass:
1072  case Expr::CXXZeroInitValueExprClass:
1073  case Expr::TypesCompatibleExprClass:
1074  case Expr::UnaryTypeTraitExprClass:
1075    return NoDiag();
1076  case Expr::CallExprClass:
1077  case Expr::CXXOperatorCallExprClass: {
1078    const CallExpr *CE = cast<CallExpr>(E);
1079    if (CE->isBuiltinCall(Ctx))
1080      return CheckEvalInICE(E, Ctx);
1081    return ICEDiag(2, E->getLocStart());
1082  }
1083  case Expr::DeclRefExprClass:
1084  case Expr::QualifiedDeclRefExprClass:
1085    if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
1086      return NoDiag();
1087    if (Ctx.getLangOptions().CPlusPlus &&
1088        E->getType().getCVRQualifiers() == QualType::Const) {
1089      // C++ 7.1.5.1p2
1090      //   A variable of non-volatile const-qualified integral or enumeration
1091      //   type initialized by an ICE can be used in ICEs.
1092      if (const VarDecl *Dcl =
1093              dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
1094        if (const Expr *Init = Dcl->getInit())
1095          return CheckICE(Init, Ctx);
1096      }
1097    }
1098    return ICEDiag(2, E->getLocStart());
1099  case Expr::UnaryOperatorClass: {
1100    const UnaryOperator *Exp = cast<UnaryOperator>(E);
1101    switch (Exp->getOpcode()) {
1102    default:
1103      return ICEDiag(2, E->getLocStart());
1104    case UnaryOperator::Extension:
1105    case UnaryOperator::LNot:
1106    case UnaryOperator::Plus:
1107    case UnaryOperator::Minus:
1108    case UnaryOperator::Not:
1109    case UnaryOperator::Real:
1110    case UnaryOperator::Imag:
1111      return CheckICE(Exp->getSubExpr(), Ctx);
1112    case UnaryOperator::OffsetOf:
1113      // Note that per C99, offsetof must be an ICE. And AFAIK, using
1114      // Evaluate matches the proposed gcc behavior for cases like
1115      // "offsetof(struct s{int x[4];}, x[!.0])".  This doesn't affect
1116      // compliance: we should warn earlier for offsetof expressions with
1117      // array subscripts that aren't ICEs, and if the array subscripts
1118      // are ICEs, the value of the offsetof must be an integer constant.
1119      return CheckEvalInICE(E, Ctx);
1120    }
1121  }
1122  case Expr::SizeOfAlignOfExprClass: {
1123    const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E);
1124    if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType())
1125      return ICEDiag(2, E->getLocStart());
1126    return NoDiag();
1127  }
1128  case Expr::BinaryOperatorClass: {
1129    const BinaryOperator *Exp = cast<BinaryOperator>(E);
1130    switch (Exp->getOpcode()) {
1131    default:
1132      return ICEDiag(2, E->getLocStart());
1133    case BinaryOperator::Mul:
1134    case BinaryOperator::Div:
1135    case BinaryOperator::Rem:
1136    case BinaryOperator::Add:
1137    case BinaryOperator::Sub:
1138    case BinaryOperator::Shl:
1139    case BinaryOperator::Shr:
1140    case BinaryOperator::LT:
1141    case BinaryOperator::GT:
1142    case BinaryOperator::LE:
1143    case BinaryOperator::GE:
1144    case BinaryOperator::EQ:
1145    case BinaryOperator::NE:
1146    case BinaryOperator::And:
1147    case BinaryOperator::Xor:
1148    case BinaryOperator::Or:
1149    case BinaryOperator::Comma: {
1150      ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1151      ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1152      if (Exp->getOpcode() == BinaryOperator::Div ||
1153          Exp->getOpcode() == BinaryOperator::Rem) {
1154        // Evaluate gives an error for undefined Div/Rem, so make sure
1155        // we don't evaluate one.
1156        if (LHSResult.Val != 2 && RHSResult.Val != 2) {
1157          llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx);
1158          if (REval == 0)
1159            return ICEDiag(1, E->getLocStart());
1160          if (REval.isSigned() && REval.isAllOnesValue()) {
1161            llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx);
1162            if (LEval.isMinSignedValue())
1163              return ICEDiag(1, E->getLocStart());
1164          }
1165        }
1166      }
1167      if (Exp->getOpcode() == BinaryOperator::Comma) {
1168        if (Ctx.getLangOptions().C99) {
1169          // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
1170          // if it isn't evaluated.
1171          if (LHSResult.Val == 0 && RHSResult.Val == 0)
1172            return ICEDiag(1, E->getLocStart());
1173        } else {
1174          // In both C89 and C++, commas in ICEs are illegal.
1175          return ICEDiag(2, E->getLocStart());
1176        }
1177      }
1178      if (LHSResult.Val >= RHSResult.Val)
1179        return LHSResult;
1180      return RHSResult;
1181    }
1182    case BinaryOperator::LAnd:
1183    case BinaryOperator::LOr: {
1184      ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1185      ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1186      if (LHSResult.Val == 0 && RHSResult.Val == 1) {
1187        // Rare case where the RHS has a comma "side-effect"; we need
1188        // to actually check the condition to see whether the side
1189        // with the comma is evaluated.
1190        if ((Exp->getOpcode() == BinaryOperator::LAnd) !=
1191            (Exp->getLHS()->EvaluateAsInt(Ctx) == 0))
1192          return RHSResult;
1193        return NoDiag();
1194      }
1195
1196      if (LHSResult.Val >= RHSResult.Val)
1197        return LHSResult;
1198      return RHSResult;
1199    }
1200    }
1201  }
1202  case Expr::ImplicitCastExprClass:
1203  case Expr::CStyleCastExprClass:
1204  case Expr::CXXFunctionalCastExprClass: {
1205    const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
1206    if (SubExpr->getType()->isIntegralType())
1207      return CheckICE(SubExpr, Ctx);
1208    if (isa<FloatingLiteral>(SubExpr->IgnoreParens()))
1209      return NoDiag();
1210    return ICEDiag(2, E->getLocStart());
1211  }
1212  case Expr::ConditionalOperatorClass: {
1213    const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
1214    // If the condition (ignoring parens) is a __builtin_constant_p call,
1215    // then only the true side is actually considered in an integer constant
1216    // expression, and it is fully evaluated.  This is an important GNU
1217    // extension.  See GCC PR38377 for discussion.
1218    if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
1219      if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) {
1220        Expr::EvalResult EVResult;
1221        if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1222            !EVResult.Val.isInt()) {
1223          return ICEDiag(2, E->getLocStart());
1224        }
1225        return NoDiag();
1226      }
1227    ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
1228    ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
1229    ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
1230    if (CondResult.Val == 2)
1231      return CondResult;
1232    if (TrueResult.Val == 2)
1233      return TrueResult;
1234    if (FalseResult.Val == 2)
1235      return FalseResult;
1236    if (CondResult.Val == 1)
1237      return CondResult;
1238    if (TrueResult.Val == 0 && FalseResult.Val == 0)
1239      return NoDiag();
1240    // Rare case where the diagnostics depend on which side is evaluated
1241    // Note that if we get here, CondResult is 0, and at least one of
1242    // TrueResult and FalseResult is non-zero.
1243    if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) {
1244      return FalseResult;
1245    }
1246    return TrueResult;
1247  }
1248  case Expr::CXXDefaultArgExprClass:
1249    return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
1250  case Expr::ChooseExprClass: {
1251    return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx);
1252  }
1253  }
1254}
1255
1256bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
1257                                 SourceLocation *Loc, bool isEvaluated) const {
1258  ICEDiag d = CheckICE(this, Ctx);
1259  if (d.Val != 0) {
1260    if (Loc) *Loc = d.Loc;
1261    return false;
1262  }
1263  EvalResult EvalResult;
1264  if (!Evaluate(EvalResult, Ctx))
1265    assert(0 && "ICE cannot be evaluated!");
1266  assert(!EvalResult.HasSideEffects && "ICE with side effects!");
1267  assert(EvalResult.Val.isInt() && "ICE that isn't integer!");
1268  Result = EvalResult.Val.getInt();
1269  return true;
1270}
1271
1272/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1273/// integer constant expression with the value zero, or if this is one that is
1274/// cast to void*.
1275bool Expr::isNullPointerConstant(ASTContext &Ctx) const
1276{
1277  // Strip off a cast to void*, if it exists. Except in C++.
1278  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1279    if (!Ctx.getLangOptions().CPlusPlus) {
1280      // Check that it is a cast to void*.
1281      if (const PointerType *PT = CE->getType()->getAsPointerType()) {
1282        QualType Pointee = PT->getPointeeType();
1283        if (Pointee.getCVRQualifiers() == 0 &&
1284            Pointee->isVoidType() &&                              // to void*
1285            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1286          return CE->getSubExpr()->isNullPointerConstant(Ctx);
1287      }
1288    }
1289  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1290    // Ignore the ImplicitCastExpr type entirely.
1291    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
1292  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1293    // Accept ((void*)0) as a null pointer constant, as many other
1294    // implementations do.
1295    return PE->getSubExpr()->isNullPointerConstant(Ctx);
1296  } else if (const CXXDefaultArgExpr *DefaultArg
1297               = dyn_cast<CXXDefaultArgExpr>(this)) {
1298    // See through default argument expressions
1299    return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
1300  } else if (isa<GNUNullExpr>(this)) {
1301    // The GNU __null extension is always a null pointer constant.
1302    return true;
1303  }
1304
1305  // This expression must be an integer type.
1306  if (!getType()->isIntegerType())
1307    return false;
1308
1309  // If we have an integer constant expression, we need to *evaluate* it and
1310  // test for the value 0.
1311  // FIXME: We should probably return false if we're compiling in strict mode
1312  // and Diag is not null (this indicates that the value was foldable but not
1313  // an ICE.
1314  EvalResult Result;
1315  return Evaluate(Result, Ctx) && !Result.HasSideEffects &&
1316        Result.Val.isInt() && Result.Val.getInt() == 0;
1317}
1318
1319/// isBitField - Return true if this expression is a bit-field.
1320bool Expr::isBitField() {
1321  Expr *E = this->IgnoreParenCasts();
1322  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1323    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1324        return Field->isBitField();
1325  return false;
1326}
1327
1328/// isArrow - Return true if the base expression is a pointer to vector,
1329/// return false if the base expression is a vector.
1330bool ExtVectorElementExpr::isArrow() const {
1331  return getBase()->getType()->isPointerType();
1332}
1333
1334unsigned ExtVectorElementExpr::getNumElements() const {
1335  if (const VectorType *VT = getType()->getAsVectorType())
1336    return VT->getNumElements();
1337  return 1;
1338}
1339
1340/// containsDuplicateElements - Return true if any element access is repeated.
1341bool ExtVectorElementExpr::containsDuplicateElements() const {
1342  const char *compStr = Accessor.getName();
1343  unsigned length = Accessor.getLength();
1344
1345  // Halving swizzles do not contain duplicate elements.
1346  if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1347      !strcmp(compStr, "even") || !strcmp(compStr, "odd"))
1348    return false;
1349
1350  // Advance past s-char prefix on hex swizzles.
1351  if (*compStr == 's') {
1352    compStr++;
1353    length--;
1354  }
1355
1356  for (unsigned i = 0; i != length-1; i++) {
1357    const char *s = compStr+i;
1358    for (const char c = *s++; *s; s++)
1359      if (c == *s)
1360        return true;
1361  }
1362  return false;
1363}
1364
1365/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1366void ExtVectorElementExpr::getEncodedElementAccess(
1367                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1368  const char *compStr = Accessor.getName();
1369  if (*compStr == 's')
1370    compStr++;
1371
1372  bool isHi =   !strcmp(compStr, "hi");
1373  bool isLo =   !strcmp(compStr, "lo");
1374  bool isEven = !strcmp(compStr, "even");
1375  bool isOdd  = !strcmp(compStr, "odd");
1376
1377  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1378    uint64_t Index;
1379
1380    if (isHi)
1381      Index = e + i;
1382    else if (isLo)
1383      Index = i;
1384    else if (isEven)
1385      Index = 2 * i;
1386    else if (isOdd)
1387      Index = 2 * i + 1;
1388    else
1389      Index = ExtVectorType::getAccessorIdx(compStr[i]);
1390
1391    Elts.push_back(Index);
1392  }
1393}
1394
1395// constructor for instance messages.
1396ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
1397                QualType retType, ObjCMethodDecl *mproto,
1398                SourceLocation LBrac, SourceLocation RBrac,
1399                Expr **ArgExprs, unsigned nargs)
1400  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1401    MethodProto(mproto) {
1402  NumArgs = nargs;
1403  SubExprs = new Stmt*[NumArgs+1];
1404  SubExprs[RECEIVER] = receiver;
1405  if (NumArgs) {
1406    for (unsigned i = 0; i != NumArgs; ++i)
1407      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1408  }
1409  LBracloc = LBrac;
1410  RBracloc = RBrac;
1411}
1412
1413// constructor for class messages.
1414// FIXME: clsName should be typed to ObjCInterfaceType
1415ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
1416                QualType retType, ObjCMethodDecl *mproto,
1417                SourceLocation LBrac, SourceLocation RBrac,
1418                Expr **ArgExprs, unsigned nargs)
1419  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1420    MethodProto(mproto) {
1421  NumArgs = nargs;
1422  SubExprs = new Stmt*[NumArgs+1];
1423  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
1424  if (NumArgs) {
1425    for (unsigned i = 0; i != NumArgs; ++i)
1426      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1427  }
1428  LBracloc = LBrac;
1429  RBracloc = RBrac;
1430}
1431
1432// constructor for class messages.
1433ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1434                                 QualType retType, ObjCMethodDecl *mproto,
1435                                 SourceLocation LBrac, SourceLocation RBrac,
1436                                 Expr **ArgExprs, unsigned nargs)
1437: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1438MethodProto(mproto) {
1439  NumArgs = nargs;
1440  SubExprs = new Stmt*[NumArgs+1];
1441  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1442  if (NumArgs) {
1443    for (unsigned i = 0; i != NumArgs; ++i)
1444      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1445  }
1446  LBracloc = LBrac;
1447  RBracloc = RBrac;
1448}
1449
1450ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1451  uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1452  switch (x & Flags) {
1453    default:
1454      assert(false && "Invalid ObjCMessageExpr.");
1455    case IsInstMeth:
1456      return ClassInfo(0, 0);
1457    case IsClsMethDeclUnknown:
1458      return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1459    case IsClsMethDeclKnown: {
1460      ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1461      return ClassInfo(D, D->getIdentifier());
1462    }
1463  }
1464}
1465
1466bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1467  return getCond()->getIntegerConstantExprValue(C) != 0;
1468}
1469
1470void SizeOfAlignOfExpr::Destroy(ASTContext& C) {
1471  // Override default behavior of traversing children. If this has a type
1472  // operand and the type is a variable-length array, the child iteration
1473  // will iterate over the size expression. However, this expression belongs
1474  // to the type, not to this, so we don't want to delete it.
1475  // We still want to delete this expression.
1476  if (isArgumentType()) {
1477    this->~SizeOfAlignOfExpr();
1478    C.Deallocate(this);
1479  }
1480  else
1481    Expr::Destroy(C);
1482}
1483
1484//===----------------------------------------------------------------------===//
1485//  DesignatedInitExpr
1486//===----------------------------------------------------------------------===//
1487
1488IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
1489  assert(Kind == FieldDesignator && "Only valid on a field designator");
1490  if (Field.NameOrField & 0x01)
1491    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
1492  else
1493    return getField()->getIdentifier();
1494}
1495
1496DesignatedInitExpr *
1497DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
1498                           unsigned NumDesignators,
1499                           Expr **IndexExprs, unsigned NumIndexExprs,
1500                           SourceLocation ColonOrEqualLoc,
1501                           bool UsesColonSyntax, Expr *Init) {
1502  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1503                         sizeof(Designator) * NumDesignators +
1504                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1505  DesignatedInitExpr *DIE
1506    = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators,
1507                                   ColonOrEqualLoc, UsesColonSyntax,
1508                                   NumIndexExprs + 1);
1509
1510  // Fill in the designators
1511  unsigned ExpectedNumSubExprs = 0;
1512  designators_iterator Desig = DIE->designators_begin();
1513  for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) {
1514    new (static_cast<void*>(Desig)) Designator(Designators[Idx]);
1515    if (Designators[Idx].isArrayDesignator())
1516      ++ExpectedNumSubExprs;
1517    else if (Designators[Idx].isArrayRangeDesignator())
1518      ExpectedNumSubExprs += 2;
1519  }
1520  assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!");
1521
1522  // Fill in the subexpressions, including the initializer expression.
1523  child_iterator Child = DIE->child_begin();
1524  *Child++ = Init;
1525  for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child)
1526    *Child = IndexExprs[Idx];
1527
1528  return DIE;
1529}
1530
1531SourceRange DesignatedInitExpr::getSourceRange() const {
1532  SourceLocation StartLoc;
1533  Designator &First =
1534    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
1535  if (First.isFieldDesignator()) {
1536    if (UsesColonSyntax)
1537      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
1538    else
1539      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
1540  } else
1541    StartLoc =
1542      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
1543  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
1544}
1545
1546DesignatedInitExpr::designators_iterator
1547DesignatedInitExpr::designators_begin() {
1548  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1549  Ptr += sizeof(DesignatedInitExpr);
1550  return static_cast<Designator*>(static_cast<void*>(Ptr));
1551}
1552
1553DesignatedInitExpr::designators_iterator DesignatedInitExpr::designators_end() {
1554  return designators_begin() + NumDesignators;
1555}
1556
1557Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
1558  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
1559  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1560  Ptr += sizeof(DesignatedInitExpr);
1561  Ptr += sizeof(Designator) * NumDesignators;
1562  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1563  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1564}
1565
1566Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
1567  assert(D.Kind == Designator::ArrayRangeDesignator &&
1568         "Requires array range designator");
1569  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1570  Ptr += sizeof(DesignatedInitExpr);
1571  Ptr += sizeof(Designator) * NumDesignators;
1572  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1573  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1574}
1575
1576Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
1577  assert(D.Kind == Designator::ArrayRangeDesignator &&
1578         "Requires array range designator");
1579  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1580  Ptr += sizeof(DesignatedInitExpr);
1581  Ptr += sizeof(Designator) * NumDesignators;
1582  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1583  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
1584}
1585
1586//===----------------------------------------------------------------------===//
1587//  ExprIterator.
1588//===----------------------------------------------------------------------===//
1589
1590Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
1591Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
1592Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
1593const Expr* ConstExprIterator::operator[](size_t idx) const {
1594  return cast<Expr>(I[idx]);
1595}
1596const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
1597const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
1598
1599//===----------------------------------------------------------------------===//
1600//  Child Iterators for iterating over subexpressions/substatements
1601//===----------------------------------------------------------------------===//
1602
1603// DeclRefExpr
1604Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1605Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
1606
1607// ObjCIvarRefExpr
1608Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1609Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
1610
1611// ObjCPropertyRefExpr
1612Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1613Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
1614
1615// ObjCKVCRefExpr
1616Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; }
1617Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; }
1618
1619// ObjCSuperExpr
1620Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
1621Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
1622
1623// PredefinedExpr
1624Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
1625Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
1626
1627// IntegerLiteral
1628Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1629Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
1630
1631// CharacterLiteral
1632Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
1633Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
1634
1635// FloatingLiteral
1636Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1637Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
1638
1639// ImaginaryLiteral
1640Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1641Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
1642
1643// StringLiteral
1644Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1645Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
1646
1647// ParenExpr
1648Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1649Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
1650
1651// UnaryOperator
1652Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1653Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
1654
1655// SizeOfAlignOfExpr
1656Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
1657  // If this is of a type and the type is a VLA type (and not a typedef), the
1658  // size expression of the VLA needs to be treated as an executable expression.
1659  // Why isn't this weirdness documented better in StmtIterator?
1660  if (isArgumentType()) {
1661    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
1662                                   getArgumentType().getTypePtr()))
1663      return child_iterator(T);
1664    return child_iterator();
1665  }
1666  return child_iterator(&Argument.Ex);
1667}
1668Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
1669  if (isArgumentType())
1670    return child_iterator();
1671  return child_iterator(&Argument.Ex + 1);
1672}
1673
1674// ArraySubscriptExpr
1675Stmt::child_iterator ArraySubscriptExpr::child_begin() {
1676  return &SubExprs[0];
1677}
1678Stmt::child_iterator ArraySubscriptExpr::child_end() {
1679  return &SubExprs[0]+END_EXPR;
1680}
1681
1682// CallExpr
1683Stmt::child_iterator CallExpr::child_begin() {
1684  return &SubExprs[0];
1685}
1686Stmt::child_iterator CallExpr::child_end() {
1687  return &SubExprs[0]+NumArgs+ARGS_START;
1688}
1689
1690// MemberExpr
1691Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1692Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
1693
1694// ExtVectorElementExpr
1695Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1696Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
1697
1698// CompoundLiteralExpr
1699Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1700Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
1701
1702// CastExpr
1703Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1704Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
1705
1706// BinaryOperator
1707Stmt::child_iterator BinaryOperator::child_begin() {
1708  return &SubExprs[0];
1709}
1710Stmt::child_iterator BinaryOperator::child_end() {
1711  return &SubExprs[0]+END_EXPR;
1712}
1713
1714// ConditionalOperator
1715Stmt::child_iterator ConditionalOperator::child_begin() {
1716  return &SubExprs[0];
1717}
1718Stmt::child_iterator ConditionalOperator::child_end() {
1719  return &SubExprs[0]+END_EXPR;
1720}
1721
1722// AddrLabelExpr
1723Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1724Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
1725
1726// StmtExpr
1727Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1728Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
1729
1730// TypesCompatibleExpr
1731Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1732  return child_iterator();
1733}
1734
1735Stmt::child_iterator TypesCompatibleExpr::child_end() {
1736  return child_iterator();
1737}
1738
1739// ChooseExpr
1740Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1741Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
1742
1743// GNUNullExpr
1744Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
1745Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
1746
1747// ShuffleVectorExpr
1748Stmt::child_iterator ShuffleVectorExpr::child_begin() {
1749  return &SubExprs[0];
1750}
1751Stmt::child_iterator ShuffleVectorExpr::child_end() {
1752  return &SubExprs[0]+NumExprs;
1753}
1754
1755// VAArgExpr
1756Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1757Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
1758
1759// InitListExpr
1760Stmt::child_iterator InitListExpr::child_begin() {
1761  return InitExprs.size() ? &InitExprs[0] : 0;
1762}
1763Stmt::child_iterator InitListExpr::child_end() {
1764  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
1765}
1766
1767// DesignatedInitExpr
1768Stmt::child_iterator DesignatedInitExpr::child_begin() {
1769  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1770  Ptr += sizeof(DesignatedInitExpr);
1771  Ptr += sizeof(Designator) * NumDesignators;
1772  return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1773}
1774Stmt::child_iterator DesignatedInitExpr::child_end() {
1775  return child_iterator(&*child_begin() + NumSubExprs);
1776}
1777
1778// ImplicitValueInitExpr
1779Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
1780  return child_iterator();
1781}
1782
1783Stmt::child_iterator ImplicitValueInitExpr::child_end() {
1784  return child_iterator();
1785}
1786
1787// ObjCStringLiteral
1788Stmt::child_iterator ObjCStringLiteral::child_begin() {
1789  return &String;
1790}
1791Stmt::child_iterator ObjCStringLiteral::child_end() {
1792  return &String+1;
1793}
1794
1795// ObjCEncodeExpr
1796Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
1797Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
1798
1799// ObjCSelectorExpr
1800Stmt::child_iterator ObjCSelectorExpr::child_begin() {
1801  return child_iterator();
1802}
1803Stmt::child_iterator ObjCSelectorExpr::child_end() {
1804  return child_iterator();
1805}
1806
1807// ObjCProtocolExpr
1808Stmt::child_iterator ObjCProtocolExpr::child_begin() {
1809  return child_iterator();
1810}
1811Stmt::child_iterator ObjCProtocolExpr::child_end() {
1812  return child_iterator();
1813}
1814
1815// ObjCMessageExpr
1816Stmt::child_iterator ObjCMessageExpr::child_begin() {
1817  return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
1818}
1819Stmt::child_iterator ObjCMessageExpr::child_end() {
1820  return &SubExprs[0]+ARGS_START+getNumArgs();
1821}
1822
1823// Blocks
1824Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
1825Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
1826
1827Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
1828Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
1829