Expr.cpp revision 1c0cfd4599e816cfd7a8f348286bf0ad79652ffc 
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, bool hadDesignators)
225  : Expr(InitListExprClass, QualType()),
226    LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), HadDesignators(hadDesignators) {
227
228  InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits);
229}
230
231/// getFunctionType - Return the underlying function type for this block.
232///
233const FunctionType *BlockExpr::getFunctionType() const {
234  return getType()->getAsBlockPointerType()->
235                    getPointeeType()->getAsFunctionType();
236}
237
238SourceLocation BlockExpr::getCaretLocation() const {
239  return TheBlock->getCaretLocation();
240}
241const Stmt *BlockExpr::getBody() const { return TheBlock->getBody(); }
242Stmt *BlockExpr::getBody() { return TheBlock->getBody(); }
243
244
245//===----------------------------------------------------------------------===//
246// Generic Expression Routines
247//===----------------------------------------------------------------------===//
248
249/// hasLocalSideEffect - Return true if this immediate expression has side
250/// effects, not counting any sub-expressions.
251bool Expr::hasLocalSideEffect() const {
252  switch (getStmtClass()) {
253  default:
254    return false;
255  case ParenExprClass:
256    return cast<ParenExpr>(this)->getSubExpr()->hasLocalSideEffect();
257  case UnaryOperatorClass: {
258    const UnaryOperator *UO = cast<UnaryOperator>(this);
259
260    switch (UO->getOpcode()) {
261    default: return false;
262    case UnaryOperator::PostInc:
263    case UnaryOperator::PostDec:
264    case UnaryOperator::PreInc:
265    case UnaryOperator::PreDec:
266      return true;                     // ++/--
267
268    case UnaryOperator::Deref:
269      // Dereferencing a volatile pointer is a side-effect.
270      return getType().isVolatileQualified();
271    case UnaryOperator::Real:
272    case UnaryOperator::Imag:
273      // accessing a piece of a volatile complex is a side-effect.
274      return UO->getSubExpr()->getType().isVolatileQualified();
275
276    case UnaryOperator::Extension:
277      return UO->getSubExpr()->hasLocalSideEffect();
278    }
279  }
280  case BinaryOperatorClass: {
281    const BinaryOperator *BinOp = cast<BinaryOperator>(this);
282    // Consider comma to have side effects if the LHS and RHS both do.
283    if (BinOp->getOpcode() == BinaryOperator::Comma)
284      return BinOp->getLHS()->hasLocalSideEffect() &&
285             BinOp->getRHS()->hasLocalSideEffect();
286
287    return BinOp->isAssignmentOp();
288  }
289  case CompoundAssignOperatorClass:
290    return true;
291
292  case ConditionalOperatorClass: {
293    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
294    return Exp->getCond()->hasLocalSideEffect()
295           || (Exp->getLHS() && Exp->getLHS()->hasLocalSideEffect())
296           || (Exp->getRHS() && Exp->getRHS()->hasLocalSideEffect());
297  }
298
299  case MemberExprClass:
300  case ArraySubscriptExprClass:
301    // If the base pointer or element is to a volatile pointer/field, accessing
302    // if is a side effect.
303    return getType().isVolatileQualified();
304
305  case CallExprClass:
306  case CXXOperatorCallExprClass:
307    // TODO: check attributes for pure/const.   "void foo() { strlen("bar"); }"
308    // should warn.
309    return true;
310  case ObjCMessageExprClass:
311    return true;
312  case StmtExprClass: {
313    // Statement exprs don't logically have side effects themselves, but are
314    // sometimes used in macros in ways that give them a type that is unused.
315    // For example ({ blah; foo(); }) will end up with a type if foo has a type.
316    // however, if the result of the stmt expr is dead, we don't want to emit a
317    // warning.
318    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
319    if (!CS->body_empty())
320      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
321        return E->hasLocalSideEffect();
322    return false;
323  }
324  case CStyleCastExprClass:
325  case CXXFunctionalCastExprClass:
326    // If this is a cast to void, check the operand.  Otherwise, the result of
327    // the cast is unused.
328    if (getType()->isVoidType())
329      return cast<CastExpr>(this)->getSubExpr()->hasLocalSideEffect();
330    return false;
331
332  case ImplicitCastExprClass:
333    // Check the operand, since implicit casts are inserted by Sema
334    return cast<ImplicitCastExpr>(this)->getSubExpr()->hasLocalSideEffect();
335
336  case CXXDefaultArgExprClass:
337    return cast<CXXDefaultArgExpr>(this)->getExpr()->hasLocalSideEffect();
338
339  case CXXNewExprClass:
340    // FIXME: In theory, there might be new expressions that don't have side
341    // effects (e.g. a placement new with an uninitialized POD).
342  case CXXDeleteExprClass:
343    return true;
344  }
345}
346
347/// DeclCanBeLvalue - Determine whether the given declaration can be
348/// an lvalue. This is a helper routine for isLvalue.
349static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) {
350  // C++ [temp.param]p6:
351  //   A non-type non-reference template-parameter is not an lvalue.
352  if (const NonTypeTemplateParmDecl *NTTParm
353        = dyn_cast<NonTypeTemplateParmDecl>(Decl))
354    return NTTParm->getType()->isReferenceType();
355
356  return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) ||
357    // C++ 3.10p2: An lvalue refers to an object or function.
358    (Ctx.getLangOptions().CPlusPlus &&
359     (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl)));
360}
361
362/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
363/// incomplete type other than void. Nonarray expressions that can be lvalues:
364///  - name, where name must be a variable
365///  - e[i]
366///  - (e), where e must be an lvalue
367///  - e.name, where e must be an lvalue
368///  - e->name
369///  - *e, the type of e cannot be a function type
370///  - string-constant
371///  - (__real__ e) and (__imag__ e) where e is an lvalue  [GNU extension]
372///  - reference type [C++ [expr]]
373///
374Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const {
375  // first, check the type (C99 6.3.2.1). Expressions with function
376  // type in C are not lvalues, but they can be lvalues in C++.
377  if (!Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
378    return LV_NotObjectType;
379
380  // Allow qualified void which is an incomplete type other than void (yuck).
381  if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers())
382    return LV_IncompleteVoidType;
383
384  /// FIXME: Expressions can't have reference type, so the following
385  /// isn't needed.
386  if (TR->isReferenceType()) // C++ [expr]
387    return LV_Valid;
388
389  // the type looks fine, now check the expression
390  switch (getStmtClass()) {
391  case StringLiteralClass: // C99 6.5.1p4
392    return LV_Valid;
393  case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
394    // For vectors, make sure base is an lvalue (i.e. not a function call).
395    if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
396      return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx);
397    return LV_Valid;
398  case DeclRefExprClass: { // C99 6.5.1p2
399    const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
400    if (DeclCanBeLvalue(RefdDecl, Ctx))
401      return LV_Valid;
402    break;
403  }
404  case BlockDeclRefExprClass: {
405    const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
406    if (isa<VarDecl>(BDR->getDecl()))
407      return LV_Valid;
408    break;
409  }
410  case MemberExprClass: { // C99 6.5.2.3p4
411    const MemberExpr *m = cast<MemberExpr>(this);
412    return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx);
413  }
414  case UnaryOperatorClass:
415    if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref)
416      return LV_Valid; // C99 6.5.3p4
417
418    if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real ||
419        cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag ||
420        cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension)
421      return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx);  // GNU.
422
423    if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1
424        (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc ||
425         cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec))
426      return LV_Valid;
427    break;
428  case ImplicitCastExprClass:
429    return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid
430                                                       : LV_InvalidExpression;
431  case ParenExprClass: // C99 6.5.1p5
432    return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx);
433  case BinaryOperatorClass:
434  case CompoundAssignOperatorClass: {
435    const BinaryOperator *BinOp = cast<BinaryOperator>(this);
436
437    if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1
438        BinOp->getOpcode() == BinaryOperator::Comma)
439      return BinOp->getRHS()->isLvalue(Ctx);
440
441    if (!BinOp->isAssignmentOp())
442      return LV_InvalidExpression;
443
444    if (Ctx.getLangOptions().CPlusPlus)
445      // C++ [expr.ass]p1:
446      //   The result of an assignment operation [...] is an lvalue.
447      return LV_Valid;
448
449
450    // C99 6.5.16:
451    //   An assignment expression [...] is not an lvalue.
452    return LV_InvalidExpression;
453  }
454  case CallExprClass:
455  case CXXOperatorCallExprClass: {
456    // C++ [expr.call]p10:
457    //   A function call is an lvalue if and only if the result type
458    //   is a reference.
459    QualType CalleeType = cast<CallExpr>(this)->getCallee()->getType();
460    if (const PointerType *FnTypePtr = CalleeType->getAsPointerType())
461      if (const FunctionType *FnType
462            = FnTypePtr->getPointeeType()->getAsFunctionType())
463        if (FnType->getResultType()->isReferenceType())
464          return LV_Valid;
465
466    break;
467  }
468  case CompoundLiteralExprClass: // C99 6.5.2.5p5
469    return LV_Valid;
470  case ChooseExprClass:
471    // __builtin_choose_expr is an lvalue if the selected operand is.
472    if (cast<ChooseExpr>(this)->isConditionTrue(Ctx))
473      return cast<ChooseExpr>(this)->getLHS()->isLvalue(Ctx);
474    else
475      return cast<ChooseExpr>(this)->getRHS()->isLvalue(Ctx);
476
477  case ExtVectorElementExprClass:
478    if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements())
479      return LV_DuplicateVectorComponents;
480    return LV_Valid;
481  case ObjCIvarRefExprClass: // ObjC instance variables are lvalues.
482    return LV_Valid;
483  case ObjCPropertyRefExprClass: // FIXME: check if read-only property.
484    return LV_Valid;
485  case ObjCKVCRefExprClass: // FIXME: check if read-only property.
486    return LV_Valid;
487  case PredefinedExprClass:
488    return LV_Valid;
489  case VAArgExprClass:
490    return LV_Valid;
491  case CXXDefaultArgExprClass:
492    return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx);
493  case CXXConditionDeclExprClass:
494    return LV_Valid;
495  case CStyleCastExprClass:
496  case CXXFunctionalCastExprClass:
497  case CXXStaticCastExprClass:
498  case CXXDynamicCastExprClass:
499  case CXXReinterpretCastExprClass:
500  case CXXConstCastExprClass:
501    // The result of an explicit cast is an lvalue if the type we are
502    // casting to is a reference type. See C++ [expr.cast]p1,
503    // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2,
504    // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1.
505    if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isReferenceType())
506      return LV_Valid;
507    break;
508  case CXXTypeidExprClass:
509    // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ...
510    return LV_Valid;
511  default:
512    break;
513  }
514  return LV_InvalidExpression;
515}
516
517/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
518/// does not have an incomplete type, does not have a const-qualified type, and
519/// if it is a structure or union, does not have any member (including,
520/// recursively, any member or element of all contained aggregates or unions)
521/// with a const-qualified type.
522Expr::isModifiableLvalueResult Expr::isModifiableLvalue(ASTContext &Ctx) const {
523  isLvalueResult lvalResult = isLvalue(Ctx);
524
525  switch (lvalResult) {
526  case LV_Valid:
527    // C++ 3.10p11: Functions cannot be modified, but pointers to
528    // functions can be modifiable.
529    if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
530      return MLV_NotObjectType;
531    break;
532
533  case LV_NotObjectType: return MLV_NotObjectType;
534  case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
535  case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
536  case LV_InvalidExpression:
537    // If the top level is a C-style cast, and the subexpression is a valid
538    // lvalue, then this is probably a use of the old-school "cast as lvalue"
539    // GCC extension.  We don't support it, but we want to produce good
540    // diagnostics when it happens so that the user knows why.
541    if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(this))
542      if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid)
543        return MLV_LValueCast;
544    return MLV_InvalidExpression;
545  }
546
547  QualType CT = Ctx.getCanonicalType(getType());
548
549  if (CT.isConstQualified())
550    return MLV_ConstQualified;
551  if (CT->isArrayType())
552    return MLV_ArrayType;
553  if (CT->isIncompleteType())
554    return MLV_IncompleteType;
555
556  if (const RecordType *r = CT->getAsRecordType()) {
557    if (r->hasConstFields())
558      return MLV_ConstQualified;
559  }
560  // The following is illegal:
561  //   void takeclosure(void (^C)(void));
562  //   void func() { int x = 1; takeclosure(^{ x = 7 }); }
563  //
564  if (getStmtClass() == BlockDeclRefExprClass) {
565    const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
566    if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl()))
567      return MLV_NotBlockQualified;
568  }
569  // Assigning to a readonly property?
570  if (getStmtClass() == ObjCPropertyRefExprClass) {
571    const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(this);
572    if (ObjCPropertyDecl *PDecl = PropExpr->getProperty()) {
573      QualType BaseType = PropExpr->getBase()->getType();
574      if (const PointerType *PTy = BaseType->getAsPointerType())
575        if (const ObjCInterfaceType *IFTy =
576            PTy->getPointeeType()->getAsObjCInterfaceType())
577          if (ObjCInterfaceDecl *IFace = IFTy->getDecl())
578            if (IFace->isPropertyReadonly(PDecl))
579              return MLV_ReadonlyProperty;
580    }
581  }
582  // Assigning to an 'implicit' property?
583  else if (getStmtClass() == ObjCKVCRefExprClass) {
584    const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this);
585    if (KVCExpr->getSetterMethod() == 0)
586      return MLV_NoSetterProperty;
587  }
588  return MLV_Valid;
589}
590
591/// hasGlobalStorage - Return true if this expression has static storage
592/// duration.  This means that the address of this expression is a link-time
593/// constant.
594bool Expr::hasGlobalStorage() const {
595  switch (getStmtClass()) {
596  default:
597    return false;
598  case ParenExprClass:
599    return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage();
600  case ImplicitCastExprClass:
601    return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage();
602  case CompoundLiteralExprClass:
603    return cast<CompoundLiteralExpr>(this)->isFileScope();
604  case DeclRefExprClass: {
605    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
606    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
607      return VD->hasGlobalStorage();
608    if (isa<FunctionDecl>(D))
609      return true;
610    return false;
611  }
612  case MemberExprClass: {
613    const MemberExpr *M = cast<MemberExpr>(this);
614    return !M->isArrow() && M->getBase()->hasGlobalStorage();
615  }
616  case ArraySubscriptExprClass:
617    return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage();
618  case PredefinedExprClass:
619    return true;
620  case CXXDefaultArgExprClass:
621    return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage();
622  }
623}
624
625Expr* Expr::IgnoreParens() {
626  Expr* E = this;
627  while (ParenExpr* P = dyn_cast<ParenExpr>(E))
628    E = P->getSubExpr();
629
630  return E;
631}
632
633/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
634/// or CastExprs or ImplicitCastExprs, returning their operand.
635Expr *Expr::IgnoreParenCasts() {
636  Expr *E = this;
637  while (true) {
638    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
639      E = P->getSubExpr();
640    else if (CastExpr *P = dyn_cast<CastExpr>(E))
641      E = P->getSubExpr();
642    else
643      return E;
644  }
645}
646
647/// hasAnyTypeDependentArguments - Determines if any of the expressions
648/// in Exprs is type-dependent.
649bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
650  for (unsigned I = 0; I < NumExprs; ++I)
651    if (Exprs[I]->isTypeDependent())
652      return true;
653
654  return false;
655}
656
657/// hasAnyValueDependentArguments - Determines if any of the expressions
658/// in Exprs is value-dependent.
659bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
660  for (unsigned I = 0; I < NumExprs; ++I)
661    if (Exprs[I]->isValueDependent())
662      return true;
663
664  return false;
665}
666
667bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const {
668  switch (getStmtClass()) {
669  default:
670    if (!isEvaluatable(Ctx)) {
671      if (Loc) *Loc = getLocStart();
672      return false;
673    }
674    break;
675  case StringLiteralClass:
676    return true;
677  case InitListExprClass: {
678    const InitListExpr *Exp = cast<InitListExpr>(this);
679    unsigned numInits = Exp->getNumInits();
680    for (unsigned i = 0; i < numInits; i++) {
681      if (!Exp->getInit(i)->isConstantExpr(Ctx, Loc))
682        return false;
683    }
684  }
685  }
686
687  return true;
688}
689
690/// isIntegerConstantExpr - this recursive routine will test if an expression is
691/// an integer constant expression. Note: With the introduction of VLA's in
692/// C99 the result of the sizeof operator is no longer always a constant
693/// expression. The generalization of the wording to include any subexpression
694/// that is not evaluated (C99 6.6p3) means that nonconstant subexpressions
695/// can appear as operands to other operators (e.g. &&, ||, ?:). For instance,
696/// "0 || f()" can be treated as a constant expression. In C90 this expression,
697/// occurring in a context requiring a constant, would have been a constraint
698/// violation. FIXME: This routine currently implements C90 semantics.
699/// To properly implement C99 semantics this routine will need to evaluate
700/// expressions involving operators previously mentioned.
701
702/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
703/// comma, etc
704///
705/// FIXME: This should ext-warn on overflow during evaluation!  ISO C does not
706/// permit this.  This includes things like (int)1e1000
707///
708/// FIXME: Handle offsetof.  Two things to do:  Handle GCC's __builtin_offsetof
709/// to support gcc 4.0+  and handle the idiom GCC recognizes with a null pointer
710/// cast+dereference.
711bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
712                                 SourceLocation *Loc, bool isEvaluated) const {
713  // Pretest for integral type; some parts of the code crash for types that
714  // can't be sized.
715  if (!getType()->isIntegralType()) {
716    if (Loc) *Loc = getLocStart();
717    return false;
718  }
719  switch (getStmtClass()) {
720  default:
721    if (Loc) *Loc = getLocStart();
722    return false;
723  case ParenExprClass:
724    return cast<ParenExpr>(this)->getSubExpr()->
725                     isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated);
726  case IntegerLiteralClass:
727    Result = cast<IntegerLiteral>(this)->getValue();
728    break;
729  case CharacterLiteralClass: {
730    const CharacterLiteral *CL = cast<CharacterLiteral>(this);
731    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
732    Result = CL->getValue();
733    Result.setIsUnsigned(!getType()->isSignedIntegerType());
734    break;
735  }
736  case CXXBoolLiteralExprClass: {
737    const CXXBoolLiteralExpr *BL = cast<CXXBoolLiteralExpr>(this);
738    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
739    Result = BL->getValue();
740    Result.setIsUnsigned(!getType()->isSignedIntegerType());
741    break;
742  }
743  case CXXZeroInitValueExprClass:
744    Result.clear();
745    break;
746  case TypesCompatibleExprClass: {
747    const TypesCompatibleExpr *TCE = cast<TypesCompatibleExpr>(this);
748    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
749    // Per gcc docs "this built-in function ignores top level
750    // qualifiers".  We need to use the canonical version to properly
751    // be able to strip CRV qualifiers from the type.
752    QualType T0 = Ctx.getCanonicalType(TCE->getArgType1());
753    QualType T1 = Ctx.getCanonicalType(TCE->getArgType2());
754    Result = Ctx.typesAreCompatible(T0.getUnqualifiedType(),
755                                    T1.getUnqualifiedType());
756    break;
757  }
758  case CallExprClass:
759  case CXXOperatorCallExprClass: {
760    const CallExpr *CE = cast<CallExpr>(this);
761    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
762
763    // If this is a call to a builtin function, constant fold it otherwise
764    // reject it.
765    if (CE->isBuiltinCall()) {
766      EvalResult EvalResult;
767      if (CE->Evaluate(EvalResult, Ctx)) {
768        assert(!EvalResult.HasSideEffects &&
769               "Foldable builtin call should not have side effects!");
770        Result = EvalResult.Val.getInt();
771        break;  // It is a constant, expand it.
772      }
773    }
774
775    if (Loc) *Loc = getLocStart();
776    return false;
777  }
778  case DeclRefExprClass:
779    if (const EnumConstantDecl *D =
780          dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) {
781      Result = D->getInitVal();
782      break;
783    }
784    if (Loc) *Loc = getLocStart();
785    return false;
786  case UnaryOperatorClass: {
787    const UnaryOperator *Exp = cast<UnaryOperator>(this);
788
789    // Get the operand value.  If this is offsetof, do not evalute the
790    // operand.  This affects C99 6.6p3.
791    if (!Exp->isOffsetOfOp() && !Exp->getSubExpr()->
792                        isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
793      return false;
794
795    switch (Exp->getOpcode()) {
796    // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
797    // See C99 6.6p3.
798    default:
799      if (Loc) *Loc = Exp->getOperatorLoc();
800      return false;
801    case UnaryOperator::Extension:
802      return true;  // FIXME: this is wrong.
803    case UnaryOperator::LNot: {
804      bool Val = Result == 0;
805      Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
806      Result = Val;
807      break;
808    }
809    case UnaryOperator::Plus:
810      break;
811    case UnaryOperator::Minus:
812      Result = -Result;
813      break;
814    case UnaryOperator::Not:
815      Result = ~Result;
816      break;
817    case UnaryOperator::OffsetOf:
818      Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
819      Result = Exp->evaluateOffsetOf(Ctx);
820    }
821    break;
822  }
823  case SizeOfAlignOfExprClass: {
824    const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(this);
825
826    // Return the result in the right width.
827    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
828
829    QualType ArgTy = Exp->getTypeOfArgument();
830    // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
831    if (ArgTy->isVoidType()) {
832      Result = 1;
833      break;
834    }
835
836    // alignof always evaluates to a constant, sizeof does if arg is not VLA.
837    if (Exp->isSizeOf() && !ArgTy->isConstantSizeType()) {
838      if (Loc) *Loc = Exp->getOperatorLoc();
839      return false;
840    }
841
842    // Get information about the size or align.
843    if (ArgTy->isFunctionType()) {
844      // GCC extension: sizeof(function) = 1.
845      Result = Exp->isSizeOf() ? 1 : 4;
846    } else {
847      unsigned CharSize = Ctx.Target.getCharWidth();
848      if (Exp->isSizeOf())
849        Result = Ctx.getTypeSize(ArgTy) / CharSize;
850      else
851        Result = Ctx.getTypeAlign(ArgTy) / CharSize;
852    }
853    break;
854  }
855  case BinaryOperatorClass: {
856    const BinaryOperator *Exp = cast<BinaryOperator>(this);
857    llvm::APSInt LHS, RHS;
858
859    // Initialize result to have correct signedness and width.
860    Result = llvm::APSInt(static_cast<uint32_t>(Ctx.getTypeSize(getType())),
861                          !getType()->isSignedIntegerType());
862
863    // The LHS of a constant expr is always evaluated and needed.
864    if (!Exp->getLHS()->isIntegerConstantExpr(LHS, Ctx, Loc, isEvaluated))
865      return false;
866
867    // The short-circuiting &&/|| operators don't necessarily evaluate their
868    // RHS.  Make sure to pass isEvaluated down correctly.
869    if (Exp->isLogicalOp()) {
870      bool RHSEval;
871      if (Exp->getOpcode() == BinaryOperator::LAnd)
872        RHSEval = LHS != 0;
873      else {
874        assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical");
875        RHSEval = LHS == 0;
876      }
877
878      if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc,
879                                                isEvaluated & RHSEval))
880        return false;
881    } else {
882      if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated))
883        return false;
884    }
885
886    switch (Exp->getOpcode()) {
887    default:
888      if (Loc) *Loc = getLocStart();
889      return false;
890    case BinaryOperator::Mul:
891      Result = LHS * RHS;
892      break;
893    case BinaryOperator::Div:
894      if (RHS == 0) {
895        if (!isEvaluated) break;
896        if (Loc) *Loc = getLocStart();
897        return false;
898      }
899      Result = LHS / RHS;
900      break;
901    case BinaryOperator::Rem:
902      if (RHS == 0) {
903        if (!isEvaluated) break;
904        if (Loc) *Loc = getLocStart();
905        return false;
906      }
907      Result = LHS % RHS;
908      break;
909    case BinaryOperator::Add: Result = LHS + RHS; break;
910    case BinaryOperator::Sub: Result = LHS - RHS; break;
911    case BinaryOperator::Shl:
912      Result = LHS <<
913        static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1));
914    break;
915    case BinaryOperator::Shr:
916      Result = LHS >>
917        static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1));
918      break;
919    case BinaryOperator::LT:  Result = LHS < RHS; break;
920    case BinaryOperator::GT:  Result = LHS > RHS; break;
921    case BinaryOperator::LE:  Result = LHS <= RHS; break;
922    case BinaryOperator::GE:  Result = LHS >= RHS; break;
923    case BinaryOperator::EQ:  Result = LHS == RHS; break;
924    case BinaryOperator::NE:  Result = LHS != RHS; break;
925    case BinaryOperator::And: Result = LHS & RHS; break;
926    case BinaryOperator::Xor: Result = LHS ^ RHS; break;
927    case BinaryOperator::Or:  Result = LHS | RHS; break;
928    case BinaryOperator::LAnd:
929      Result = LHS != 0 && RHS != 0;
930      break;
931    case BinaryOperator::LOr:
932      Result = LHS != 0 || RHS != 0;
933      break;
934
935    case BinaryOperator::Comma:
936      // C99 6.6p3: "shall not contain assignment, ..., or comma operators,
937      // *except* when they are contained within a subexpression that is not
938      // evaluated".  Note that Assignment can never happen due to constraints
939      // on the LHS subexpr, so we don't need to check it here.
940      if (isEvaluated) {
941        if (Loc) *Loc = getLocStart();
942        return false;
943      }
944
945      // The result of the constant expr is the RHS.
946      Result = RHS;
947      return true;
948    }
949
950    assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!");
951    break;
952  }
953  case ImplicitCastExprClass:
954  case CStyleCastExprClass:
955  case CXXFunctionalCastExprClass: {
956    const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr();
957    SourceLocation CastLoc = getLocStart();
958
959    // C99 6.6p6: shall only convert arithmetic types to integer types.
960    if (!SubExpr->getType()->isArithmeticType() ||
961        !getType()->isIntegerType()) {
962      if (Loc) *Loc = SubExpr->getLocStart();
963      return false;
964    }
965
966    uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType()));
967
968    // Handle simple integer->integer casts.
969    if (SubExpr->getType()->isIntegerType()) {
970      if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
971        return false;
972
973      // Figure out if this is a truncate, extend or noop cast.
974      // If the input is signed, do a sign extend, noop, or truncate.
975      if (getType()->isBooleanType()) {
976        // Conversion to bool compares against zero.
977        Result = Result != 0;
978        Result.zextOrTrunc(DestWidth);
979      } else if (SubExpr->getType()->isSignedIntegerType())
980        Result.sextOrTrunc(DestWidth);
981      else  // If the input is unsigned, do a zero extend, noop, or truncate.
982        Result.zextOrTrunc(DestWidth);
983      break;
984    }
985
986    // Allow floating constants that are the immediate operands of casts or that
987    // are parenthesized.
988    const Expr *Operand = SubExpr;
989    while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand))
990      Operand = PE->getSubExpr();
991
992    // If this isn't a floating literal, we can't handle it.
993    const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand);
994    if (!FL) {
995      if (Loc) *Loc = Operand->getLocStart();
996      return false;
997    }
998
999    // If the destination is boolean, compare against zero.
1000    if (getType()->isBooleanType()) {
1001      Result = !FL->getValue().isZero();
1002      Result.zextOrTrunc(DestWidth);
1003      break;
1004    }
1005
1006    // Determine whether we are converting to unsigned or signed.
1007    bool DestSigned = getType()->isSignedIntegerType();
1008
1009    // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can
1010    // be called multiple times per AST.
1011    uint64_t Space[4];
1012    bool ignored;
1013    (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned,
1014                                          llvm::APFloat::rmTowardZero,
1015                                          &ignored);
1016    Result = llvm::APInt(DestWidth, 4, Space);
1017    break;
1018  }
1019  case ConditionalOperatorClass: {
1020    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1021
1022    const Expr *Cond = Exp->getCond();
1023
1024    if (!Cond->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
1025      return false;
1026
1027    const Expr *TrueExp  = Exp->getLHS();
1028    const Expr *FalseExp = Exp->getRHS();
1029    if (Result == 0) std::swap(TrueExp, FalseExp);
1030
1031    // If the condition (ignoring parens) is a __builtin_constant_p call,
1032    // then only the true side is actually considered in an integer constant
1033    // expression, and it is fully evaluated.  This is an important GNU
1034    // extension.  See GCC PR38377 for discussion.
1035    if (const CallExpr *CallCE = dyn_cast<CallExpr>(Cond->IgnoreParenCasts()))
1036      if (CallCE->isBuiltinCall() == Builtin::BI__builtin_constant_p) {
1037        EvalResult EVResult;
1038        if (!Evaluate(EVResult, Ctx) || EVResult.HasSideEffects)
1039          return false;
1040        assert(EVResult.Val.isInt() && "FP conditional expr not expected");
1041        Result = EVResult.Val.getInt();
1042        if (Loc) *Loc = EVResult.DiagLoc;
1043        return true;
1044      }
1045
1046    // Evaluate the false one first, discard the result.
1047    if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false))
1048      return false;
1049    // Evalute the true one, capture the result.
1050    if (TrueExp &&
1051        !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
1052      return false;
1053    break;
1054  }
1055  case CXXDefaultArgExprClass:
1056    return cast<CXXDefaultArgExpr>(this)
1057             ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated);
1058  }
1059
1060  // Cases that are valid constant exprs fall through to here.
1061  Result.setIsUnsigned(getType()->isUnsignedIntegerType());
1062  return true;
1063}
1064
1065/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1066/// integer constant expression with the value zero, or if this is one that is
1067/// cast to void*.
1068bool Expr::isNullPointerConstant(ASTContext &Ctx) const
1069{
1070  // Strip off a cast to void*, if it exists. Except in C++.
1071  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1072    if (!Ctx.getLangOptions().CPlusPlus) {
1073      // Check that it is a cast to void*.
1074      if (const PointerType *PT = CE->getType()->getAsPointerType()) {
1075        QualType Pointee = PT->getPointeeType();
1076        if (Pointee.getCVRQualifiers() == 0 &&
1077            Pointee->isVoidType() &&                              // to void*
1078            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1079          return CE->getSubExpr()->isNullPointerConstant(Ctx);
1080      }
1081    }
1082  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1083    // Ignore the ImplicitCastExpr type entirely.
1084    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
1085  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1086    // Accept ((void*)0) as a null pointer constant, as many other
1087    // implementations do.
1088    return PE->getSubExpr()->isNullPointerConstant(Ctx);
1089  } else if (const CXXDefaultArgExpr *DefaultArg
1090               = dyn_cast<CXXDefaultArgExpr>(this)) {
1091    // See through default argument expressions
1092    return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
1093  } else if (isa<GNUNullExpr>(this)) {
1094    // The GNU __null extension is always a null pointer constant.
1095    return true;
1096  }
1097
1098  // This expression must be an integer type.
1099  if (!getType()->isIntegerType())
1100    return false;
1101
1102  // If we have an integer constant expression, we need to *evaluate* it and
1103  // test for the value 0.
1104  // FIXME: We should probably return false if we're compiling in strict mode
1105  // and Diag is not null (this indicates that the value was foldable but not
1106  // an ICE.
1107  EvalResult Result;
1108  return Evaluate(Result, Ctx) && !Result.HasSideEffects &&
1109        Result.Val.isInt() && Result.Val.getInt() == 0;
1110}
1111
1112/// isBitField - Return true if this expression is a bit-field.
1113bool Expr::isBitField() {
1114  Expr *E = this->IgnoreParenCasts();
1115  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1116    return MemRef->getMemberDecl()->isBitField();
1117  return false;
1118}
1119
1120unsigned ExtVectorElementExpr::getNumElements() const {
1121  if (const VectorType *VT = getType()->getAsVectorType())
1122    return VT->getNumElements();
1123  return 1;
1124}
1125
1126/// containsDuplicateElements - Return true if any element access is repeated.
1127bool ExtVectorElementExpr::containsDuplicateElements() const {
1128  const char *compStr = Accessor.getName();
1129  unsigned length = Accessor.getLength();
1130
1131  for (unsigned i = 0; i != length-1; i++) {
1132    const char *s = compStr+i;
1133    for (const char c = *s++; *s; s++)
1134      if (c == *s)
1135        return true;
1136  }
1137  return false;
1138}
1139
1140/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1141void ExtVectorElementExpr::getEncodedElementAccess(
1142                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1143  bool isHi =   Accessor.isStr("hi");
1144  bool isLo =   Accessor.isStr("lo");
1145  bool isEven = Accessor.isStr("e");
1146  bool isOdd  = Accessor.isStr("o");
1147
1148  const char *compStr = Accessor.getName();
1149  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1150    uint64_t Index;
1151
1152    if (isHi)
1153      Index = e + i;
1154    else if (isLo)
1155      Index = i;
1156    else if (isEven)
1157      Index = 2 * i;
1158    else if (isOdd)
1159      Index = 2 * i + 1;
1160    else
1161      Index = ExtVectorType::getAccessorIdx(compStr[i]);
1162
1163    Elts.push_back(Index);
1164  }
1165}
1166
1167// constructor for instance messages.
1168ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
1169                QualType retType, ObjCMethodDecl *mproto,
1170                SourceLocation LBrac, SourceLocation RBrac,
1171                Expr **ArgExprs, unsigned nargs)
1172  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1173    MethodProto(mproto) {
1174  NumArgs = nargs;
1175  SubExprs = new Stmt*[NumArgs+1];
1176  SubExprs[RECEIVER] = receiver;
1177  if (NumArgs) {
1178    for (unsigned i = 0; i != NumArgs; ++i)
1179      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1180  }
1181  LBracloc = LBrac;
1182  RBracloc = RBrac;
1183}
1184
1185// constructor for class messages.
1186// FIXME: clsName should be typed to ObjCInterfaceType
1187ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
1188                QualType retType, ObjCMethodDecl *mproto,
1189                SourceLocation LBrac, SourceLocation RBrac,
1190                Expr **ArgExprs, unsigned nargs)
1191  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1192    MethodProto(mproto) {
1193  NumArgs = nargs;
1194  SubExprs = new Stmt*[NumArgs+1];
1195  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
1196  if (NumArgs) {
1197    for (unsigned i = 0; i != NumArgs; ++i)
1198      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1199  }
1200  LBracloc = LBrac;
1201  RBracloc = RBrac;
1202}
1203
1204// constructor for class messages.
1205ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1206                                 QualType retType, ObjCMethodDecl *mproto,
1207                                 SourceLocation LBrac, SourceLocation RBrac,
1208                                 Expr **ArgExprs, unsigned nargs)
1209: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1210MethodProto(mproto) {
1211  NumArgs = nargs;
1212  SubExprs = new Stmt*[NumArgs+1];
1213  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1214  if (NumArgs) {
1215    for (unsigned i = 0; i != NumArgs; ++i)
1216      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1217  }
1218  LBracloc = LBrac;
1219  RBracloc = RBrac;
1220}
1221
1222ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1223  uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1224  switch (x & Flags) {
1225    default:
1226      assert(false && "Invalid ObjCMessageExpr.");
1227    case IsInstMeth:
1228      return ClassInfo(0, 0);
1229    case IsClsMethDeclUnknown:
1230      return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1231    case IsClsMethDeclKnown: {
1232      ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1233      return ClassInfo(D, D->getIdentifier());
1234    }
1235  }
1236}
1237
1238bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1239  return getCond()->getIntegerConstantExprValue(C) != 0;
1240}
1241
1242static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) {
1243  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
1244    QualType Ty = ME->getBase()->getType();
1245
1246    RecordDecl *RD = Ty->getAsRecordType()->getDecl();
1247    const ASTRecordLayout &RL = C.getASTRecordLayout(RD);
1248    FieldDecl *FD = ME->getMemberDecl();
1249
1250    // FIXME: This is linear time. And the fact that we're indexing
1251    // into the layout by position in the record means that we're
1252    // either stuck numbering the fields in the AST or we have to keep
1253    // the linear search (yuck and yuck).
1254    unsigned i = 0;
1255    for (RecordDecl::field_iterator Field = RD->field_begin(),
1256                                 FieldEnd = RD->field_end();
1257         Field != FieldEnd; (void)++Field, ++i) {
1258      if (*Field == FD)
1259        break;
1260    }
1261
1262    return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase());
1263  } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
1264    const Expr *Base = ASE->getBase();
1265
1266    int64_t size = C.getTypeSize(ASE->getType());
1267    size *= ASE->getIdx()->getIntegerConstantExprValue(C).getSExtValue();
1268
1269    return size + evaluateOffsetOf(C, Base);
1270  } else if (isa<CompoundLiteralExpr>(E))
1271    return 0;
1272
1273  assert(0 && "Unknown offsetof subexpression!");
1274  return 0;
1275}
1276
1277int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const
1278{
1279  assert(Opc == OffsetOf && "Unary operator not offsetof!");
1280
1281  unsigned CharSize = C.Target.getCharWidth();
1282  return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize;
1283}
1284
1285void SizeOfAlignOfExpr::Destroy(ASTContext& C) {
1286  // Override default behavior of traversing children. If this has a type
1287  // operand and the type is a variable-length array, the child iteration
1288  // will iterate over the size expression. However, this expression belongs
1289  // to the type, not to this, so we don't want to delete it.
1290  // We still want to delete this expression.
1291  // FIXME: Same as in Stmt::Destroy - will be eventually in ASTContext's
1292  // pool allocator.
1293  if (isArgumentType())
1294    delete this;
1295  else
1296    Expr::Destroy(C);
1297}
1298
1299//===----------------------------------------------------------------------===//
1300//  ExprIterator.
1301//===----------------------------------------------------------------------===//
1302
1303Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
1304Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
1305Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
1306const Expr* ConstExprIterator::operator[](size_t idx) const {
1307  return cast<Expr>(I[idx]);
1308}
1309const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
1310const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
1311
1312//===----------------------------------------------------------------------===//
1313//  Child Iterators for iterating over subexpressions/substatements
1314//===----------------------------------------------------------------------===//
1315
1316// DeclRefExpr
1317Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1318Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
1319
1320// ObjCIvarRefExpr
1321Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1322Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
1323
1324// ObjCPropertyRefExpr
1325Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1326Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
1327
1328// ObjCKVCRefExpr
1329Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; }
1330Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; }
1331
1332// ObjCSuperExpr
1333Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
1334Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
1335
1336// PredefinedExpr
1337Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
1338Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
1339
1340// IntegerLiteral
1341Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1342Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
1343
1344// CharacterLiteral
1345Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); }
1346Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
1347
1348// FloatingLiteral
1349Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1350Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
1351
1352// ImaginaryLiteral
1353Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1354Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
1355
1356// StringLiteral
1357Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1358Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
1359
1360// ParenExpr
1361Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1362Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
1363
1364// UnaryOperator
1365Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1366Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
1367
1368// SizeOfAlignOfExpr
1369Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
1370  // If this is of a type and the type is a VLA type (and not a typedef), the
1371  // size expression of the VLA needs to be treated as an executable expression.
1372  // Why isn't this weirdness documented better in StmtIterator?
1373  if (isArgumentType()) {
1374    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
1375                                   getArgumentType().getTypePtr()))
1376      return child_iterator(T);
1377    return child_iterator();
1378  }
1379  return child_iterator(&Argument.Ex);
1380}
1381Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
1382  if (isArgumentType())
1383    return child_iterator();
1384  return child_iterator(&Argument.Ex + 1);
1385}
1386
1387// ArraySubscriptExpr
1388Stmt::child_iterator ArraySubscriptExpr::child_begin() {
1389  return &SubExprs[0];
1390}
1391Stmt::child_iterator ArraySubscriptExpr::child_end() {
1392  return &SubExprs[0]+END_EXPR;
1393}
1394
1395// CallExpr
1396Stmt::child_iterator CallExpr::child_begin() {
1397  return &SubExprs[0];
1398}
1399Stmt::child_iterator CallExpr::child_end() {
1400  return &SubExprs[0]+NumArgs+ARGS_START;
1401}
1402
1403// MemberExpr
1404Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1405Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
1406
1407// ExtVectorElementExpr
1408Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1409Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
1410
1411// CompoundLiteralExpr
1412Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1413Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
1414
1415// CastExpr
1416Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1417Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
1418
1419// BinaryOperator
1420Stmt::child_iterator BinaryOperator::child_begin() {
1421  return &SubExprs[0];
1422}
1423Stmt::child_iterator BinaryOperator::child_end() {
1424  return &SubExprs[0]+END_EXPR;
1425}
1426
1427// ConditionalOperator
1428Stmt::child_iterator ConditionalOperator::child_begin() {
1429  return &SubExprs[0];
1430}
1431Stmt::child_iterator ConditionalOperator::child_end() {
1432  return &SubExprs[0]+END_EXPR;
1433}
1434
1435// AddrLabelExpr
1436Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1437Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
1438
1439// StmtExpr
1440Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1441Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
1442
1443// TypesCompatibleExpr
1444Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1445  return child_iterator();
1446}
1447
1448Stmt::child_iterator TypesCompatibleExpr::child_end() {
1449  return child_iterator();
1450}
1451
1452// ChooseExpr
1453Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1454Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
1455
1456// GNUNullExpr
1457Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
1458Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
1459
1460// OverloadExpr
1461Stmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; }
1462Stmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; }
1463
1464// ShuffleVectorExpr
1465Stmt::child_iterator ShuffleVectorExpr::child_begin() {
1466  return &SubExprs[0];
1467}
1468Stmt::child_iterator ShuffleVectorExpr::child_end() {
1469  return &SubExprs[0]+NumExprs;
1470}
1471
1472// VAArgExpr
1473Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1474Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
1475
1476// InitListExpr
1477Stmt::child_iterator InitListExpr::child_begin() {
1478  return InitExprs.size() ? &InitExprs[0] : 0;
1479}
1480Stmt::child_iterator InitListExpr::child_end() {
1481  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
1482}
1483
1484// ObjCStringLiteral
1485Stmt::child_iterator ObjCStringLiteral::child_begin() {
1486  return child_iterator();
1487}
1488Stmt::child_iterator ObjCStringLiteral::child_end() {
1489  return child_iterator();
1490}
1491
1492// ObjCEncodeExpr
1493Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
1494Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
1495
1496// ObjCSelectorExpr
1497Stmt::child_iterator ObjCSelectorExpr::child_begin() {
1498  return child_iterator();
1499}
1500Stmt::child_iterator ObjCSelectorExpr::child_end() {
1501  return child_iterator();
1502}
1503
1504// ObjCProtocolExpr
1505Stmt::child_iterator ObjCProtocolExpr::child_begin() {
1506  return child_iterator();
1507}
1508Stmt::child_iterator ObjCProtocolExpr::child_end() {
1509  return child_iterator();
1510}
1511
1512// ObjCMessageExpr
1513Stmt::child_iterator ObjCMessageExpr::child_begin() {
1514  return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
1515}
1516Stmt::child_iterator ObjCMessageExpr::child_end() {
1517  return &SubExprs[0]+ARGS_START+getNumArgs();
1518}
1519
1520// Blocks
1521Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
1522Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
1523
1524Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
1525Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
1526