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