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