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