Expr.cpp revision 44e35f7b2b5da1eb338639e46bf0b5522e75c5f3 
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  default: assert(false && "No unary operator for overloaded function");
107  case OO_PlusPlus:   return Postfix ? PostInc : PreInc;
108  case OO_MinusMinus: return Postfix ? PostDec : PreDec;
109  case OO_Amp:        return AddrOf;
110  case OO_Star:       return Deref;
111  case OO_Plus:       return Plus;
112  case OO_Minus:      return Minus;
113  case OO_Tilde:      return Not;
114  case OO_Exclaim:    return LNot;
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  default: assert(false && "Not an overloadable binary operator");
273  case OO_Plus: return Add;
274  case OO_Minus: return Sub;
275  case OO_Star: return Mul;
276  case OO_Slash: return Div;
277  case OO_Percent: return Rem;
278  case OO_Caret: return Xor;
279  case OO_Amp: return And;
280  case OO_Pipe: return Or;
281  case OO_Equal: return Assign;
282  case OO_Less: return LT;
283  case OO_Greater: return GT;
284  case OO_PlusEqual: return AddAssign;
285  case OO_MinusEqual: return SubAssign;
286  case OO_StarEqual: return MulAssign;
287  case OO_SlashEqual: return DivAssign;
288  case OO_PercentEqual: return RemAssign;
289  case OO_CaretEqual: return XorAssign;
290  case OO_AmpEqual: return AndAssign;
291  case OO_PipeEqual: return OrAssign;
292  case OO_LessLess: return Shl;
293  case OO_GreaterGreater: return Shr;
294  case OO_LessLessEqual: return ShlAssign;
295  case OO_GreaterGreaterEqual: return ShrAssign;
296  case OO_EqualEqual: return EQ;
297  case OO_ExclaimEqual: return NE;
298  case OO_LessEqual: return LE;
299  case OO_GreaterEqual: return GE;
300  case OO_AmpAmp: return LAnd;
301  case OO_PipePipe: return LOr;
302  case OO_Comma: return Comma;
303  case OO_ArrowStar: return PtrMemI;
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
760Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const {
761  isLvalueResult lvalResult = isLvalue(Ctx);
762
763  switch (lvalResult) {
764  case LV_Valid:
765    // C++ 3.10p11: Functions cannot be modified, but pointers to
766    // functions can be modifiable.
767    if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
768      return MLV_NotObjectType;
769    break;
770
771  case LV_NotObjectType: return MLV_NotObjectType;
772  case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
773  case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
774  case LV_InvalidExpression:
775    // If the top level is a C-style cast, and the subexpression is a valid
776    // lvalue, then this is probably a use of the old-school "cast as lvalue"
777    // GCC extension.  We don't support it, but we want to produce good
778    // diagnostics when it happens so that the user knows why.
779    if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) {
780      if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) {
781        if (Loc)
782          *Loc = CE->getLParenLoc();
783        return MLV_LValueCast;
784      }
785    }
786    return MLV_InvalidExpression;
787  case LV_MemberFunction: return MLV_MemberFunction;
788  }
789
790  // The following is illegal:
791  //   void takeclosure(void (^C)(void));
792  //   void func() { int x = 1; takeclosure(^{ x = 7; }); }
793  //
794  if (isa<BlockDeclRefExpr>(this)) {
795    const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
796    if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl()))
797      return MLV_NotBlockQualified;
798  }
799
800  QualType CT = Ctx.getCanonicalType(getType());
801
802  if (CT.isConstQualified())
803    return MLV_ConstQualified;
804  if (CT->isArrayType())
805    return MLV_ArrayType;
806  if (CT->isIncompleteType())
807    return MLV_IncompleteType;
808
809  if (const RecordType *r = CT->getAsRecordType()) {
810    if (r->hasConstFields())
811      return MLV_ConstQualified;
812  }
813
814  // Assigning to an 'implicit' property?
815  else if (isa<ObjCKVCRefExpr>(this)) {
816    const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this);
817    if (KVCExpr->getSetterMethod() == 0)
818      return MLV_NoSetterProperty;
819  }
820  return MLV_Valid;
821}
822
823/// hasGlobalStorage - Return true if this expression has static storage
824/// duration.  This means that the address of this expression is a link-time
825/// constant.
826bool Expr::hasGlobalStorage() const {
827  switch (getStmtClass()) {
828  default:
829    return false;
830  case ParenExprClass:
831    return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage();
832  case ImplicitCastExprClass:
833    return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage();
834  case CompoundLiteralExprClass:
835    return cast<CompoundLiteralExpr>(this)->isFileScope();
836  case DeclRefExprClass:
837  case QualifiedDeclRefExprClass: {
838    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
839    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
840      return VD->hasGlobalStorage();
841    if (isa<FunctionDecl>(D))
842      return true;
843    return false;
844  }
845  case MemberExprClass: {
846    const MemberExpr *M = cast<MemberExpr>(this);
847    return !M->isArrow() && M->getBase()->hasGlobalStorage();
848  }
849  case ArraySubscriptExprClass:
850    return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage();
851  case PredefinedExprClass:
852    return true;
853  case CXXDefaultArgExprClass:
854    return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage();
855  }
856}
857
858/// isOBJCGCCandidate - Check if an expression is objc gc'able.
859///
860bool Expr::isOBJCGCCandidate() const {
861  switch (getStmtClass()) {
862  default:
863    return false;
864  case ObjCIvarRefExprClass:
865    return true;
866  case Expr::UnaryOperatorClass:
867    return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate();
868  case ParenExprClass:
869    return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate();
870  case ImplicitCastExprClass:
871    return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate();
872  case DeclRefExprClass:
873  case QualifiedDeclRefExprClass: {
874    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
875    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
876      return VD->hasGlobalStorage();
877    return false;
878  }
879  case MemberExprClass: {
880    const MemberExpr *M = cast<MemberExpr>(this);
881    return !M->isArrow() && M->getBase()->isOBJCGCCandidate();
882  }
883  case ArraySubscriptExprClass:
884    return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate();
885  }
886}
887Expr* Expr::IgnoreParens() {
888  Expr* E = this;
889  while (ParenExpr* P = dyn_cast<ParenExpr>(E))
890    E = P->getSubExpr();
891
892  return E;
893}
894
895/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
896/// or CastExprs or ImplicitCastExprs, returning their operand.
897Expr *Expr::IgnoreParenCasts() {
898  Expr *E = this;
899  while (true) {
900    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
901      E = P->getSubExpr();
902    else if (CastExpr *P = dyn_cast<CastExpr>(E))
903      E = P->getSubExpr();
904    else
905      return E;
906  }
907}
908
909/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
910/// value (including ptr->int casts of the same size).  Strip off any
911/// ParenExpr or CastExprs, returning their operand.
912Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
913  Expr *E = this;
914  while (true) {
915    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
916      E = P->getSubExpr();
917      continue;
918    }
919
920    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
921      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
922      // ptr<->int casts of the same width.  We also ignore all identify casts.
923      Expr *SE = P->getSubExpr();
924
925      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
926        E = SE;
927        continue;
928      }
929
930      if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) &&
931          (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) &&
932          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
933        E = SE;
934        continue;
935      }
936    }
937
938    return E;
939  }
940}
941
942
943/// hasAnyTypeDependentArguments - Determines if any of the expressions
944/// in Exprs is type-dependent.
945bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
946  for (unsigned I = 0; I < NumExprs; ++I)
947    if (Exprs[I]->isTypeDependent())
948      return true;
949
950  return false;
951}
952
953/// hasAnyValueDependentArguments - Determines if any of the expressions
954/// in Exprs is value-dependent.
955bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
956  for (unsigned I = 0; I < NumExprs; ++I)
957    if (Exprs[I]->isValueDependent())
958      return true;
959
960  return false;
961}
962
963bool Expr::isConstantInitializer(ASTContext &Ctx) const {
964  // This function is attempting whether an expression is an initializer
965  // which can be evaluated at compile-time.  isEvaluatable handles most
966  // of the cases, but it can't deal with some initializer-specific
967  // expressions, and it can't deal with aggregates; we deal with those here,
968  // and fall back to isEvaluatable for the other cases.
969
970  // FIXME: This function assumes the variable being assigned to
971  // isn't a reference type!
972
973  switch (getStmtClass()) {
974  default: break;
975  case StringLiteralClass:
976  case ObjCEncodeExprClass:
977    return true;
978  case CompoundLiteralExprClass: {
979    // This handles gcc's extension that allows global initializers like
980    // "struct x {int x;} x = (struct x) {};".
981    // FIXME: This accepts other cases it shouldn't!
982    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
983    return Exp->isConstantInitializer(Ctx);
984  }
985  case InitListExprClass: {
986    // FIXME: This doesn't deal with fields with reference types correctly.
987    // FIXME: This incorrectly allows pointers cast to integers to be assigned
988    // to bitfields.
989    const InitListExpr *Exp = cast<InitListExpr>(this);
990    unsigned numInits = Exp->getNumInits();
991    for (unsigned i = 0; i < numInits; i++) {
992      if (!Exp->getInit(i)->isConstantInitializer(Ctx))
993        return false;
994    }
995    return true;
996  }
997  case ImplicitValueInitExprClass:
998    return true;
999  case ParenExprClass: {
1000    return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1001  }
1002  case UnaryOperatorClass: {
1003    const UnaryOperator* Exp = cast<UnaryOperator>(this);
1004    if (Exp->getOpcode() == UnaryOperator::Extension)
1005      return Exp->getSubExpr()->isConstantInitializer(Ctx);
1006    break;
1007  }
1008  case CStyleCastExprClass:
1009    // Handle casts with a destination that's a struct or union; this
1010    // deals with both the gcc no-op struct cast extension and the
1011    // cast-to-union extension.
1012    if (getType()->isRecordType())
1013      return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1014    break;
1015  }
1016
1017  return isEvaluatable(Ctx);
1018}
1019
1020/// isIntegerConstantExpr - this recursive routine will test if an expression is
1021/// an integer constant expression.
1022
1023/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
1024/// comma, etc
1025///
1026/// FIXME: Handle offsetof.  Two things to do:  Handle GCC's __builtin_offsetof
1027/// to support gcc 4.0+  and handle the idiom GCC recognizes with a null pointer
1028/// cast+dereference.
1029
1030// CheckICE - This function does the fundamental ICE checking: the returned
1031// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation.
1032// Note that to reduce code duplication, this helper does no evaluation
1033// itself; the caller checks whether the expression is evaluatable, and
1034// in the rare cases where CheckICE actually cares about the evaluated
1035// value, it calls into Evalute.
1036//
1037// Meanings of Val:
1038// 0: This expression is an ICE if it can be evaluated by Evaluate.
1039// 1: This expression is not an ICE, but if it isn't evaluated, it's
1040//    a legal subexpression for an ICE. This return value is used to handle
1041//    the comma operator in C99 mode.
1042// 2: This expression is not an ICE, and is not a legal subexpression for one.
1043
1044struct ICEDiag {
1045  unsigned Val;
1046  SourceLocation Loc;
1047
1048  public:
1049  ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {}
1050  ICEDiag() : Val(0) {}
1051};
1052
1053ICEDiag NoDiag() { return ICEDiag(); }
1054
1055static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) {
1056  Expr::EvalResult EVResult;
1057  if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1058      !EVResult.Val.isInt()) {
1059    return ICEDiag(2, E->getLocStart());
1060  }
1061  return NoDiag();
1062}
1063
1064static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
1065  assert(!E->isValueDependent() && "Should not see value dependent exprs!");
1066  if (!E->getType()->isIntegralType()) {
1067    return ICEDiag(2, E->getLocStart());
1068  }
1069
1070  switch (E->getStmtClass()) {
1071  default:
1072    return ICEDiag(2, E->getLocStart());
1073  case Expr::ParenExprClass:
1074    return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
1075  case Expr::IntegerLiteralClass:
1076  case Expr::CharacterLiteralClass:
1077  case Expr::CXXBoolLiteralExprClass:
1078  case Expr::CXXZeroInitValueExprClass:
1079  case Expr::TypesCompatibleExprClass:
1080  case Expr::UnaryTypeTraitExprClass:
1081    return NoDiag();
1082  case Expr::CallExprClass:
1083  case Expr::CXXOperatorCallExprClass: {
1084    const CallExpr *CE = cast<CallExpr>(E);
1085    if (CE->isBuiltinCall(Ctx))
1086      return CheckEvalInICE(E, Ctx);
1087    return ICEDiag(2, E->getLocStart());
1088  }
1089  case Expr::DeclRefExprClass:
1090  case Expr::QualifiedDeclRefExprClass:
1091    if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
1092      return NoDiag();
1093    if (Ctx.getLangOptions().CPlusPlus &&
1094        E->getType().getCVRQualifiers() == QualType::Const) {
1095      // C++ 7.1.5.1p2
1096      //   A variable of non-volatile const-qualified integral or enumeration
1097      //   type initialized by an ICE can be used in ICEs.
1098      if (const VarDecl *Dcl =
1099              dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
1100        if (const Expr *Init = Dcl->getInit())
1101          return CheckICE(Init, Ctx);
1102      }
1103    }
1104    return ICEDiag(2, E->getLocStart());
1105  case Expr::UnaryOperatorClass: {
1106    const UnaryOperator *Exp = cast<UnaryOperator>(E);
1107    switch (Exp->getOpcode()) {
1108    default:
1109      return ICEDiag(2, E->getLocStart());
1110    case UnaryOperator::Extension:
1111    case UnaryOperator::LNot:
1112    case UnaryOperator::Plus:
1113    case UnaryOperator::Minus:
1114    case UnaryOperator::Not:
1115    case UnaryOperator::Real:
1116    case UnaryOperator::Imag:
1117      return CheckICE(Exp->getSubExpr(), Ctx);
1118    case UnaryOperator::OffsetOf:
1119      // Note that per C99, offsetof must be an ICE. And AFAIK, using
1120      // Evaluate matches the proposed gcc behavior for cases like
1121      // "offsetof(struct s{int x[4];}, x[!.0])".  This doesn't affect
1122      // compliance: we should warn earlier for offsetof expressions with
1123      // array subscripts that aren't ICEs, and if the array subscripts
1124      // are ICEs, the value of the offsetof must be an integer constant.
1125      return CheckEvalInICE(E, Ctx);
1126    }
1127  }
1128  case Expr::SizeOfAlignOfExprClass: {
1129    const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E);
1130    if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType())
1131      return ICEDiag(2, E->getLocStart());
1132    return NoDiag();
1133  }
1134  case Expr::BinaryOperatorClass: {
1135    const BinaryOperator *Exp = cast<BinaryOperator>(E);
1136    switch (Exp->getOpcode()) {
1137    default:
1138      return ICEDiag(2, E->getLocStart());
1139    case BinaryOperator::Mul:
1140    case BinaryOperator::Div:
1141    case BinaryOperator::Rem:
1142    case BinaryOperator::Add:
1143    case BinaryOperator::Sub:
1144    case BinaryOperator::Shl:
1145    case BinaryOperator::Shr:
1146    case BinaryOperator::LT:
1147    case BinaryOperator::GT:
1148    case BinaryOperator::LE:
1149    case BinaryOperator::GE:
1150    case BinaryOperator::EQ:
1151    case BinaryOperator::NE:
1152    case BinaryOperator::And:
1153    case BinaryOperator::Xor:
1154    case BinaryOperator::Or:
1155    case BinaryOperator::Comma: {
1156      ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1157      ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1158      if (Exp->getOpcode() == BinaryOperator::Div ||
1159          Exp->getOpcode() == BinaryOperator::Rem) {
1160        // Evaluate gives an error for undefined Div/Rem, so make sure
1161        // we don't evaluate one.
1162        if (LHSResult.Val != 2 && RHSResult.Val != 2) {
1163          llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx);
1164          if (REval == 0)
1165            return ICEDiag(1, E->getLocStart());
1166          if (REval.isSigned() && REval.isAllOnesValue()) {
1167            llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx);
1168            if (LEval.isMinSignedValue())
1169              return ICEDiag(1, E->getLocStart());
1170          }
1171        }
1172      }
1173      if (Exp->getOpcode() == BinaryOperator::Comma) {
1174        if (Ctx.getLangOptions().C99) {
1175          // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
1176          // if it isn't evaluated.
1177          if (LHSResult.Val == 0 && RHSResult.Val == 0)
1178            return ICEDiag(1, E->getLocStart());
1179        } else {
1180          // In both C89 and C++, commas in ICEs are illegal.
1181          return ICEDiag(2, E->getLocStart());
1182        }
1183      }
1184      if (LHSResult.Val >= RHSResult.Val)
1185        return LHSResult;
1186      return RHSResult;
1187    }
1188    case BinaryOperator::LAnd:
1189    case BinaryOperator::LOr: {
1190      ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1191      ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1192      if (LHSResult.Val == 0 && RHSResult.Val == 1) {
1193        // Rare case where the RHS has a comma "side-effect"; we need
1194        // to actually check the condition to see whether the side
1195        // with the comma is evaluated.
1196        if ((Exp->getOpcode() == BinaryOperator::LAnd) !=
1197            (Exp->getLHS()->EvaluateAsInt(Ctx) == 0))
1198          return RHSResult;
1199        return NoDiag();
1200      }
1201
1202      if (LHSResult.Val >= RHSResult.Val)
1203        return LHSResult;
1204      return RHSResult;
1205    }
1206    }
1207  }
1208  case Expr::ImplicitCastExprClass:
1209  case Expr::CStyleCastExprClass:
1210  case Expr::CXXFunctionalCastExprClass: {
1211    const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
1212    if (SubExpr->getType()->isIntegralType())
1213      return CheckICE(SubExpr, Ctx);
1214    if (isa<FloatingLiteral>(SubExpr->IgnoreParens()))
1215      return NoDiag();
1216    return ICEDiag(2, E->getLocStart());
1217  }
1218  case Expr::ConditionalOperatorClass: {
1219    const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
1220    // If the condition (ignoring parens) is a __builtin_constant_p call,
1221    // then only the true side is actually considered in an integer constant
1222    // expression, and it is fully evaluated.  This is an important GNU
1223    // extension.  See GCC PR38377 for discussion.
1224    if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
1225      if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) {
1226        Expr::EvalResult EVResult;
1227        if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1228            !EVResult.Val.isInt()) {
1229          return ICEDiag(2, E->getLocStart());
1230        }
1231        return NoDiag();
1232      }
1233    ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
1234    ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
1235    ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
1236    if (CondResult.Val == 2)
1237      return CondResult;
1238    if (TrueResult.Val == 2)
1239      return TrueResult;
1240    if (FalseResult.Val == 2)
1241      return FalseResult;
1242    if (CondResult.Val == 1)
1243      return CondResult;
1244    if (TrueResult.Val == 0 && FalseResult.Val == 0)
1245      return NoDiag();
1246    // Rare case where the diagnostics depend on which side is evaluated
1247    // Note that if we get here, CondResult is 0, and at least one of
1248    // TrueResult and FalseResult is non-zero.
1249    if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) {
1250      return FalseResult;
1251    }
1252    return TrueResult;
1253  }
1254  case Expr::CXXDefaultArgExprClass:
1255    return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
1256  case Expr::ChooseExprClass: {
1257    return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx);
1258  }
1259  }
1260}
1261
1262bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
1263                                 SourceLocation *Loc, bool isEvaluated) const {
1264  ICEDiag d = CheckICE(this, Ctx);
1265  if (d.Val != 0) {
1266    if (Loc) *Loc = d.Loc;
1267    return false;
1268  }
1269  EvalResult EvalResult;
1270  if (!Evaluate(EvalResult, Ctx))
1271    assert(0 && "ICE cannot be evaluated!");
1272  assert(!EvalResult.HasSideEffects && "ICE with side effects!");
1273  assert(EvalResult.Val.isInt() && "ICE that isn't integer!");
1274  Result = EvalResult.Val.getInt();
1275  return true;
1276}
1277
1278/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1279/// integer constant expression with the value zero, or if this is one that is
1280/// cast to void*.
1281bool Expr::isNullPointerConstant(ASTContext &Ctx) const
1282{
1283  // Strip off a cast to void*, if it exists. Except in C++.
1284  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1285    if (!Ctx.getLangOptions().CPlusPlus) {
1286      // Check that it is a cast to void*.
1287      if (const PointerType *PT = CE->getType()->getAsPointerType()) {
1288        QualType Pointee = PT->getPointeeType();
1289        if (Pointee.getCVRQualifiers() == 0 &&
1290            Pointee->isVoidType() &&                              // to void*
1291            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1292          return CE->getSubExpr()->isNullPointerConstant(Ctx);
1293      }
1294    }
1295  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1296    // Ignore the ImplicitCastExpr type entirely.
1297    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
1298  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1299    // Accept ((void*)0) as a null pointer constant, as many other
1300    // implementations do.
1301    return PE->getSubExpr()->isNullPointerConstant(Ctx);
1302  } else if (const CXXDefaultArgExpr *DefaultArg
1303               = dyn_cast<CXXDefaultArgExpr>(this)) {
1304    // See through default argument expressions
1305    return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
1306  } else if (isa<GNUNullExpr>(this)) {
1307    // The GNU __null extension is always a null pointer constant.
1308    return true;
1309  }
1310
1311  // This expression must be an integer type.
1312  if (!getType()->isIntegerType())
1313    return false;
1314
1315  // If we have an integer constant expression, we need to *evaluate* it and
1316  // test for the value 0.
1317  // FIXME: We should probably return false if we're compiling in strict mode
1318  // and Diag is not null (this indicates that the value was foldable but not
1319  // an ICE.
1320  EvalResult Result;
1321  return Evaluate(Result, Ctx) && !Result.HasSideEffects &&
1322        Result.Val.isInt() && Result.Val.getInt() == 0;
1323}
1324
1325/// isBitField - Return true if this expression is a bit-field.
1326bool Expr::isBitField() {
1327  Expr *E = this->IgnoreParenCasts();
1328  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1329    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1330        return Field->isBitField();
1331  return false;
1332}
1333
1334/// isArrow - Return true if the base expression is a pointer to vector,
1335/// return false if the base expression is a vector.
1336bool ExtVectorElementExpr::isArrow() const {
1337  return getBase()->getType()->isPointerType();
1338}
1339
1340unsigned ExtVectorElementExpr::getNumElements() const {
1341  if (const VectorType *VT = getType()->getAsVectorType())
1342    return VT->getNumElements();
1343  return 1;
1344}
1345
1346/// containsDuplicateElements - Return true if any element access is repeated.
1347bool ExtVectorElementExpr::containsDuplicateElements() const {
1348  const char *compStr = Accessor.getName();
1349  unsigned length = Accessor.getLength();
1350
1351  // Halving swizzles do not contain duplicate elements.
1352  if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1353      !strcmp(compStr, "even") || !strcmp(compStr, "odd"))
1354    return false;
1355
1356  // Advance past s-char prefix on hex swizzles.
1357  if (*compStr == 's') {
1358    compStr++;
1359    length--;
1360  }
1361
1362  for (unsigned i = 0; i != length-1; i++) {
1363    const char *s = compStr+i;
1364    for (const char c = *s++; *s; s++)
1365      if (c == *s)
1366        return true;
1367  }
1368  return false;
1369}
1370
1371/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1372void ExtVectorElementExpr::getEncodedElementAccess(
1373                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1374  const char *compStr = Accessor.getName();
1375  if (*compStr == 's')
1376    compStr++;
1377
1378  bool isHi =   !strcmp(compStr, "hi");
1379  bool isLo =   !strcmp(compStr, "lo");
1380  bool isEven = !strcmp(compStr, "even");
1381  bool isOdd  = !strcmp(compStr, "odd");
1382
1383  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1384    uint64_t Index;
1385
1386    if (isHi)
1387      Index = e + i;
1388    else if (isLo)
1389      Index = i;
1390    else if (isEven)
1391      Index = 2 * i;
1392    else if (isOdd)
1393      Index = 2 * i + 1;
1394    else
1395      Index = ExtVectorType::getAccessorIdx(compStr[i]);
1396
1397    Elts.push_back(Index);
1398  }
1399}
1400
1401// constructor for instance messages.
1402ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
1403                QualType retType, ObjCMethodDecl *mproto,
1404                SourceLocation LBrac, SourceLocation RBrac,
1405                Expr **ArgExprs, unsigned nargs)
1406  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1407    MethodProto(mproto) {
1408  NumArgs = nargs;
1409  SubExprs = new Stmt*[NumArgs+1];
1410  SubExprs[RECEIVER] = receiver;
1411  if (NumArgs) {
1412    for (unsigned i = 0; i != NumArgs; ++i)
1413      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1414  }
1415  LBracloc = LBrac;
1416  RBracloc = RBrac;
1417}
1418
1419// constructor for class messages.
1420// FIXME: clsName should be typed to ObjCInterfaceType
1421ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
1422                QualType retType, ObjCMethodDecl *mproto,
1423                SourceLocation LBrac, SourceLocation RBrac,
1424                Expr **ArgExprs, unsigned nargs)
1425  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1426    MethodProto(mproto) {
1427  NumArgs = nargs;
1428  SubExprs = new Stmt*[NumArgs+1];
1429  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
1430  if (NumArgs) {
1431    for (unsigned i = 0; i != NumArgs; ++i)
1432      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1433  }
1434  LBracloc = LBrac;
1435  RBracloc = RBrac;
1436}
1437
1438// constructor for class messages.
1439ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1440                                 QualType retType, ObjCMethodDecl *mproto,
1441                                 SourceLocation LBrac, SourceLocation RBrac,
1442                                 Expr **ArgExprs, unsigned nargs)
1443: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1444MethodProto(mproto) {
1445  NumArgs = nargs;
1446  SubExprs = new Stmt*[NumArgs+1];
1447  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1448  if (NumArgs) {
1449    for (unsigned i = 0; i != NumArgs; ++i)
1450      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1451  }
1452  LBracloc = LBrac;
1453  RBracloc = RBrac;
1454}
1455
1456ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1457  uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1458  switch (x & Flags) {
1459    default:
1460      assert(false && "Invalid ObjCMessageExpr.");
1461    case IsInstMeth:
1462      return ClassInfo(0, 0);
1463    case IsClsMethDeclUnknown:
1464      return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1465    case IsClsMethDeclKnown: {
1466      ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1467      return ClassInfo(D, D->getIdentifier());
1468    }
1469  }
1470}
1471
1472bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1473  return getCond()->getIntegerConstantExprValue(C) != 0;
1474}
1475
1476void SizeOfAlignOfExpr::Destroy(ASTContext& C) {
1477  // Override default behavior of traversing children. If this has a type
1478  // operand and the type is a variable-length array, the child iteration
1479  // will iterate over the size expression. However, this expression belongs
1480  // to the type, not to this, so we don't want to delete it.
1481  // We still want to delete this expression.
1482  if (isArgumentType()) {
1483    this->~SizeOfAlignOfExpr();
1484    C.Deallocate(this);
1485  }
1486  else
1487    Expr::Destroy(C);
1488}
1489
1490//===----------------------------------------------------------------------===//
1491//  DesignatedInitExpr
1492//===----------------------------------------------------------------------===//
1493
1494IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
1495  assert(Kind == FieldDesignator && "Only valid on a field designator");
1496  if (Field.NameOrField & 0x01)
1497    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
1498  else
1499    return getField()->getIdentifier();
1500}
1501
1502DesignatedInitExpr *
1503DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
1504                           unsigned NumDesignators,
1505                           Expr **IndexExprs, unsigned NumIndexExprs,
1506                           SourceLocation ColonOrEqualLoc,
1507                           bool UsesColonSyntax, Expr *Init) {
1508  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1509                         sizeof(Designator) * NumDesignators +
1510                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1511  DesignatedInitExpr *DIE
1512    = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators,
1513                                   ColonOrEqualLoc, UsesColonSyntax,
1514                                   NumIndexExprs + 1);
1515
1516  // Fill in the designators
1517  unsigned ExpectedNumSubExprs = 0;
1518  designators_iterator Desig = DIE->designators_begin();
1519  for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) {
1520    new (static_cast<void*>(Desig)) Designator(Designators[Idx]);
1521    if (Designators[Idx].isArrayDesignator())
1522      ++ExpectedNumSubExprs;
1523    else if (Designators[Idx].isArrayRangeDesignator())
1524      ExpectedNumSubExprs += 2;
1525  }
1526  assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!");
1527
1528  // Fill in the subexpressions, including the initializer expression.
1529  child_iterator Child = DIE->child_begin();
1530  *Child++ = Init;
1531  for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child)
1532    *Child = IndexExprs[Idx];
1533
1534  return DIE;
1535}
1536
1537SourceRange DesignatedInitExpr::getSourceRange() const {
1538  SourceLocation StartLoc;
1539  Designator &First =
1540    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
1541  if (First.isFieldDesignator()) {
1542    if (GNUSyntax)
1543      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
1544    else
1545      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
1546  } else
1547    StartLoc =
1548      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
1549  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
1550}
1551
1552DesignatedInitExpr::designators_iterator
1553DesignatedInitExpr::designators_begin() {
1554  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1555  Ptr += sizeof(DesignatedInitExpr);
1556  return static_cast<Designator*>(static_cast<void*>(Ptr));
1557}
1558
1559DesignatedInitExpr::designators_iterator DesignatedInitExpr::designators_end() {
1560  return designators_begin() + NumDesignators;
1561}
1562
1563Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
1564  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
1565  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1566  Ptr += sizeof(DesignatedInitExpr);
1567  Ptr += sizeof(Designator) * NumDesignators;
1568  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1569  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1570}
1571
1572Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
1573  assert(D.Kind == Designator::ArrayRangeDesignator &&
1574         "Requires array range designator");
1575  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1576  Ptr += sizeof(DesignatedInitExpr);
1577  Ptr += sizeof(Designator) * NumDesignators;
1578  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1579  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1580}
1581
1582Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
1583  assert(D.Kind == Designator::ArrayRangeDesignator &&
1584         "Requires array range designator");
1585  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1586  Ptr += sizeof(DesignatedInitExpr);
1587  Ptr += sizeof(Designator) * NumDesignators;
1588  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1589  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
1590}
1591
1592//===----------------------------------------------------------------------===//
1593//  ExprIterator.
1594//===----------------------------------------------------------------------===//
1595
1596Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
1597Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
1598Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
1599const Expr* ConstExprIterator::operator[](size_t idx) const {
1600  return cast<Expr>(I[idx]);
1601}
1602const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
1603const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
1604
1605//===----------------------------------------------------------------------===//
1606//  Child Iterators for iterating over subexpressions/substatements
1607//===----------------------------------------------------------------------===//
1608
1609// DeclRefExpr
1610Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1611Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
1612
1613// ObjCIvarRefExpr
1614Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1615Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
1616
1617// ObjCPropertyRefExpr
1618Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1619Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
1620
1621// ObjCKVCRefExpr
1622Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; }
1623Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; }
1624
1625// ObjCSuperExpr
1626Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
1627Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
1628
1629// PredefinedExpr
1630Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
1631Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
1632
1633// IntegerLiteral
1634Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1635Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
1636
1637// CharacterLiteral
1638Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
1639Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
1640
1641// FloatingLiteral
1642Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1643Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
1644
1645// ImaginaryLiteral
1646Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1647Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
1648
1649// StringLiteral
1650Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1651Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
1652
1653// ParenExpr
1654Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1655Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
1656
1657// UnaryOperator
1658Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1659Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
1660
1661// SizeOfAlignOfExpr
1662Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
1663  // If this is of a type and the type is a VLA type (and not a typedef), the
1664  // size expression of the VLA needs to be treated as an executable expression.
1665  // Why isn't this weirdness documented better in StmtIterator?
1666  if (isArgumentType()) {
1667    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
1668                                   getArgumentType().getTypePtr()))
1669      return child_iterator(T);
1670    return child_iterator();
1671  }
1672  return child_iterator(&Argument.Ex);
1673}
1674Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
1675  if (isArgumentType())
1676    return child_iterator();
1677  return child_iterator(&Argument.Ex + 1);
1678}
1679
1680// ArraySubscriptExpr
1681Stmt::child_iterator ArraySubscriptExpr::child_begin() {
1682  return &SubExprs[0];
1683}
1684Stmt::child_iterator ArraySubscriptExpr::child_end() {
1685  return &SubExprs[0]+END_EXPR;
1686}
1687
1688// CallExpr
1689Stmt::child_iterator CallExpr::child_begin() {
1690  return &SubExprs[0];
1691}
1692Stmt::child_iterator CallExpr::child_end() {
1693  return &SubExprs[0]+NumArgs+ARGS_START;
1694}
1695
1696// MemberExpr
1697Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1698Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
1699
1700// ExtVectorElementExpr
1701Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1702Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
1703
1704// CompoundLiteralExpr
1705Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1706Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
1707
1708// CastExpr
1709Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1710Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
1711
1712// BinaryOperator
1713Stmt::child_iterator BinaryOperator::child_begin() {
1714  return &SubExprs[0];
1715}
1716Stmt::child_iterator BinaryOperator::child_end() {
1717  return &SubExprs[0]+END_EXPR;
1718}
1719
1720// ConditionalOperator
1721Stmt::child_iterator ConditionalOperator::child_begin() {
1722  return &SubExprs[0];
1723}
1724Stmt::child_iterator ConditionalOperator::child_end() {
1725  return &SubExprs[0]+END_EXPR;
1726}
1727
1728// AddrLabelExpr
1729Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1730Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
1731
1732// StmtExpr
1733Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1734Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
1735
1736// TypesCompatibleExpr
1737Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1738  return child_iterator();
1739}
1740
1741Stmt::child_iterator TypesCompatibleExpr::child_end() {
1742  return child_iterator();
1743}
1744
1745// ChooseExpr
1746Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1747Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
1748
1749// GNUNullExpr
1750Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
1751Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
1752
1753// ShuffleVectorExpr
1754Stmt::child_iterator ShuffleVectorExpr::child_begin() {
1755  return &SubExprs[0];
1756}
1757Stmt::child_iterator ShuffleVectorExpr::child_end() {
1758  return &SubExprs[0]+NumExprs;
1759}
1760
1761// VAArgExpr
1762Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1763Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
1764
1765// InitListExpr
1766Stmt::child_iterator InitListExpr::child_begin() {
1767  return InitExprs.size() ? &InitExprs[0] : 0;
1768}
1769Stmt::child_iterator InitListExpr::child_end() {
1770  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
1771}
1772
1773// DesignatedInitExpr
1774Stmt::child_iterator DesignatedInitExpr::child_begin() {
1775  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1776  Ptr += sizeof(DesignatedInitExpr);
1777  Ptr += sizeof(Designator) * NumDesignators;
1778  return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1779}
1780Stmt::child_iterator DesignatedInitExpr::child_end() {
1781  return child_iterator(&*child_begin() + NumSubExprs);
1782}
1783
1784// ImplicitValueInitExpr
1785Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
1786  return child_iterator();
1787}
1788
1789Stmt::child_iterator ImplicitValueInitExpr::child_end() {
1790  return child_iterator();
1791}
1792
1793// ObjCStringLiteral
1794Stmt::child_iterator ObjCStringLiteral::child_begin() {
1795  return &String;
1796}
1797Stmt::child_iterator ObjCStringLiteral::child_end() {
1798  return &String+1;
1799}
1800
1801// ObjCEncodeExpr
1802Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
1803Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
1804
1805// ObjCSelectorExpr
1806Stmt::child_iterator ObjCSelectorExpr::child_begin() {
1807  return child_iterator();
1808}
1809Stmt::child_iterator ObjCSelectorExpr::child_end() {
1810  return child_iterator();
1811}
1812
1813// ObjCProtocolExpr
1814Stmt::child_iterator ObjCProtocolExpr::child_begin() {
1815  return child_iterator();
1816}
1817Stmt::child_iterator ObjCProtocolExpr::child_end() {
1818  return child_iterator();
1819}
1820
1821// ObjCMessageExpr
1822Stmt::child_iterator ObjCMessageExpr::child_begin() {
1823  return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
1824}
1825Stmt::child_iterator ObjCMessageExpr::child_end() {
1826  return &SubExprs[0]+ARGS_START+getNumArgs();
1827}
1828
1829// Blocks
1830Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
1831Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
1832
1833Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
1834Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
1835