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