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