Expr.cpp revision 42b83dde7c700b34f9435ad746984169888ae705 
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      APValue ResultAP;
767      if (CE->Evaluate(ResultAP, Ctx)) {
768        Result = ResultAP.getInt();
769        break;  // It is a constant, expand it.
770      }
771    }
772
773    if (Loc) *Loc = getLocStart();
774    return false;
775  }
776  case DeclRefExprClass:
777    if (const EnumConstantDecl *D =
778          dyn_cast<EnumConstantDecl>(cast<DeclRefExpr>(this)->getDecl())) {
779      Result = D->getInitVal();
780      break;
781    }
782    if (Loc) *Loc = getLocStart();
783    return false;
784  case UnaryOperatorClass: {
785    const UnaryOperator *Exp = cast<UnaryOperator>(this);
786
787    // Get the operand value.  If this is offsetof, do not evalute the
788    // operand.  This affects C99 6.6p3.
789    if (!Exp->isOffsetOfOp() && !Exp->getSubExpr()->
790                        isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
791      return false;
792
793    switch (Exp->getOpcode()) {
794    // Address, indirect, pre/post inc/dec, etc are not valid constant exprs.
795    // See C99 6.6p3.
796    default:
797      if (Loc) *Loc = Exp->getOperatorLoc();
798      return false;
799    case UnaryOperator::Extension:
800      return true;  // FIXME: this is wrong.
801    case UnaryOperator::LNot: {
802      bool Val = Result == 0;
803      Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
804      Result = Val;
805      break;
806    }
807    case UnaryOperator::Plus:
808      break;
809    case UnaryOperator::Minus:
810      Result = -Result;
811      break;
812    case UnaryOperator::Not:
813      Result = ~Result;
814      break;
815    case UnaryOperator::OffsetOf:
816      Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
817      Result = Exp->evaluateOffsetOf(Ctx);
818    }
819    break;
820  }
821  case SizeOfAlignOfExprClass: {
822    const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(this);
823
824    // Return the result in the right width.
825    Result.zextOrTrunc(static_cast<uint32_t>(Ctx.getTypeSize(getType())));
826
827    QualType ArgTy = Exp->getTypeOfArgument();
828    // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
829    if (ArgTy->isVoidType()) {
830      Result = 1;
831      break;
832    }
833
834    // alignof always evaluates to a constant, sizeof does if arg is not VLA.
835    if (Exp->isSizeOf() && !ArgTy->isConstantSizeType()) {
836      if (Loc) *Loc = Exp->getOperatorLoc();
837      return false;
838    }
839
840    // Get information about the size or align.
841    if (ArgTy->isFunctionType()) {
842      // GCC extension: sizeof(function) = 1.
843      Result = Exp->isSizeOf() ? 1 : 4;
844    } else {
845      unsigned CharSize = Ctx.Target.getCharWidth();
846      if (Exp->isSizeOf())
847        Result = Ctx.getTypeSize(ArgTy) / CharSize;
848      else
849        Result = Ctx.getTypeAlign(ArgTy) / CharSize;
850    }
851    break;
852  }
853  case BinaryOperatorClass: {
854    const BinaryOperator *Exp = cast<BinaryOperator>(this);
855    llvm::APSInt LHS, RHS;
856
857    // Initialize result to have correct signedness and width.
858    Result = llvm::APSInt(static_cast<uint32_t>(Ctx.getTypeSize(getType())),
859                          !getType()->isSignedIntegerType());
860
861    // The LHS of a constant expr is always evaluated and needed.
862    if (!Exp->getLHS()->isIntegerConstantExpr(LHS, Ctx, Loc, isEvaluated))
863      return false;
864
865    // The short-circuiting &&/|| operators don't necessarily evaluate their
866    // RHS.  Make sure to pass isEvaluated down correctly.
867    if (Exp->isLogicalOp()) {
868      bool RHSEval;
869      if (Exp->getOpcode() == BinaryOperator::LAnd)
870        RHSEval = LHS != 0;
871      else {
872        assert(Exp->getOpcode() == BinaryOperator::LOr &&"Unexpected logical");
873        RHSEval = LHS == 0;
874      }
875
876      if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc,
877                                                isEvaluated & RHSEval))
878        return false;
879    } else {
880      if (!Exp->getRHS()->isIntegerConstantExpr(RHS, Ctx, Loc, isEvaluated))
881        return false;
882    }
883
884    switch (Exp->getOpcode()) {
885    default:
886      if (Loc) *Loc = getLocStart();
887      return false;
888    case BinaryOperator::Mul:
889      Result = LHS * RHS;
890      break;
891    case BinaryOperator::Div:
892      if (RHS == 0) {
893        if (!isEvaluated) break;
894        if (Loc) *Loc = getLocStart();
895        return false;
896      }
897      Result = LHS / RHS;
898      break;
899    case BinaryOperator::Rem:
900      if (RHS == 0) {
901        if (!isEvaluated) break;
902        if (Loc) *Loc = getLocStart();
903        return false;
904      }
905      Result = LHS % RHS;
906      break;
907    case BinaryOperator::Add: Result = LHS + RHS; break;
908    case BinaryOperator::Sub: Result = LHS - RHS; break;
909    case BinaryOperator::Shl:
910      Result = LHS <<
911        static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1));
912    break;
913    case BinaryOperator::Shr:
914      Result = LHS >>
915        static_cast<uint32_t>(RHS.getLimitedValue(LHS.getBitWidth()-1));
916      break;
917    case BinaryOperator::LT:  Result = LHS < RHS; break;
918    case BinaryOperator::GT:  Result = LHS > RHS; break;
919    case BinaryOperator::LE:  Result = LHS <= RHS; break;
920    case BinaryOperator::GE:  Result = LHS >= RHS; break;
921    case BinaryOperator::EQ:  Result = LHS == RHS; break;
922    case BinaryOperator::NE:  Result = LHS != RHS; break;
923    case BinaryOperator::And: Result = LHS & RHS; break;
924    case BinaryOperator::Xor: Result = LHS ^ RHS; break;
925    case BinaryOperator::Or:  Result = LHS | RHS; break;
926    case BinaryOperator::LAnd:
927      Result = LHS != 0 && RHS != 0;
928      break;
929    case BinaryOperator::LOr:
930      Result = LHS != 0 || RHS != 0;
931      break;
932
933    case BinaryOperator::Comma:
934      // C99 6.6p3: "shall not contain assignment, ..., or comma operators,
935      // *except* when they are contained within a subexpression that is not
936      // evaluated".  Note that Assignment can never happen due to constraints
937      // on the LHS subexpr, so we don't need to check it here.
938      if (isEvaluated) {
939        if (Loc) *Loc = getLocStart();
940        return false;
941      }
942
943      // The result of the constant expr is the RHS.
944      Result = RHS;
945      return true;
946    }
947
948    assert(!Exp->isAssignmentOp() && "LHS can't be a constant expr!");
949    break;
950  }
951  case ImplicitCastExprClass:
952  case CStyleCastExprClass:
953  case CXXFunctionalCastExprClass: {
954    const Expr *SubExpr = cast<CastExpr>(this)->getSubExpr();
955    SourceLocation CastLoc = getLocStart();
956
957    // C99 6.6p6: shall only convert arithmetic types to integer types.
958    if (!SubExpr->getType()->isArithmeticType() ||
959        !getType()->isIntegerType()) {
960      if (Loc) *Loc = SubExpr->getLocStart();
961      return false;
962    }
963
964    uint32_t DestWidth = static_cast<uint32_t>(Ctx.getTypeSize(getType()));
965
966    // Handle simple integer->integer casts.
967    if (SubExpr->getType()->isIntegerType()) {
968      if (!SubExpr->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
969        return false;
970
971      // Figure out if this is a truncate, extend or noop cast.
972      // If the input is signed, do a sign extend, noop, or truncate.
973      if (getType()->isBooleanType()) {
974        // Conversion to bool compares against zero.
975        Result = Result != 0;
976        Result.zextOrTrunc(DestWidth);
977      } else if (SubExpr->getType()->isSignedIntegerType())
978        Result.sextOrTrunc(DestWidth);
979      else  // If the input is unsigned, do a zero extend, noop, or truncate.
980        Result.zextOrTrunc(DestWidth);
981      break;
982    }
983
984    // Allow floating constants that are the immediate operands of casts or that
985    // are parenthesized.
986    const Expr *Operand = SubExpr;
987    while (const ParenExpr *PE = dyn_cast<ParenExpr>(Operand))
988      Operand = PE->getSubExpr();
989
990    // If this isn't a floating literal, we can't handle it.
991    const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(Operand);
992    if (!FL) {
993      if (Loc) *Loc = Operand->getLocStart();
994      return false;
995    }
996
997    // If the destination is boolean, compare against zero.
998    if (getType()->isBooleanType()) {
999      Result = !FL->getValue().isZero();
1000      Result.zextOrTrunc(DestWidth);
1001      break;
1002    }
1003
1004    // Determine whether we are converting to unsigned or signed.
1005    bool DestSigned = getType()->isSignedIntegerType();
1006
1007    // TODO: Warn on overflow, but probably not here: isIntegerConstantExpr can
1008    // be called multiple times per AST.
1009    uint64_t Space[4];
1010    bool ignored;
1011    (void)FL->getValue().convertToInteger(Space, DestWidth, DestSigned,
1012                                          llvm::APFloat::rmTowardZero,
1013                                          &ignored);
1014    Result = llvm::APInt(DestWidth, 4, Space);
1015    break;
1016  }
1017  case ConditionalOperatorClass: {
1018    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1019
1020    const Expr *Cond = Exp->getCond();
1021
1022    if (!Cond->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
1023      return false;
1024
1025    const Expr *TrueExp  = Exp->getLHS();
1026    const Expr *FalseExp = Exp->getRHS();
1027    if (Result == 0) std::swap(TrueExp, FalseExp);
1028
1029    // If the condition (ignoring parens) is a __builtin_constant_p call,
1030    // then only the true side is actually considered in an integer constant
1031    // expression, and it is fully evaluated.  This is an important GNU
1032    // extension.  See GCC PR38377 for discussion.
1033    if (const CallExpr *CallCE = dyn_cast<CallExpr>(Cond->IgnoreParenCasts()))
1034      if (CallCE->isBuiltinCall() == Builtin::BI__builtin_constant_p) {
1035        EvalResult EVResult;
1036        if (!Evaluate(EVResult, Ctx) || EVResult.HasSideEffects)
1037          return false;
1038        assert(EVResult.Val.isInt() && "FP conditional expr not expected");
1039        Result = EVResult.Val.getInt();
1040        if (Loc) *Loc = EVResult.DiagLoc;
1041        return true;
1042      }
1043
1044    // Evaluate the false one first, discard the result.
1045    if (FalseExp && !FalseExp->isIntegerConstantExpr(Result, Ctx, Loc, false))
1046      return false;
1047    // Evalute the true one, capture the result.
1048    if (TrueExp &&
1049        !TrueExp->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated))
1050      return false;
1051    break;
1052  }
1053  case CXXDefaultArgExprClass:
1054    return cast<CXXDefaultArgExpr>(this)
1055             ->isIntegerConstantExpr(Result, Ctx, Loc, isEvaluated);
1056  }
1057
1058  // Cases that are valid constant exprs fall through to here.
1059  Result.setIsUnsigned(getType()->isUnsignedIntegerType());
1060  return true;
1061}
1062
1063/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1064/// integer constant expression with the value zero, or if this is one that is
1065/// cast to void*.
1066bool Expr::isNullPointerConstant(ASTContext &Ctx) const
1067{
1068  // Strip off a cast to void*, if it exists. Except in C++.
1069  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1070    if (!Ctx.getLangOptions().CPlusPlus) {
1071      // Check that it is a cast to void*.
1072      if (const PointerType *PT = CE->getType()->getAsPointerType()) {
1073        QualType Pointee = PT->getPointeeType();
1074        if (Pointee.getCVRQualifiers() == 0 &&
1075            Pointee->isVoidType() &&                              // to void*
1076            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1077          return CE->getSubExpr()->isNullPointerConstant(Ctx);
1078      }
1079    }
1080  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1081    // Ignore the ImplicitCastExpr type entirely.
1082    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
1083  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1084    // Accept ((void*)0) as a null pointer constant, as many other
1085    // implementations do.
1086    return PE->getSubExpr()->isNullPointerConstant(Ctx);
1087  } else if (const CXXDefaultArgExpr *DefaultArg
1088               = dyn_cast<CXXDefaultArgExpr>(this)) {
1089    // See through default argument expressions
1090    return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
1091  } else if (isa<GNUNullExpr>(this)) {
1092    // The GNU __null extension is always a null pointer constant.
1093    return true;
1094  }
1095
1096  // This expression must be an integer type.
1097  if (!getType()->isIntegerType())
1098    return false;
1099
1100  // If we have an integer constant expression, we need to *evaluate* it and
1101  // test for the value 0.
1102  // FIXME: We should probably return false if we're compiling in strict mode
1103  // and Diag is not null (this indicates that the value was foldable but not
1104  // an ICE.
1105  EvalResult Result;
1106  return Evaluate(Result, Ctx) && !Result.HasSideEffects &&
1107        Result.Val.isInt() && Result.Val.getInt() == 0;
1108}
1109
1110/// isBitField - Return true if this expression is a bit-field.
1111bool Expr::isBitField() {
1112  Expr *E = this->IgnoreParenCasts();
1113  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1114    return MemRef->getMemberDecl()->isBitField();
1115  return false;
1116}
1117
1118unsigned ExtVectorElementExpr::getNumElements() const {
1119  if (const VectorType *VT = getType()->getAsVectorType())
1120    return VT->getNumElements();
1121  return 1;
1122}
1123
1124/// containsDuplicateElements - Return true if any element access is repeated.
1125bool ExtVectorElementExpr::containsDuplicateElements() const {
1126  const char *compStr = Accessor.getName();
1127  unsigned length = Accessor.getLength();
1128
1129  for (unsigned i = 0; i != length-1; i++) {
1130    const char *s = compStr+i;
1131    for (const char c = *s++; *s; s++)
1132      if (c == *s)
1133        return true;
1134  }
1135  return false;
1136}
1137
1138/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1139void ExtVectorElementExpr::getEncodedElementAccess(
1140                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1141  bool isHi =   Accessor.isStr("hi");
1142  bool isLo =   Accessor.isStr("lo");
1143  bool isEven = Accessor.isStr("e");
1144  bool isOdd  = Accessor.isStr("o");
1145
1146  const char *compStr = Accessor.getName();
1147  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1148    uint64_t Index;
1149
1150    if (isHi)
1151      Index = e + i;
1152    else if (isLo)
1153      Index = i;
1154    else if (isEven)
1155      Index = 2 * i;
1156    else if (isOdd)
1157      Index = 2 * i + 1;
1158    else
1159      Index = ExtVectorType::getAccessorIdx(compStr[i]);
1160
1161    Elts.push_back(Index);
1162  }
1163}
1164
1165// constructor for instance messages.
1166ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
1167                QualType retType, ObjCMethodDecl *mproto,
1168                SourceLocation LBrac, SourceLocation RBrac,
1169                Expr **ArgExprs, unsigned nargs)
1170  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1171    MethodProto(mproto) {
1172  NumArgs = nargs;
1173  SubExprs = new Stmt*[NumArgs+1];
1174  SubExprs[RECEIVER] = receiver;
1175  if (NumArgs) {
1176    for (unsigned i = 0; i != NumArgs; ++i)
1177      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1178  }
1179  LBracloc = LBrac;
1180  RBracloc = RBrac;
1181}
1182
1183// constructor for class messages.
1184// FIXME: clsName should be typed to ObjCInterfaceType
1185ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
1186                QualType retType, ObjCMethodDecl *mproto,
1187                SourceLocation LBrac, SourceLocation RBrac,
1188                Expr **ArgExprs, unsigned nargs)
1189  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1190    MethodProto(mproto) {
1191  NumArgs = nargs;
1192  SubExprs = new Stmt*[NumArgs+1];
1193  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
1194  if (NumArgs) {
1195    for (unsigned i = 0; i != NumArgs; ++i)
1196      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1197  }
1198  LBracloc = LBrac;
1199  RBracloc = RBrac;
1200}
1201
1202// constructor for class messages.
1203ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1204                                 QualType retType, ObjCMethodDecl *mproto,
1205                                 SourceLocation LBrac, SourceLocation RBrac,
1206                                 Expr **ArgExprs, unsigned nargs)
1207: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1208MethodProto(mproto) {
1209  NumArgs = nargs;
1210  SubExprs = new Stmt*[NumArgs+1];
1211  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1212  if (NumArgs) {
1213    for (unsigned i = 0; i != NumArgs; ++i)
1214      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1215  }
1216  LBracloc = LBrac;
1217  RBracloc = RBrac;
1218}
1219
1220ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1221  uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1222  switch (x & Flags) {
1223    default:
1224      assert(false && "Invalid ObjCMessageExpr.");
1225    case IsInstMeth:
1226      return ClassInfo(0, 0);
1227    case IsClsMethDeclUnknown:
1228      return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1229    case IsClsMethDeclKnown: {
1230      ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1231      return ClassInfo(D, D->getIdentifier());
1232    }
1233  }
1234}
1235
1236bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1237  return getCond()->getIntegerConstantExprValue(C) != 0;
1238}
1239
1240static int64_t evaluateOffsetOf(ASTContext& C, const Expr *E) {
1241  if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
1242    QualType Ty = ME->getBase()->getType();
1243
1244    RecordDecl *RD = Ty->getAsRecordType()->getDecl();
1245    const ASTRecordLayout &RL = C.getASTRecordLayout(RD);
1246    FieldDecl *FD = ME->getMemberDecl();
1247
1248    // FIXME: This is linear time. And the fact that we're indexing
1249    // into the layout by position in the record means that we're
1250    // either stuck numbering the fields in the AST or we have to keep
1251    // the linear search (yuck and yuck).
1252    unsigned i = 0;
1253    for (RecordDecl::field_iterator Field = RD->field_begin(),
1254                                 FieldEnd = RD->field_end();
1255         Field != FieldEnd; (void)++Field, ++i) {
1256      if (*Field == FD)
1257        break;
1258    }
1259
1260    return RL.getFieldOffset(i) + evaluateOffsetOf(C, ME->getBase());
1261  } else if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E)) {
1262    const Expr *Base = ASE->getBase();
1263
1264    int64_t size = C.getTypeSize(ASE->getType());
1265    size *= ASE->getIdx()->getIntegerConstantExprValue(C).getSExtValue();
1266
1267    return size + evaluateOffsetOf(C, Base);
1268  } else if (isa<CompoundLiteralExpr>(E))
1269    return 0;
1270
1271  assert(0 && "Unknown offsetof subexpression!");
1272  return 0;
1273}
1274
1275int64_t UnaryOperator::evaluateOffsetOf(ASTContext& C) const
1276{
1277  assert(Opc == OffsetOf && "Unary operator not offsetof!");
1278
1279  unsigned CharSize = C.Target.getCharWidth();
1280  return ::evaluateOffsetOf(C, cast<Expr>(Val)) / CharSize;
1281}
1282
1283void SizeOfAlignOfExpr::Destroy(ASTContext& C) {
1284  // Override default behavior of traversing children. If this has a type
1285  // operand and the type is a variable-length array, the child iteration
1286  // will iterate over the size expression. However, this expression belongs
1287  // to the type, not to this, so we don't want to delete it.
1288  // We still want to delete this expression.
1289  // FIXME: Same as in Stmt::Destroy - will be eventually in ASTContext's
1290  // pool allocator.
1291  if (isArgumentType())
1292    delete this;
1293  else
1294    Expr::Destroy(C);
1295}
1296
1297//===----------------------------------------------------------------------===//
1298//  ExprIterator.
1299//===----------------------------------------------------------------------===//
1300
1301Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
1302Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
1303Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
1304const Expr* ConstExprIterator::operator[](size_t idx) const {
1305  return cast<Expr>(I[idx]);
1306}
1307const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
1308const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
1309
1310//===----------------------------------------------------------------------===//
1311//  Child Iterators for iterating over subexpressions/substatements
1312//===----------------------------------------------------------------------===//
1313
1314// DeclRefExpr
1315Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1316Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
1317
1318// ObjCIvarRefExpr
1319Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1320Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
1321
1322// ObjCPropertyRefExpr
1323Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1324Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
1325
1326// ObjCKVCRefExpr
1327Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; }
1328Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; }
1329
1330// ObjCSuperExpr
1331Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
1332Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
1333
1334// PredefinedExpr
1335Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
1336Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
1337
1338// IntegerLiteral
1339Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1340Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
1341
1342// CharacterLiteral
1343Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator(); }
1344Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
1345
1346// FloatingLiteral
1347Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1348Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
1349
1350// ImaginaryLiteral
1351Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1352Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
1353
1354// StringLiteral
1355Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1356Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
1357
1358// ParenExpr
1359Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1360Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
1361
1362// UnaryOperator
1363Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1364Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
1365
1366// SizeOfAlignOfExpr
1367Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
1368  // If this is of a type and the type is a VLA type (and not a typedef), the
1369  // size expression of the VLA needs to be treated as an executable expression.
1370  // Why isn't this weirdness documented better in StmtIterator?
1371  if (isArgumentType()) {
1372    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
1373                                   getArgumentType().getTypePtr()))
1374      return child_iterator(T);
1375    return child_iterator();
1376  }
1377  return child_iterator(&Argument.Ex);
1378}
1379Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
1380  if (isArgumentType())
1381    return child_iterator();
1382  return child_iterator(&Argument.Ex + 1);
1383}
1384
1385// ArraySubscriptExpr
1386Stmt::child_iterator ArraySubscriptExpr::child_begin() {
1387  return &SubExprs[0];
1388}
1389Stmt::child_iterator ArraySubscriptExpr::child_end() {
1390  return &SubExprs[0]+END_EXPR;
1391}
1392
1393// CallExpr
1394Stmt::child_iterator CallExpr::child_begin() {
1395  return &SubExprs[0];
1396}
1397Stmt::child_iterator CallExpr::child_end() {
1398  return &SubExprs[0]+NumArgs+ARGS_START;
1399}
1400
1401// MemberExpr
1402Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1403Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
1404
1405// ExtVectorElementExpr
1406Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1407Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
1408
1409// CompoundLiteralExpr
1410Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1411Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
1412
1413// CastExpr
1414Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1415Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
1416
1417// BinaryOperator
1418Stmt::child_iterator BinaryOperator::child_begin() {
1419  return &SubExprs[0];
1420}
1421Stmt::child_iterator BinaryOperator::child_end() {
1422  return &SubExprs[0]+END_EXPR;
1423}
1424
1425// ConditionalOperator
1426Stmt::child_iterator ConditionalOperator::child_begin() {
1427  return &SubExprs[0];
1428}
1429Stmt::child_iterator ConditionalOperator::child_end() {
1430  return &SubExprs[0]+END_EXPR;
1431}
1432
1433// AddrLabelExpr
1434Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1435Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
1436
1437// StmtExpr
1438Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1439Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
1440
1441// TypesCompatibleExpr
1442Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1443  return child_iterator();
1444}
1445
1446Stmt::child_iterator TypesCompatibleExpr::child_end() {
1447  return child_iterator();
1448}
1449
1450// ChooseExpr
1451Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1452Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
1453
1454// GNUNullExpr
1455Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
1456Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
1457
1458// OverloadExpr
1459Stmt::child_iterator OverloadExpr::child_begin() { return &SubExprs[0]; }
1460Stmt::child_iterator OverloadExpr::child_end() { return &SubExprs[0]+NumExprs; }
1461
1462// ShuffleVectorExpr
1463Stmt::child_iterator ShuffleVectorExpr::child_begin() {
1464  return &SubExprs[0];
1465}
1466Stmt::child_iterator ShuffleVectorExpr::child_end() {
1467  return &SubExprs[0]+NumExprs;
1468}
1469
1470// VAArgExpr
1471Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1472Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
1473
1474// InitListExpr
1475Stmt::child_iterator InitListExpr::child_begin() {
1476  return InitExprs.size() ? &InitExprs[0] : 0;
1477}
1478Stmt::child_iterator InitListExpr::child_end() {
1479  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
1480}
1481
1482// ObjCStringLiteral
1483Stmt::child_iterator ObjCStringLiteral::child_begin() {
1484  return child_iterator();
1485}
1486Stmt::child_iterator ObjCStringLiteral::child_end() {
1487  return child_iterator();
1488}
1489
1490// ObjCEncodeExpr
1491Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
1492Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
1493
1494// ObjCSelectorExpr
1495Stmt::child_iterator ObjCSelectorExpr::child_begin() {
1496  return child_iterator();
1497}
1498Stmt::child_iterator ObjCSelectorExpr::child_end() {
1499  return child_iterator();
1500}
1501
1502// ObjCProtocolExpr
1503Stmt::child_iterator ObjCProtocolExpr::child_begin() {
1504  return child_iterator();
1505}
1506Stmt::child_iterator ObjCProtocolExpr::child_end() {
1507  return child_iterator();
1508}
1509
1510// ObjCMessageExpr
1511Stmt::child_iterator ObjCMessageExpr::child_begin() {
1512  return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
1513}
1514Stmt::child_iterator ObjCMessageExpr::child_end() {
1515  return &SubExprs[0]+ARGS_START+getNumArgs();
1516}
1517
1518// Blocks
1519Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
1520Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
1521
1522Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
1523Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
1524