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