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