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