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