Expr.cpp revision 2d46eb21eb2c904831b0e9f75ab3523384c70e66 
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/DeclTemplate.h"
20#include "clang/AST/RecordLayout.h"
21#include "clang/AST/StmtVisitor.h"
22#include "clang/Basic/Builtins.h"
23#include "clang/Basic/TargetInfo.h"
24#include <algorithm>
25using namespace clang;
26
27//===----------------------------------------------------------------------===//
28// Primary Expressions.
29//===----------------------------------------------------------------------===//
30
31/// getValueAsApproximateDouble - This returns the value as an inaccurate
32/// double.  Note that this may cause loss of precision, but is useful for
33/// debugging dumps, etc.
34double FloatingLiteral::getValueAsApproximateDouble() const {
35  llvm::APFloat V = getValue();
36  bool ignored;
37  V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
38            &ignored);
39  return V.convertToDouble();
40}
41
42StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
43                                     unsigned ByteLength, bool Wide,
44                                     QualType Ty,
45                                     const SourceLocation *Loc,
46                                     unsigned NumStrs) {
47  // Allocate enough space for the StringLiteral plus an array of locations for
48  // any concatenated string tokens.
49  void *Mem = C.Allocate(sizeof(StringLiteral)+
50                         sizeof(SourceLocation)*(NumStrs-1),
51                         llvm::alignof<StringLiteral>());
52  StringLiteral *SL = new (Mem) StringLiteral(Ty);
53
54  // OPTIMIZE: could allocate this appended to the StringLiteral.
55  char *AStrData = new (C, 1) char[ByteLength];
56  memcpy(AStrData, StrData, ByteLength);
57  SL->StrData = AStrData;
58  SL->ByteLength = ByteLength;
59  SL->IsWide = Wide;
60  SL->TokLocs[0] = Loc[0];
61  SL->NumConcatenated = NumStrs;
62
63  if (NumStrs != 1)
64    memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
65  return SL;
66}
67
68StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
69  void *Mem = C.Allocate(sizeof(StringLiteral)+
70                         sizeof(SourceLocation)*(NumStrs-1),
71                         llvm::alignof<StringLiteral>());
72  StringLiteral *SL = new (Mem) StringLiteral(QualType());
73  SL->StrData = 0;
74  SL->ByteLength = 0;
75  SL->NumConcatenated = NumStrs;
76  return SL;
77}
78
79void StringLiteral::DoDestroy(ASTContext &C) {
80  C.Deallocate(const_cast<char*>(StrData));
81  Expr::DoDestroy(C);
82}
83
84void StringLiteral::setStrData(ASTContext &C, const char *Str, unsigned Len) {
85  if (StrData)
86    C.Deallocate(const_cast<char*>(StrData));
87
88  char *AStrData = new (C, 1) char[Len];
89  memcpy(AStrData, Str, Len);
90  StrData = AStrData;
91  ByteLength = Len;
92}
93
94/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
95/// corresponds to, e.g. "sizeof" or "[pre]++".
96const char *UnaryOperator::getOpcodeStr(Opcode Op) {
97  switch (Op) {
98  default: assert(0 && "Unknown unary operator");
99  case PostInc: return "++";
100  case PostDec: return "--";
101  case PreInc:  return "++";
102  case PreDec:  return "--";
103  case AddrOf:  return "&";
104  case Deref:   return "*";
105  case Plus:    return "+";
106  case Minus:   return "-";
107  case Not:     return "~";
108  case LNot:    return "!";
109  case Real:    return "__real";
110  case Imag:    return "__imag";
111  case Extension: return "__extension__";
112  case OffsetOf: return "__builtin_offsetof";
113  }
114}
115
116UnaryOperator::Opcode
117UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
118  switch (OO) {
119  default: assert(false && "No unary operator for overloaded function");
120  case OO_PlusPlus:   return Postfix ? PostInc : PreInc;
121  case OO_MinusMinus: return Postfix ? PostDec : PreDec;
122  case OO_Amp:        return AddrOf;
123  case OO_Star:       return Deref;
124  case OO_Plus:       return Plus;
125  case OO_Minus:      return Minus;
126  case OO_Tilde:      return Not;
127  case OO_Exclaim:    return LNot;
128  }
129}
130
131OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
132  switch (Opc) {
133  case PostInc: case PreInc: return OO_PlusPlus;
134  case PostDec: case PreDec: return OO_MinusMinus;
135  case AddrOf: return OO_Amp;
136  case Deref: return OO_Star;
137  case Plus: return OO_Plus;
138  case Minus: return OO_Minus;
139  case Not: return OO_Tilde;
140  case LNot: return OO_Exclaim;
141  default: return OO_None;
142  }
143}
144
145
146//===----------------------------------------------------------------------===//
147// Postfix Operators.
148//===----------------------------------------------------------------------===//
149
150CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args,
151                   unsigned numargs, QualType t, SourceLocation rparenloc)
152  : Expr(SC, t,
153         fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
154         fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
155    NumArgs(numargs) {
156
157  SubExprs = new (C) Stmt*[numargs+1];
158  SubExprs[FN] = fn;
159  for (unsigned i = 0; i != numargs; ++i)
160    SubExprs[i+ARGS_START] = args[i];
161
162  RParenLoc = rparenloc;
163}
164
165CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
166                   QualType t, SourceLocation rparenloc)
167  : Expr(CallExprClass, t,
168         fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
169         fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
170    NumArgs(numargs) {
171
172  SubExprs = new (C) Stmt*[numargs+1];
173  SubExprs[FN] = fn;
174  for (unsigned i = 0; i != numargs; ++i)
175    SubExprs[i+ARGS_START] = args[i];
176
177  RParenLoc = rparenloc;
178}
179
180CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
181  : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
182  SubExprs = new (C) Stmt*[1];
183}
184
185void CallExpr::DoDestroy(ASTContext& C) {
186  DestroyChildren(C);
187  if (SubExprs) C.Deallocate(SubExprs);
188  this->~CallExpr();
189  C.Deallocate(this);
190}
191
192FunctionDecl *CallExpr::getDirectCallee() {
193  Expr *CEE = getCallee()->IgnoreParenCasts();
194  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
195    return dyn_cast<FunctionDecl>(DRE->getDecl());
196
197  return 0;
198}
199
200/// setNumArgs - This changes the number of arguments present in this call.
201/// Any orphaned expressions are deleted by this, and any new operands are set
202/// to null.
203void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
204  // No change, just return.
205  if (NumArgs == getNumArgs()) return;
206
207  // If shrinking # arguments, just delete the extras and forgot them.
208  if (NumArgs < getNumArgs()) {
209    for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i)
210      getArg(i)->Destroy(C);
211    this->NumArgs = NumArgs;
212    return;
213  }
214
215  // Otherwise, we are growing the # arguments.  New an bigger argument array.
216  Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1];
217  // Copy over args.
218  for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
219    NewSubExprs[i] = SubExprs[i];
220  // Null out new args.
221  for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
222    NewSubExprs[i] = 0;
223
224  if (SubExprs) C.Deallocate(SubExprs);
225  SubExprs = NewSubExprs;
226  this->NumArgs = NumArgs;
227}
228
229/// isBuiltinCall - If this is a call to a builtin, return the builtin ID.  If
230/// not, return 0.
231unsigned CallExpr::isBuiltinCall(ASTContext &Context) const {
232  // All simple function calls (e.g. func()) are implicitly cast to pointer to
233  // function. As a result, we try and obtain the DeclRefExpr from the
234  // ImplicitCastExpr.
235  const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
236  if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
237    return 0;
238
239  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
240  if (!DRE)
241    return 0;
242
243  const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
244  if (!FDecl)
245    return 0;
246
247  if (!FDecl->getIdentifier())
248    return 0;
249
250  return FDecl->getBuiltinID(Context);
251}
252
253QualType CallExpr::getCallReturnType() const {
254  QualType CalleeType = getCallee()->getType();
255  if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
256    CalleeType = FnTypePtr->getPointeeType();
257  else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
258    CalleeType = BPT->getPointeeType();
259
260  const FunctionType *FnType = CalleeType->getAsFunctionType();
261  return FnType->getResultType();
262}
263
264/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
265/// corresponds to, e.g. "<<=".
266const char *BinaryOperator::getOpcodeStr(Opcode Op) {
267  switch (Op) {
268  case PtrMemD:   return ".*";
269  case PtrMemI:   return "->*";
270  case Mul:       return "*";
271  case Div:       return "/";
272  case Rem:       return "%";
273  case Add:       return "+";
274  case Sub:       return "-";
275  case Shl:       return "<<";
276  case Shr:       return ">>";
277  case LT:        return "<";
278  case GT:        return ">";
279  case LE:        return "<=";
280  case GE:        return ">=";
281  case EQ:        return "==";
282  case NE:        return "!=";
283  case And:       return "&";
284  case Xor:       return "^";
285  case Or:        return "|";
286  case LAnd:      return "&&";
287  case LOr:       return "||";
288  case Assign:    return "=";
289  case MulAssign: return "*=";
290  case DivAssign: return "/=";
291  case RemAssign: return "%=";
292  case AddAssign: return "+=";
293  case SubAssign: return "-=";
294  case ShlAssign: return "<<=";
295  case ShrAssign: return ">>=";
296  case AndAssign: return "&=";
297  case XorAssign: return "^=";
298  case OrAssign:  return "|=";
299  case Comma:     return ",";
300  }
301
302  return "";
303}
304
305BinaryOperator::Opcode
306BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
307  switch (OO) {
308  default: assert(false && "Not an overloadable binary operator");
309  case OO_Plus: return Add;
310  case OO_Minus: return Sub;
311  case OO_Star: return Mul;
312  case OO_Slash: return Div;
313  case OO_Percent: return Rem;
314  case OO_Caret: return Xor;
315  case OO_Amp: return And;
316  case OO_Pipe: return Or;
317  case OO_Equal: return Assign;
318  case OO_Less: return LT;
319  case OO_Greater: return GT;
320  case OO_PlusEqual: return AddAssign;
321  case OO_MinusEqual: return SubAssign;
322  case OO_StarEqual: return MulAssign;
323  case OO_SlashEqual: return DivAssign;
324  case OO_PercentEqual: return RemAssign;
325  case OO_CaretEqual: return XorAssign;
326  case OO_AmpEqual: return AndAssign;
327  case OO_PipeEqual: return OrAssign;
328  case OO_LessLess: return Shl;
329  case OO_GreaterGreater: return Shr;
330  case OO_LessLessEqual: return ShlAssign;
331  case OO_GreaterGreaterEqual: return ShrAssign;
332  case OO_EqualEqual: return EQ;
333  case OO_ExclaimEqual: return NE;
334  case OO_LessEqual: return LE;
335  case OO_GreaterEqual: return GE;
336  case OO_AmpAmp: return LAnd;
337  case OO_PipePipe: return LOr;
338  case OO_Comma: return Comma;
339  case OO_ArrowStar: return PtrMemI;
340  }
341}
342
343OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
344  static const OverloadedOperatorKind OverOps[] = {
345    /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
346    OO_Star, OO_Slash, OO_Percent,
347    OO_Plus, OO_Minus,
348    OO_LessLess, OO_GreaterGreater,
349    OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
350    OO_EqualEqual, OO_ExclaimEqual,
351    OO_Amp,
352    OO_Caret,
353    OO_Pipe,
354    OO_AmpAmp,
355    OO_PipePipe,
356    OO_Equal, OO_StarEqual,
357    OO_SlashEqual, OO_PercentEqual,
358    OO_PlusEqual, OO_MinusEqual,
359    OO_LessLessEqual, OO_GreaterGreaterEqual,
360    OO_AmpEqual, OO_CaretEqual,
361    OO_PipeEqual,
362    OO_Comma
363  };
364  return OverOps[Opc];
365}
366
367InitListExpr::InitListExpr(SourceLocation lbraceloc,
368                           Expr **initExprs, unsigned numInits,
369                           SourceLocation rbraceloc)
370  : Expr(InitListExprClass, QualType(),
371         hasAnyTypeDependentArguments(initExprs, numInits),
372         hasAnyValueDependentArguments(initExprs, numInits)),
373    LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
374    UnionFieldInit(0), HadArrayRangeDesignator(false) {
375
376  InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits);
377}
378
379void InitListExpr::reserveInits(unsigned NumInits) {
380  if (NumInits > InitExprs.size())
381    InitExprs.reserve(NumInits);
382}
383
384void InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) {
385  for (unsigned Idx = NumInits, LastIdx = InitExprs.size();
386       Idx < LastIdx; ++Idx)
387    InitExprs[Idx]->Destroy(Context);
388  InitExprs.resize(NumInits, 0);
389}
390
391Expr *InitListExpr::updateInit(unsigned Init, Expr *expr) {
392  if (Init >= InitExprs.size()) {
393    InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0);
394    InitExprs.back() = expr;
395    return 0;
396  }
397
398  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
399  InitExprs[Init] = expr;
400  return Result;
401}
402
403/// getFunctionType - Return the underlying function type for this block.
404///
405const FunctionType *BlockExpr::getFunctionType() const {
406  return getType()->getAs<BlockPointerType>()->
407                    getPointeeType()->getAsFunctionType();
408}
409
410SourceLocation BlockExpr::getCaretLocation() const {
411  return TheBlock->getCaretLocation();
412}
413const Stmt *BlockExpr::getBody() const {
414  return TheBlock->getBody();
415}
416Stmt *BlockExpr::getBody() {
417  return TheBlock->getBody();
418}
419
420
421//===----------------------------------------------------------------------===//
422// Generic Expression Routines
423//===----------------------------------------------------------------------===//
424
425/// isUnusedResultAWarning - Return true if this immediate expression should
426/// be warned about if the result is unused.  If so, fill in Loc and Ranges
427/// with location to warn on and the source range[s] to report with the
428/// warning.
429bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
430                                  SourceRange &R2) const {
431  // Don't warn if the expr is type dependent. The type could end up
432  // instantiating to void.
433  if (isTypeDependent())
434    return false;
435
436  switch (getStmtClass()) {
437  default:
438    Loc = getExprLoc();
439    R1 = getSourceRange();
440    return true;
441  case ParenExprClass:
442    return cast<ParenExpr>(this)->getSubExpr()->
443      isUnusedResultAWarning(Loc, R1, R2);
444  case UnaryOperatorClass: {
445    const UnaryOperator *UO = cast<UnaryOperator>(this);
446
447    switch (UO->getOpcode()) {
448    default: break;
449    case UnaryOperator::PostInc:
450    case UnaryOperator::PostDec:
451    case UnaryOperator::PreInc:
452    case UnaryOperator::PreDec:                 // ++/--
453      return false;  // Not a warning.
454    case UnaryOperator::Deref:
455      // Dereferencing a volatile pointer is a side-effect.
456      if (getType().isVolatileQualified())
457        return false;
458      break;
459    case UnaryOperator::Real:
460    case UnaryOperator::Imag:
461      // accessing a piece of a volatile complex is a side-effect.
462      if (UO->getSubExpr()->getType().isVolatileQualified())
463        return false;
464      break;
465    case UnaryOperator::Extension:
466      return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2);
467    }
468    Loc = UO->getOperatorLoc();
469    R1 = UO->getSubExpr()->getSourceRange();
470    return true;
471  }
472  case BinaryOperatorClass: {
473    const BinaryOperator *BO = cast<BinaryOperator>(this);
474    // Consider comma to have side effects if the LHS or RHS does.
475    if (BO->getOpcode() == BinaryOperator::Comma)
476      return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2) ||
477             BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2);
478
479    if (BO->isAssignmentOp())
480      return false;
481    Loc = BO->getOperatorLoc();
482    R1 = BO->getLHS()->getSourceRange();
483    R2 = BO->getRHS()->getSourceRange();
484    return true;
485  }
486  case CompoundAssignOperatorClass:
487    return false;
488
489  case ConditionalOperatorClass: {
490    // The condition must be evaluated, but if either the LHS or RHS is a
491    // warning, warn about them.
492    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
493    if (Exp->getLHS() &&
494        Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2))
495      return true;
496    return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2);
497  }
498
499  case MemberExprClass:
500    // If the base pointer or element is to a volatile pointer/field, accessing
501    // it is a side effect.
502    if (getType().isVolatileQualified())
503      return false;
504    Loc = cast<MemberExpr>(this)->getMemberLoc();
505    R1 = SourceRange(Loc, Loc);
506    R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
507    return true;
508
509  case ArraySubscriptExprClass:
510    // If the base pointer or element is to a volatile pointer/field, accessing
511    // it is a side effect.
512    if (getType().isVolatileQualified())
513      return false;
514    Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
515    R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
516    R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
517    return true;
518
519  case CallExprClass:
520  case CXXOperatorCallExprClass:
521  case CXXMemberCallExprClass: {
522    // If this is a direct call, get the callee.
523    const CallExpr *CE = cast<CallExpr>(this);
524    const Expr *CalleeExpr = CE->getCallee()->IgnoreParenCasts();
525    if (const DeclRefExpr *CalleeDRE = dyn_cast<DeclRefExpr>(CalleeExpr)) {
526      // If the callee has attribute pure, const, or warn_unused_result, warn
527      // about it. void foo() { strlen("bar"); } should warn.
528      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CalleeDRE->getDecl()))
529        if (FD->getAttr<WarnUnusedResultAttr>() ||
530            FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
531          Loc = CE->getCallee()->getLocStart();
532          R1 = CE->getCallee()->getSourceRange();
533
534          if (unsigned NumArgs = CE->getNumArgs())
535            R2 = SourceRange(CE->getArg(0)->getLocStart(),
536                             CE->getArg(NumArgs-1)->getLocEnd());
537          return true;
538        }
539    }
540    return false;
541  }
542  case ObjCMessageExprClass:
543    return false;
544  case StmtExprClass: {
545    // Statement exprs don't logically have side effects themselves, but are
546    // sometimes used in macros in ways that give them a type that is unused.
547    // For example ({ blah; foo(); }) will end up with a type if foo has a type.
548    // however, if the result of the stmt expr is dead, we don't want to emit a
549    // warning.
550    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
551    if (!CS->body_empty())
552      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
553        return E->isUnusedResultAWarning(Loc, R1, R2);
554
555    Loc = cast<StmtExpr>(this)->getLParenLoc();
556    R1 = getSourceRange();
557    return true;
558  }
559  case CStyleCastExprClass:
560    // If this is an explicit cast to void, allow it.  People do this when they
561    // think they know what they're doing :).
562    if (getType()->isVoidType())
563      return false;
564    Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
565    R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
566    return true;
567  case CXXFunctionalCastExprClass:
568    // If this is a cast to void, check the operand.  Otherwise, the result of
569    // the cast is unused.
570    if (getType()->isVoidType())
571      return cast<CastExpr>(this)->getSubExpr()
572               ->isUnusedResultAWarning(Loc, R1, R2);
573    Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
574    R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
575    return true;
576
577  case ImplicitCastExprClass:
578    // Check the operand, since implicit casts are inserted by Sema
579    return cast<ImplicitCastExpr>(this)
580      ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2);
581
582  case CXXDefaultArgExprClass:
583    return cast<CXXDefaultArgExpr>(this)
584      ->getExpr()->isUnusedResultAWarning(Loc, R1, R2);
585
586  case CXXNewExprClass:
587    // FIXME: In theory, there might be new expressions that don't have side
588    // effects (e.g. a placement new with an uninitialized POD).
589  case CXXDeleteExprClass:
590    return false;
591  case CXXBindTemporaryExprClass:
592    return cast<CXXBindTemporaryExpr>(this)
593      ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2);
594  case CXXExprWithTemporariesClass:
595    return cast<CXXExprWithTemporaries>(this)
596      ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2);
597  }
598}
599
600/// DeclCanBeLvalue - Determine whether the given declaration can be
601/// an lvalue. This is a helper routine for isLvalue.
602static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) {
603  // C++ [temp.param]p6:
604  //   A non-type non-reference template-parameter is not an lvalue.
605  if (const NonTypeTemplateParmDecl *NTTParm
606        = dyn_cast<NonTypeTemplateParmDecl>(Decl))
607    return NTTParm->getType()->isReferenceType();
608
609  return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) ||
610    // C++ 3.10p2: An lvalue refers to an object or function.
611    (Ctx.getLangOptions().CPlusPlus &&
612     (isa<FunctionDecl>(Decl) || isa<OverloadedFunctionDecl>(Decl) ||
613      isa<FunctionTemplateDecl>(Decl)));
614}
615
616/// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
617/// incomplete type other than void. Nonarray expressions that can be lvalues:
618///  - name, where name must be a variable
619///  - e[i]
620///  - (e), where e must be an lvalue
621///  - e.name, where e must be an lvalue
622///  - e->name
623///  - *e, the type of e cannot be a function type
624///  - string-constant
625///  - (__real__ e) and (__imag__ e) where e is an lvalue  [GNU extension]
626///  - reference type [C++ [expr]]
627///
628Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const {
629  assert(!TR->isReferenceType() && "Expressions can't have reference type.");
630
631  isLvalueResult Res = isLvalueInternal(Ctx);
632  if (Res != LV_Valid || Ctx.getLangOptions().CPlusPlus)
633    return Res;
634
635  // first, check the type (C99 6.3.2.1). Expressions with function
636  // type in C are not lvalues, but they can be lvalues in C++.
637  if (TR->isFunctionType() || TR == Ctx.OverloadTy)
638    return LV_NotObjectType;
639
640  // Allow qualified void which is an incomplete type other than void (yuck).
641  if (TR->isVoidType() && !Ctx.getCanonicalType(TR).getCVRQualifiers())
642    return LV_IncompleteVoidType;
643
644  return LV_Valid;
645}
646
647// Check whether the expression can be sanely treated like an l-value
648Expr::isLvalueResult Expr::isLvalueInternal(ASTContext &Ctx) const {
649  switch (getStmtClass()) {
650  case StringLiteralClass:  // C99 6.5.1p4
651  case ObjCEncodeExprClass: // @encode behaves like its string in every way.
652    return LV_Valid;
653  case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
654    // For vectors, make sure base is an lvalue (i.e. not a function call).
655    if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
656      return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx);
657    return LV_Valid;
658  case DeclRefExprClass:
659  case QualifiedDeclRefExprClass: { // C99 6.5.1p2
660    const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
661    if (DeclCanBeLvalue(RefdDecl, Ctx))
662      return LV_Valid;
663    break;
664  }
665  case BlockDeclRefExprClass: {
666    const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
667    if (isa<VarDecl>(BDR->getDecl()))
668      return LV_Valid;
669    break;
670  }
671  case MemberExprClass: {
672    const MemberExpr *m = cast<MemberExpr>(this);
673    if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4:
674      NamedDecl *Member = m->getMemberDecl();
675      // C++ [expr.ref]p4:
676      //   If E2 is declared to have type "reference to T", then E1.E2
677      //   is an lvalue.
678      if (ValueDecl *Value = dyn_cast<ValueDecl>(Member))
679        if (Value->getType()->isReferenceType())
680          return LV_Valid;
681
682      //   -- If E2 is a static data member [...] then E1.E2 is an lvalue.
683      if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord())
684        return LV_Valid;
685
686      //   -- If E2 is a non-static data member [...]. If E1 is an
687      //      lvalue, then E1.E2 is an lvalue.
688      if (isa<FieldDecl>(Member))
689        return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx);
690
691      //   -- If it refers to a static member function [...], then
692      //      E1.E2 is an lvalue.
693      //   -- Otherwise, if E1.E2 refers to a non-static member
694      //      function [...], then E1.E2 is not an lvalue.
695      if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member))
696        return Method->isStatic()? LV_Valid : LV_MemberFunction;
697
698      //   -- If E2 is a member enumerator [...], the expression E1.E2
699      //      is not an lvalue.
700      if (isa<EnumConstantDecl>(Member))
701        return LV_InvalidExpression;
702
703        // Not an lvalue.
704      return LV_InvalidExpression;
705    }
706
707    // C99 6.5.2.3p4
708    return m->isArrow() ? LV_Valid : m->getBase()->isLvalue(Ctx);
709  }
710  case UnaryOperatorClass:
711    if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref)
712      return LV_Valid; // C99 6.5.3p4
713
714    if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real ||
715        cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag ||
716        cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension)
717      return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx);  // GNU.
718
719    if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1
720        (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc ||
721         cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec))
722      return LV_Valid;
723    break;
724  case ImplicitCastExprClass:
725    return cast<ImplicitCastExpr>(this)->isLvalueCast()? LV_Valid
726                                                       : LV_InvalidExpression;
727  case ParenExprClass: // C99 6.5.1p5
728    return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx);
729  case BinaryOperatorClass:
730  case CompoundAssignOperatorClass: {
731    const BinaryOperator *BinOp = cast<BinaryOperator>(this);
732
733    if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1
734        BinOp->getOpcode() == BinaryOperator::Comma)
735      return BinOp->getRHS()->isLvalue(Ctx);
736
737    // C++ [expr.mptr.oper]p6
738    if ((BinOp->getOpcode() == BinaryOperator::PtrMemD ||
739         BinOp->getOpcode() == BinaryOperator::PtrMemI) &&
740        !BinOp->getType()->isFunctionType())
741      return BinOp->getLHS()->isLvalue(Ctx);
742
743    if (!BinOp->isAssignmentOp())
744      return LV_InvalidExpression;
745
746    if (Ctx.getLangOptions().CPlusPlus)
747      // C++ [expr.ass]p1:
748      //   The result of an assignment operation [...] is an lvalue.
749      return LV_Valid;
750
751
752    // C99 6.5.16:
753    //   An assignment expression [...] is not an lvalue.
754    return LV_InvalidExpression;
755  }
756  case CallExprClass:
757  case CXXOperatorCallExprClass:
758  case CXXMemberCallExprClass: {
759    // C++0x [expr.call]p10
760    //   A function call is an lvalue if and only if the result type
761    //   is an lvalue reference.
762    QualType ReturnType = cast<CallExpr>(this)->getCallReturnType();
763    if (ReturnType->isLValueReferenceType())
764      return LV_Valid;
765
766    break;
767  }
768  case CompoundLiteralExprClass: // C99 6.5.2.5p5
769    return LV_Valid;
770  case ChooseExprClass:
771    // __builtin_choose_expr is an lvalue if the selected operand is.
772    return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx);
773  case ExtVectorElementExprClass:
774    if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements())
775      return LV_DuplicateVectorComponents;
776    return LV_Valid;
777  case ObjCIvarRefExprClass: // ObjC instance variables are lvalues.
778    return LV_Valid;
779  case ObjCPropertyRefExprClass: // FIXME: check if read-only property.
780    return LV_Valid;
781  case ObjCKVCRefExprClass: // FIXME: check if read-only property.
782    return LV_Valid;
783  case PredefinedExprClass:
784    return LV_Valid;
785  case CXXDefaultArgExprClass:
786    return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx);
787  case CXXConditionDeclExprClass:
788    return LV_Valid;
789  case CStyleCastExprClass:
790  case CXXFunctionalCastExprClass:
791  case CXXStaticCastExprClass:
792  case CXXDynamicCastExprClass:
793  case CXXReinterpretCastExprClass:
794  case CXXConstCastExprClass:
795    // The result of an explicit cast is an lvalue if the type we are
796    // casting to is an lvalue reference type. See C++ [expr.cast]p1,
797    // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2,
798    // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1.
799    if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->
800          isLValueReferenceType())
801      return LV_Valid;
802    break;
803  case CXXTypeidExprClass:
804    // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ...
805    return LV_Valid;
806  case CXXBindTemporaryExprClass:
807    return cast<CXXBindTemporaryExpr>(this)->getSubExpr()->
808      isLvalueInternal(Ctx);
809  case ConditionalOperatorClass: {
810    // Complicated handling is only for C++.
811    if (!Ctx.getLangOptions().CPlusPlus)
812      return LV_InvalidExpression;
813
814    // Sema should have taken care to ensure that a CXXTemporaryObjectExpr is
815    // everywhere there's an object converted to an rvalue. Also, any other
816    // casts should be wrapped by ImplicitCastExprs. There's just the special
817    // case involving throws to work out.
818    const ConditionalOperator *Cond = cast<ConditionalOperator>(this);
819    Expr *True = Cond->getTrueExpr();
820    Expr *False = Cond->getFalseExpr();
821    // C++0x 5.16p2
822    //   If either the second or the third operand has type (cv) void, [...]
823    //   the result [...] is an rvalue.
824    if (True->getType()->isVoidType() || False->getType()->isVoidType())
825      return LV_InvalidExpression;
826
827    // Both sides must be lvalues for the result to be an lvalue.
828    if (True->isLvalue(Ctx) != LV_Valid || False->isLvalue(Ctx) != LV_Valid)
829      return LV_InvalidExpression;
830
831    // That's it.
832    return LV_Valid;
833  }
834
835  default:
836    break;
837  }
838  return LV_InvalidExpression;
839}
840
841/// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
842/// does not have an incomplete type, does not have a const-qualified type, and
843/// if it is a structure or union, does not have any member (including,
844/// recursively, any member or element of all contained aggregates or unions)
845/// with a const-qualified type.
846Expr::isModifiableLvalueResult
847Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const {
848  isLvalueResult lvalResult = isLvalue(Ctx);
849
850  switch (lvalResult) {
851  case LV_Valid:
852    // C++ 3.10p11: Functions cannot be modified, but pointers to
853    // functions can be modifiable.
854    if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
855      return MLV_NotObjectType;
856    break;
857
858  case LV_NotObjectType: return MLV_NotObjectType;
859  case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
860  case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
861  case LV_InvalidExpression:
862    // If the top level is a C-style cast, and the subexpression is a valid
863    // lvalue, then this is probably a use of the old-school "cast as lvalue"
864    // GCC extension.  We don't support it, but we want to produce good
865    // diagnostics when it happens so that the user knows why.
866    if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) {
867      if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) {
868        if (Loc)
869          *Loc = CE->getLParenLoc();
870        return MLV_LValueCast;
871      }
872    }
873    return MLV_InvalidExpression;
874  case LV_MemberFunction: return MLV_MemberFunction;
875  }
876
877  // The following is illegal:
878  //   void takeclosure(void (^C)(void));
879  //   void func() { int x = 1; takeclosure(^{ x = 7; }); }
880  //
881  if (isa<BlockDeclRefExpr>(this)) {
882    const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
883    if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl()))
884      return MLV_NotBlockQualified;
885  }
886
887  QualType CT = Ctx.getCanonicalType(getType());
888
889  if (CT.isConstQualified())
890    return MLV_ConstQualified;
891  if (CT->isArrayType())
892    return MLV_ArrayType;
893  if (CT->isIncompleteType())
894    return MLV_IncompleteType;
895
896  if (const RecordType *r = CT->getAs<RecordType>()) {
897    if (r->hasConstFields())
898      return MLV_ConstQualified;
899  }
900
901  // Assigning to an 'implicit' property?
902  else if (isa<ObjCKVCRefExpr>(this)) {
903    const ObjCKVCRefExpr* KVCExpr = cast<ObjCKVCRefExpr>(this);
904    if (KVCExpr->getSetterMethod() == 0)
905      return MLV_NoSetterProperty;
906  }
907  return MLV_Valid;
908}
909
910/// hasGlobalStorage - Return true if this expression has static storage
911/// duration.  This means that the address of this expression is a link-time
912/// constant.
913bool Expr::hasGlobalStorage() const {
914  switch (getStmtClass()) {
915  default:
916    return false;
917  case BlockExprClass:
918    return true;
919  case ParenExprClass:
920    return cast<ParenExpr>(this)->getSubExpr()->hasGlobalStorage();
921  case ImplicitCastExprClass:
922    return cast<ImplicitCastExpr>(this)->getSubExpr()->hasGlobalStorage();
923  case CompoundLiteralExprClass:
924    return cast<CompoundLiteralExpr>(this)->isFileScope();
925  case DeclRefExprClass:
926  case QualifiedDeclRefExprClass: {
927    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
928    if (const VarDecl *VD = dyn_cast<VarDecl>(D))
929      return VD->hasGlobalStorage();
930    if (isa<FunctionDecl>(D))
931      return true;
932    return false;
933  }
934  case MemberExprClass: {
935    const MemberExpr *M = cast<MemberExpr>(this);
936    return !M->isArrow() && M->getBase()->hasGlobalStorage();
937  }
938  case ArraySubscriptExprClass:
939    return cast<ArraySubscriptExpr>(this)->getBase()->hasGlobalStorage();
940  case PredefinedExprClass:
941    return true;
942  case CXXDefaultArgExprClass:
943    return cast<CXXDefaultArgExpr>(this)->getExpr()->hasGlobalStorage();
944  }
945}
946
947/// isOBJCGCCandidate - Check if an expression is objc gc'able.
948///
949bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
950  switch (getStmtClass()) {
951  default:
952    return false;
953  case ObjCIvarRefExprClass:
954    return true;
955  case Expr::UnaryOperatorClass:
956    return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
957  case ParenExprClass:
958    return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
959  case ImplicitCastExprClass:
960    return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
961  case CStyleCastExprClass:
962    return cast<CStyleCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
963  case DeclRefExprClass:
964  case QualifiedDeclRefExprClass: {
965    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
966    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
967      if (VD->hasGlobalStorage())
968        return true;
969      QualType T = VD->getType();
970      // dereferencing to an object pointer is always a gc'able candidate
971      if (T->isPointerType() &&
972          T->getAs<PointerType>()->getPointeeType()->isObjCObjectPointerType())
973        return true;
974
975    }
976    return false;
977  }
978  case MemberExprClass: {
979    const MemberExpr *M = cast<MemberExpr>(this);
980    return M->getBase()->isOBJCGCCandidate(Ctx);
981  }
982  case ArraySubscriptExprClass:
983    return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(Ctx);
984  }
985}
986Expr* Expr::IgnoreParens() {
987  Expr* E = this;
988  while (ParenExpr* P = dyn_cast<ParenExpr>(E))
989    E = P->getSubExpr();
990
991  return E;
992}
993
994/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
995/// or CastExprs or ImplicitCastExprs, returning their operand.
996Expr *Expr::IgnoreParenCasts() {
997  Expr *E = this;
998  while (true) {
999    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
1000      E = P->getSubExpr();
1001    else if (CastExpr *P = dyn_cast<CastExpr>(E))
1002      E = P->getSubExpr();
1003    else
1004      return E;
1005  }
1006}
1007
1008/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
1009/// value (including ptr->int casts of the same size).  Strip off any
1010/// ParenExpr or CastExprs, returning their operand.
1011Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
1012  Expr *E = this;
1013  while (true) {
1014    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1015      E = P->getSubExpr();
1016      continue;
1017    }
1018
1019    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1020      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
1021      // ptr<->int casts of the same width.  We also ignore all identify casts.
1022      Expr *SE = P->getSubExpr();
1023
1024      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
1025        E = SE;
1026        continue;
1027      }
1028
1029      if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) &&
1030          (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) &&
1031          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
1032        E = SE;
1033        continue;
1034      }
1035    }
1036
1037    return E;
1038  }
1039}
1040
1041
1042/// hasAnyTypeDependentArguments - Determines if any of the expressions
1043/// in Exprs is type-dependent.
1044bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
1045  for (unsigned I = 0; I < NumExprs; ++I)
1046    if (Exprs[I]->isTypeDependent())
1047      return true;
1048
1049  return false;
1050}
1051
1052/// hasAnyValueDependentArguments - Determines if any of the expressions
1053/// in Exprs is value-dependent.
1054bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
1055  for (unsigned I = 0; I < NumExprs; ++I)
1056    if (Exprs[I]->isValueDependent())
1057      return true;
1058
1059  return false;
1060}
1061
1062bool Expr::isConstantInitializer(ASTContext &Ctx) const {
1063  // This function is attempting whether an expression is an initializer
1064  // which can be evaluated at compile-time.  isEvaluatable handles most
1065  // of the cases, but it can't deal with some initializer-specific
1066  // expressions, and it can't deal with aggregates; we deal with those here,
1067  // and fall back to isEvaluatable for the other cases.
1068
1069  // FIXME: This function assumes the variable being assigned to
1070  // isn't a reference type!
1071
1072  switch (getStmtClass()) {
1073  default: break;
1074  case StringLiteralClass:
1075  case ObjCStringLiteralClass:
1076  case ObjCEncodeExprClass:
1077    return true;
1078  case CompoundLiteralExprClass: {
1079    // This handles gcc's extension that allows global initializers like
1080    // "struct x {int x;} x = (struct x) {};".
1081    // FIXME: This accepts other cases it shouldn't!
1082    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
1083    return Exp->isConstantInitializer(Ctx);
1084  }
1085  case InitListExprClass: {
1086    // FIXME: This doesn't deal with fields with reference types correctly.
1087    // FIXME: This incorrectly allows pointers cast to integers to be assigned
1088    // to bitfields.
1089    const InitListExpr *Exp = cast<InitListExpr>(this);
1090    unsigned numInits = Exp->getNumInits();
1091    for (unsigned i = 0; i < numInits; i++) {
1092      if (!Exp->getInit(i)->isConstantInitializer(Ctx))
1093        return false;
1094    }
1095    return true;
1096  }
1097  case ImplicitValueInitExprClass:
1098    return true;
1099  case ParenExprClass: {
1100    return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1101  }
1102  case UnaryOperatorClass: {
1103    const UnaryOperator* Exp = cast<UnaryOperator>(this);
1104    if (Exp->getOpcode() == UnaryOperator::Extension)
1105      return Exp->getSubExpr()->isConstantInitializer(Ctx);
1106    break;
1107  }
1108  case ImplicitCastExprClass:
1109  case CStyleCastExprClass:
1110    // Handle casts with a destination that's a struct or union; this
1111    // deals with both the gcc no-op struct cast extension and the
1112    // cast-to-union extension.
1113    if (getType()->isRecordType())
1114      return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1115    break;
1116  }
1117  return isEvaluatable(Ctx);
1118}
1119
1120/// isIntegerConstantExpr - this recursive routine will test if an expression is
1121/// an integer constant expression.
1122
1123/// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
1124/// comma, etc
1125///
1126/// FIXME: Handle offsetof.  Two things to do:  Handle GCC's __builtin_offsetof
1127/// to support gcc 4.0+  and handle the idiom GCC recognizes with a null pointer
1128/// cast+dereference.
1129
1130// CheckICE - This function does the fundamental ICE checking: the returned
1131// ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation.
1132// Note that to reduce code duplication, this helper does no evaluation
1133// itself; the caller checks whether the expression is evaluatable, and
1134// in the rare cases where CheckICE actually cares about the evaluated
1135// value, it calls into Evalute.
1136//
1137// Meanings of Val:
1138// 0: This expression is an ICE if it can be evaluated by Evaluate.
1139// 1: This expression is not an ICE, but if it isn't evaluated, it's
1140//    a legal subexpression for an ICE. This return value is used to handle
1141//    the comma operator in C99 mode.
1142// 2: This expression is not an ICE, and is not a legal subexpression for one.
1143
1144struct ICEDiag {
1145  unsigned Val;
1146  SourceLocation Loc;
1147
1148  public:
1149  ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {}
1150  ICEDiag() : Val(0) {}
1151};
1152
1153ICEDiag NoDiag() { return ICEDiag(); }
1154
1155static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) {
1156  Expr::EvalResult EVResult;
1157  if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1158      !EVResult.Val.isInt()) {
1159    return ICEDiag(2, E->getLocStart());
1160  }
1161  return NoDiag();
1162}
1163
1164static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
1165  assert(!E->isValueDependent() && "Should not see value dependent exprs!");
1166  if (!E->getType()->isIntegralType()) {
1167    return ICEDiag(2, E->getLocStart());
1168  }
1169
1170  switch (E->getStmtClass()) {
1171  default:
1172    return ICEDiag(2, E->getLocStart());
1173  case Expr::ParenExprClass:
1174    return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
1175  case Expr::IntegerLiteralClass:
1176  case Expr::CharacterLiteralClass:
1177  case Expr::CXXBoolLiteralExprClass:
1178  case Expr::CXXZeroInitValueExprClass:
1179  case Expr::TypesCompatibleExprClass:
1180  case Expr::UnaryTypeTraitExprClass:
1181    return NoDiag();
1182  case Expr::CallExprClass:
1183  case Expr::CXXOperatorCallExprClass: {
1184    const CallExpr *CE = cast<CallExpr>(E);
1185    if (CE->isBuiltinCall(Ctx))
1186      return CheckEvalInICE(E, Ctx);
1187    return ICEDiag(2, E->getLocStart());
1188  }
1189  case Expr::DeclRefExprClass:
1190  case Expr::QualifiedDeclRefExprClass:
1191    if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
1192      return NoDiag();
1193    if (Ctx.getLangOptions().CPlusPlus &&
1194        E->getType().getCVRQualifiers() == QualType::Const) {
1195      // C++ 7.1.5.1p2
1196      //   A variable of non-volatile const-qualified integral or enumeration
1197      //   type initialized by an ICE can be used in ICEs.
1198      if (const VarDecl *Dcl =
1199              dyn_cast<VarDecl>(cast<DeclRefExpr>(E)->getDecl())) {
1200        if (Dcl->isInitKnownICE()) {
1201          // We have already checked whether this subexpression is an
1202          // integral constant expression.
1203          if (Dcl->isInitICE())
1204            return NoDiag();
1205          else
1206            return ICEDiag(2, E->getLocStart());
1207        }
1208
1209        if (const Expr *Init = Dcl->getInit()) {
1210          ICEDiag Result = CheckICE(Init, Ctx);
1211          // Cache the result of the ICE test.
1212          Dcl->setInitKnownICE(Ctx, Result.Val == 0);
1213          return Result;
1214        }
1215      }
1216    }
1217    return ICEDiag(2, E->getLocStart());
1218  case Expr::UnaryOperatorClass: {
1219    const UnaryOperator *Exp = cast<UnaryOperator>(E);
1220    switch (Exp->getOpcode()) {
1221    default:
1222      return ICEDiag(2, E->getLocStart());
1223    case UnaryOperator::Extension:
1224    case UnaryOperator::LNot:
1225    case UnaryOperator::Plus:
1226    case UnaryOperator::Minus:
1227    case UnaryOperator::Not:
1228    case UnaryOperator::Real:
1229    case UnaryOperator::Imag:
1230      return CheckICE(Exp->getSubExpr(), Ctx);
1231    case UnaryOperator::OffsetOf:
1232      // Note that per C99, offsetof must be an ICE. And AFAIK, using
1233      // Evaluate matches the proposed gcc behavior for cases like
1234      // "offsetof(struct s{int x[4];}, x[!.0])".  This doesn't affect
1235      // compliance: we should warn earlier for offsetof expressions with
1236      // array subscripts that aren't ICEs, and if the array subscripts
1237      // are ICEs, the value of the offsetof must be an integer constant.
1238      return CheckEvalInICE(E, Ctx);
1239    }
1240  }
1241  case Expr::SizeOfAlignOfExprClass: {
1242    const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E);
1243    if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType())
1244      return ICEDiag(2, E->getLocStart());
1245    return NoDiag();
1246  }
1247  case Expr::BinaryOperatorClass: {
1248    const BinaryOperator *Exp = cast<BinaryOperator>(E);
1249    switch (Exp->getOpcode()) {
1250    default:
1251      return ICEDiag(2, E->getLocStart());
1252    case BinaryOperator::Mul:
1253    case BinaryOperator::Div:
1254    case BinaryOperator::Rem:
1255    case BinaryOperator::Add:
1256    case BinaryOperator::Sub:
1257    case BinaryOperator::Shl:
1258    case BinaryOperator::Shr:
1259    case BinaryOperator::LT:
1260    case BinaryOperator::GT:
1261    case BinaryOperator::LE:
1262    case BinaryOperator::GE:
1263    case BinaryOperator::EQ:
1264    case BinaryOperator::NE:
1265    case BinaryOperator::And:
1266    case BinaryOperator::Xor:
1267    case BinaryOperator::Or:
1268    case BinaryOperator::Comma: {
1269      ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1270      ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1271      if (Exp->getOpcode() == BinaryOperator::Div ||
1272          Exp->getOpcode() == BinaryOperator::Rem) {
1273        // Evaluate gives an error for undefined Div/Rem, so make sure
1274        // we don't evaluate one.
1275        if (LHSResult.Val != 2 && RHSResult.Val != 2) {
1276          llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx);
1277          if (REval == 0)
1278            return ICEDiag(1, E->getLocStart());
1279          if (REval.isSigned() && REval.isAllOnesValue()) {
1280            llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx);
1281            if (LEval.isMinSignedValue())
1282              return ICEDiag(1, E->getLocStart());
1283          }
1284        }
1285      }
1286      if (Exp->getOpcode() == BinaryOperator::Comma) {
1287        if (Ctx.getLangOptions().C99) {
1288          // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
1289          // if it isn't evaluated.
1290          if (LHSResult.Val == 0 && RHSResult.Val == 0)
1291            return ICEDiag(1, E->getLocStart());
1292        } else {
1293          // In both C89 and C++, commas in ICEs are illegal.
1294          return ICEDiag(2, E->getLocStart());
1295        }
1296      }
1297      if (LHSResult.Val >= RHSResult.Val)
1298        return LHSResult;
1299      return RHSResult;
1300    }
1301    case BinaryOperator::LAnd:
1302    case BinaryOperator::LOr: {
1303      ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1304      ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1305      if (LHSResult.Val == 0 && RHSResult.Val == 1) {
1306        // Rare case where the RHS has a comma "side-effect"; we need
1307        // to actually check the condition to see whether the side
1308        // with the comma is evaluated.
1309        if ((Exp->getOpcode() == BinaryOperator::LAnd) !=
1310            (Exp->getLHS()->EvaluateAsInt(Ctx) == 0))
1311          return RHSResult;
1312        return NoDiag();
1313      }
1314
1315      if (LHSResult.Val >= RHSResult.Val)
1316        return LHSResult;
1317      return RHSResult;
1318    }
1319    }
1320  }
1321  case Expr::ImplicitCastExprClass:
1322  case Expr::CStyleCastExprClass:
1323  case Expr::CXXFunctionalCastExprClass: {
1324    const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
1325    if (SubExpr->getType()->isIntegralType())
1326      return CheckICE(SubExpr, Ctx);
1327    if (isa<FloatingLiteral>(SubExpr->IgnoreParens()))
1328      return NoDiag();
1329    return ICEDiag(2, E->getLocStart());
1330  }
1331  case Expr::ConditionalOperatorClass: {
1332    const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
1333    // If the condition (ignoring parens) is a __builtin_constant_p call,
1334    // then only the true side is actually considered in an integer constant
1335    // expression, and it is fully evaluated.  This is an important GNU
1336    // extension.  See GCC PR38377 for discussion.
1337    if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
1338      if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) {
1339        Expr::EvalResult EVResult;
1340        if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1341            !EVResult.Val.isInt()) {
1342          return ICEDiag(2, E->getLocStart());
1343        }
1344        return NoDiag();
1345      }
1346    ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
1347    ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
1348    ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
1349    if (CondResult.Val == 2)
1350      return CondResult;
1351    if (TrueResult.Val == 2)
1352      return TrueResult;
1353    if (FalseResult.Val == 2)
1354      return FalseResult;
1355    if (CondResult.Val == 1)
1356      return CondResult;
1357    if (TrueResult.Val == 0 && FalseResult.Val == 0)
1358      return NoDiag();
1359    // Rare case where the diagnostics depend on which side is evaluated
1360    // Note that if we get here, CondResult is 0, and at least one of
1361    // TrueResult and FalseResult is non-zero.
1362    if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) {
1363      return FalseResult;
1364    }
1365    return TrueResult;
1366  }
1367  case Expr::CXXDefaultArgExprClass:
1368    return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
1369  case Expr::ChooseExprClass: {
1370    return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx);
1371  }
1372  }
1373}
1374
1375bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
1376                                 SourceLocation *Loc, bool isEvaluated) const {
1377  ICEDiag d = CheckICE(this, Ctx);
1378  if (d.Val != 0) {
1379    if (Loc) *Loc = d.Loc;
1380    return false;
1381  }
1382  EvalResult EvalResult;
1383  if (!Evaluate(EvalResult, Ctx))
1384    assert(0 && "ICE cannot be evaluated!");
1385  assert(!EvalResult.HasSideEffects && "ICE with side effects!");
1386  assert(EvalResult.Val.isInt() && "ICE that isn't integer!");
1387  Result = EvalResult.Val.getInt();
1388  return true;
1389}
1390
1391/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1392/// integer constant expression with the value zero, or if this is one that is
1393/// cast to void*.
1394bool Expr::isNullPointerConstant(ASTContext &Ctx) const
1395{
1396  // Strip off a cast to void*, if it exists. Except in C++.
1397  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1398    if (!Ctx.getLangOptions().CPlusPlus) {
1399      // Check that it is a cast to void*.
1400      if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
1401        QualType Pointee = PT->getPointeeType();
1402        if (Pointee.getCVRQualifiers() == 0 &&
1403            Pointee->isVoidType() &&                              // to void*
1404            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1405          return CE->getSubExpr()->isNullPointerConstant(Ctx);
1406      }
1407    }
1408  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1409    // Ignore the ImplicitCastExpr type entirely.
1410    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
1411  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1412    // Accept ((void*)0) as a null pointer constant, as many other
1413    // implementations do.
1414    return PE->getSubExpr()->isNullPointerConstant(Ctx);
1415  } else if (const CXXDefaultArgExpr *DefaultArg
1416               = dyn_cast<CXXDefaultArgExpr>(this)) {
1417    // See through default argument expressions
1418    return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
1419  } else if (isa<GNUNullExpr>(this)) {
1420    // The GNU __null extension is always a null pointer constant.
1421    return true;
1422  }
1423
1424  // C++0x nullptr_t is always a null pointer constant.
1425  if (getType()->isNullPtrType())
1426    return true;
1427
1428  // This expression must be an integer type.
1429  if (!getType()->isIntegerType())
1430    return false;
1431
1432  // If we have an integer constant expression, we need to *evaluate* it and
1433  // test for the value 0.
1434  llvm::APSInt Result;
1435  return isIntegerConstantExpr(Result, Ctx) && Result == 0;
1436}
1437
1438FieldDecl *Expr::getBitField() {
1439  Expr *E = this->IgnoreParens();
1440
1441  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1442    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1443      if (Field->isBitField())
1444        return Field;
1445
1446  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E))
1447    if (BinOp->isAssignmentOp() && BinOp->getLHS())
1448      return BinOp->getLHS()->getBitField();
1449
1450  return 0;
1451}
1452
1453/// isArrow - Return true if the base expression is a pointer to vector,
1454/// return false if the base expression is a vector.
1455bool ExtVectorElementExpr::isArrow() const {
1456  return getBase()->getType()->isPointerType();
1457}
1458
1459unsigned ExtVectorElementExpr::getNumElements() const {
1460  if (const VectorType *VT = getType()->getAsVectorType())
1461    return VT->getNumElements();
1462  return 1;
1463}
1464
1465/// containsDuplicateElements - Return true if any element access is repeated.
1466bool ExtVectorElementExpr::containsDuplicateElements() const {
1467  const char *compStr = Accessor->getName();
1468  unsigned length = Accessor->getLength();
1469
1470  // Halving swizzles do not contain duplicate elements.
1471  if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1472      !strcmp(compStr, "even") || !strcmp(compStr, "odd"))
1473    return false;
1474
1475  // Advance past s-char prefix on hex swizzles.
1476  if (*compStr == 's' || *compStr == 'S') {
1477    compStr++;
1478    length--;
1479  }
1480
1481  for (unsigned i = 0; i != length-1; i++) {
1482    const char *s = compStr+i;
1483    for (const char c = *s++; *s; s++)
1484      if (c == *s)
1485        return true;
1486  }
1487  return false;
1488}
1489
1490/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1491void ExtVectorElementExpr::getEncodedElementAccess(
1492                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1493  const char *compStr = Accessor->getName();
1494  if (*compStr == 's' || *compStr == 'S')
1495    compStr++;
1496
1497  bool isHi =   !strcmp(compStr, "hi");
1498  bool isLo =   !strcmp(compStr, "lo");
1499  bool isEven = !strcmp(compStr, "even");
1500  bool isOdd  = !strcmp(compStr, "odd");
1501
1502  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1503    uint64_t Index;
1504
1505    if (isHi)
1506      Index = e + i;
1507    else if (isLo)
1508      Index = i;
1509    else if (isEven)
1510      Index = 2 * i;
1511    else if (isOdd)
1512      Index = 2 * i + 1;
1513    else
1514      Index = ExtVectorType::getAccessorIdx(compStr[i]);
1515
1516    Elts.push_back(Index);
1517  }
1518}
1519
1520// constructor for instance messages.
1521ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
1522                QualType retType, ObjCMethodDecl *mproto,
1523                SourceLocation LBrac, SourceLocation RBrac,
1524                Expr **ArgExprs, unsigned nargs)
1525  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1526    MethodProto(mproto) {
1527  NumArgs = nargs;
1528  SubExprs = new Stmt*[NumArgs+1];
1529  SubExprs[RECEIVER] = receiver;
1530  if (NumArgs) {
1531    for (unsigned i = 0; i != NumArgs; ++i)
1532      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1533  }
1534  LBracloc = LBrac;
1535  RBracloc = RBrac;
1536}
1537
1538// constructor for class messages.
1539// FIXME: clsName should be typed to ObjCInterfaceType
1540ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
1541                QualType retType, ObjCMethodDecl *mproto,
1542                SourceLocation LBrac, SourceLocation RBrac,
1543                Expr **ArgExprs, unsigned nargs)
1544  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1545    MethodProto(mproto) {
1546  NumArgs = nargs;
1547  SubExprs = new Stmt*[NumArgs+1];
1548  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
1549  if (NumArgs) {
1550    for (unsigned i = 0; i != NumArgs; ++i)
1551      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1552  }
1553  LBracloc = LBrac;
1554  RBracloc = RBrac;
1555}
1556
1557// constructor for class messages.
1558ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1559                                 QualType retType, ObjCMethodDecl *mproto,
1560                                 SourceLocation LBrac, SourceLocation RBrac,
1561                                 Expr **ArgExprs, unsigned nargs)
1562: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1563MethodProto(mproto) {
1564  NumArgs = nargs;
1565  SubExprs = new Stmt*[NumArgs+1];
1566  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1567  if (NumArgs) {
1568    for (unsigned i = 0; i != NumArgs; ++i)
1569      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1570  }
1571  LBracloc = LBrac;
1572  RBracloc = RBrac;
1573}
1574
1575ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1576  uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1577  switch (x & Flags) {
1578    default:
1579      assert(false && "Invalid ObjCMessageExpr.");
1580    case IsInstMeth:
1581      return ClassInfo(0, 0);
1582    case IsClsMethDeclUnknown:
1583      return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1584    case IsClsMethDeclKnown: {
1585      ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1586      return ClassInfo(D, D->getIdentifier());
1587    }
1588  }
1589}
1590
1591void ObjCMessageExpr::setClassInfo(const ObjCMessageExpr::ClassInfo &CI) {
1592  if (CI.first == 0 && CI.second == 0)
1593    SubExprs[RECEIVER] = (Expr*)((uintptr_t)0 | IsInstMeth);
1594  else if (CI.first == 0)
1595    SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.second | IsClsMethDeclUnknown);
1596  else
1597    SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.first | IsClsMethDeclKnown);
1598}
1599
1600
1601bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1602  return getCond()->EvaluateAsInt(C) != 0;
1603}
1604
1605void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
1606                                 unsigned NumExprs) {
1607  if (SubExprs) C.Deallocate(SubExprs);
1608
1609  SubExprs = new (C) Stmt* [NumExprs];
1610  this->NumExprs = NumExprs;
1611  memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
1612}
1613
1614void ShuffleVectorExpr::DoDestroy(ASTContext& C) {
1615  DestroyChildren(C);
1616  if (SubExprs) C.Deallocate(SubExprs);
1617  this->~ShuffleVectorExpr();
1618  C.Deallocate(this);
1619}
1620
1621void SizeOfAlignOfExpr::DoDestroy(ASTContext& C) {
1622  // Override default behavior of traversing children. If this has a type
1623  // operand and the type is a variable-length array, the child iteration
1624  // will iterate over the size expression. However, this expression belongs
1625  // to the type, not to this, so we don't want to delete it.
1626  // We still want to delete this expression.
1627  if (isArgumentType()) {
1628    this->~SizeOfAlignOfExpr();
1629    C.Deallocate(this);
1630  }
1631  else
1632    Expr::DoDestroy(C);
1633}
1634
1635//===----------------------------------------------------------------------===//
1636//  DesignatedInitExpr
1637//===----------------------------------------------------------------------===//
1638
1639IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
1640  assert(Kind == FieldDesignator && "Only valid on a field designator");
1641  if (Field.NameOrField & 0x01)
1642    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
1643  else
1644    return getField()->getIdentifier();
1645}
1646
1647DesignatedInitExpr::DesignatedInitExpr(QualType Ty, unsigned NumDesignators,
1648                                       const Designator *Designators,
1649                                       SourceLocation EqualOrColonLoc,
1650                                       bool GNUSyntax,
1651                                       Expr **IndexExprs,
1652                                       unsigned NumIndexExprs,
1653                                       Expr *Init)
1654  : Expr(DesignatedInitExprClass, Ty,
1655         Init->isTypeDependent(), Init->isValueDependent()),
1656    EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
1657    NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
1658  this->Designators = new Designator[NumDesignators];
1659
1660  // Record the initializer itself.
1661  child_iterator Child = child_begin();
1662  *Child++ = Init;
1663
1664  // Copy the designators and their subexpressions, computing
1665  // value-dependence along the way.
1666  unsigned IndexIdx = 0;
1667  for (unsigned I = 0; I != NumDesignators; ++I) {
1668    this->Designators[I] = Designators[I];
1669
1670    if (this->Designators[I].isArrayDesignator()) {
1671      // Compute type- and value-dependence.
1672      Expr *Index = IndexExprs[IndexIdx];
1673      ValueDependent = ValueDependent ||
1674        Index->isTypeDependent() || Index->isValueDependent();
1675
1676      // Copy the index expressions into permanent storage.
1677      *Child++ = IndexExprs[IndexIdx++];
1678    } else if (this->Designators[I].isArrayRangeDesignator()) {
1679      // Compute type- and value-dependence.
1680      Expr *Start = IndexExprs[IndexIdx];
1681      Expr *End = IndexExprs[IndexIdx + 1];
1682      ValueDependent = ValueDependent ||
1683        Start->isTypeDependent() || Start->isValueDependent() ||
1684        End->isTypeDependent() || End->isValueDependent();
1685
1686      // Copy the start/end expressions into permanent storage.
1687      *Child++ = IndexExprs[IndexIdx++];
1688      *Child++ = IndexExprs[IndexIdx++];
1689    }
1690  }
1691
1692  assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
1693}
1694
1695DesignatedInitExpr *
1696DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
1697                           unsigned NumDesignators,
1698                           Expr **IndexExprs, unsigned NumIndexExprs,
1699                           SourceLocation ColonOrEqualLoc,
1700                           bool UsesColonSyntax, Expr *Init) {
1701  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1702                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1703  return new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, Designators,
1704                                      ColonOrEqualLoc, UsesColonSyntax,
1705                                      IndexExprs, NumIndexExprs, Init);
1706}
1707
1708DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
1709                                                    unsigned NumIndexExprs) {
1710  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1711                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1712  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
1713}
1714
1715void DesignatedInitExpr::setDesignators(const Designator *Desigs,
1716                                        unsigned NumDesigs) {
1717  if (Designators)
1718    delete [] Designators;
1719
1720  Designators = new Designator[NumDesigs];
1721  NumDesignators = NumDesigs;
1722  for (unsigned I = 0; I != NumDesigs; ++I)
1723    Designators[I] = Desigs[I];
1724}
1725
1726SourceRange DesignatedInitExpr::getSourceRange() const {
1727  SourceLocation StartLoc;
1728  Designator &First =
1729    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
1730  if (First.isFieldDesignator()) {
1731    if (GNUSyntax)
1732      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
1733    else
1734      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
1735  } else
1736    StartLoc =
1737      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
1738  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
1739}
1740
1741Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
1742  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
1743  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1744  Ptr += sizeof(DesignatedInitExpr);
1745  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1746  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1747}
1748
1749Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
1750  assert(D.Kind == Designator::ArrayRangeDesignator &&
1751         "Requires array range designator");
1752  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1753  Ptr += sizeof(DesignatedInitExpr);
1754  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1755  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1756}
1757
1758Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
1759  assert(D.Kind == Designator::ArrayRangeDesignator &&
1760         "Requires array range designator");
1761  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1762  Ptr += sizeof(DesignatedInitExpr);
1763  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1764  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
1765}
1766
1767/// \brief Replaces the designator at index @p Idx with the series
1768/// of designators in [First, Last).
1769void DesignatedInitExpr::ExpandDesignator(unsigned Idx,
1770                                          const Designator *First,
1771                                          const Designator *Last) {
1772  unsigned NumNewDesignators = Last - First;
1773  if (NumNewDesignators == 0) {
1774    std::copy_backward(Designators + Idx + 1,
1775                       Designators + NumDesignators,
1776                       Designators + Idx);
1777    --NumNewDesignators;
1778    return;
1779  } else if (NumNewDesignators == 1) {
1780    Designators[Idx] = *First;
1781    return;
1782  }
1783
1784  Designator *NewDesignators
1785    = new Designator[NumDesignators - 1 + NumNewDesignators];
1786  std::copy(Designators, Designators + Idx, NewDesignators);
1787  std::copy(First, Last, NewDesignators + Idx);
1788  std::copy(Designators + Idx + 1, Designators + NumDesignators,
1789            NewDesignators + Idx + NumNewDesignators);
1790  delete [] Designators;
1791  Designators = NewDesignators;
1792  NumDesignators = NumDesignators - 1 + NumNewDesignators;
1793}
1794
1795void DesignatedInitExpr::DoDestroy(ASTContext &C) {
1796  delete [] Designators;
1797  Expr::DoDestroy(C);
1798}
1799
1800ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
1801                             Expr **exprs, unsigned nexprs,
1802                             SourceLocation rparenloc)
1803: Expr(ParenListExprClass, QualType(),
1804       hasAnyTypeDependentArguments(exprs, nexprs),
1805       hasAnyValueDependentArguments(exprs, nexprs)),
1806  NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
1807
1808  Exprs = new (C) Stmt*[nexprs];
1809  for (unsigned i = 0; i != nexprs; ++i)
1810    Exprs[i] = exprs[i];
1811}
1812
1813void ParenListExpr::DoDestroy(ASTContext& C) {
1814  DestroyChildren(C);
1815  if (Exprs) C.Deallocate(Exprs);
1816  this->~ParenListExpr();
1817  C.Deallocate(this);
1818}
1819
1820//===----------------------------------------------------------------------===//
1821//  ExprIterator.
1822//===----------------------------------------------------------------------===//
1823
1824Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
1825Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
1826Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
1827const Expr* ConstExprIterator::operator[](size_t idx) const {
1828  return cast<Expr>(I[idx]);
1829}
1830const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
1831const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
1832
1833//===----------------------------------------------------------------------===//
1834//  Child Iterators for iterating over subexpressions/substatements
1835//===----------------------------------------------------------------------===//
1836
1837// DeclRefExpr
1838Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1839Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
1840
1841// ObjCIvarRefExpr
1842Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1843Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
1844
1845// ObjCPropertyRefExpr
1846Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1847Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
1848
1849// ObjCKVCRefExpr
1850Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; }
1851Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; }
1852
1853// ObjCSuperExpr
1854Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
1855Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
1856
1857// ObjCIsaExpr
1858Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; }
1859Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; }
1860
1861// PredefinedExpr
1862Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
1863Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
1864
1865// IntegerLiteral
1866Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1867Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
1868
1869// CharacterLiteral
1870Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
1871Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
1872
1873// FloatingLiteral
1874Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1875Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
1876
1877// ImaginaryLiteral
1878Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1879Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
1880
1881// StringLiteral
1882Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1883Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
1884
1885// ParenExpr
1886Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1887Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
1888
1889// UnaryOperator
1890Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1891Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
1892
1893// SizeOfAlignOfExpr
1894Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
1895  // If this is of a type and the type is a VLA type (and not a typedef), the
1896  // size expression of the VLA needs to be treated as an executable expression.
1897  // Why isn't this weirdness documented better in StmtIterator?
1898  if (isArgumentType()) {
1899    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
1900                                   getArgumentType().getTypePtr()))
1901      return child_iterator(T);
1902    return child_iterator();
1903  }
1904  return child_iterator(&Argument.Ex);
1905}
1906Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
1907  if (isArgumentType())
1908    return child_iterator();
1909  return child_iterator(&Argument.Ex + 1);
1910}
1911
1912// ArraySubscriptExpr
1913Stmt::child_iterator ArraySubscriptExpr::child_begin() {
1914  return &SubExprs[0];
1915}
1916Stmt::child_iterator ArraySubscriptExpr::child_end() {
1917  return &SubExprs[0]+END_EXPR;
1918}
1919
1920// CallExpr
1921Stmt::child_iterator CallExpr::child_begin() {
1922  return &SubExprs[0];
1923}
1924Stmt::child_iterator CallExpr::child_end() {
1925  return &SubExprs[0]+NumArgs+ARGS_START;
1926}
1927
1928// MemberExpr
1929Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1930Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
1931
1932// ExtVectorElementExpr
1933Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1934Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
1935
1936// CompoundLiteralExpr
1937Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1938Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
1939
1940// CastExpr
1941Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1942Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
1943
1944// BinaryOperator
1945Stmt::child_iterator BinaryOperator::child_begin() {
1946  return &SubExprs[0];
1947}
1948Stmt::child_iterator BinaryOperator::child_end() {
1949  return &SubExprs[0]+END_EXPR;
1950}
1951
1952// ConditionalOperator
1953Stmt::child_iterator ConditionalOperator::child_begin() {
1954  return &SubExprs[0];
1955}
1956Stmt::child_iterator ConditionalOperator::child_end() {
1957  return &SubExprs[0]+END_EXPR;
1958}
1959
1960// AddrLabelExpr
1961Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1962Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
1963
1964// StmtExpr
1965Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1966Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
1967
1968// TypesCompatibleExpr
1969Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1970  return child_iterator();
1971}
1972
1973Stmt::child_iterator TypesCompatibleExpr::child_end() {
1974  return child_iterator();
1975}
1976
1977// ChooseExpr
1978Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1979Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
1980
1981// GNUNullExpr
1982Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
1983Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
1984
1985// ShuffleVectorExpr
1986Stmt::child_iterator ShuffleVectorExpr::child_begin() {
1987  return &SubExprs[0];
1988}
1989Stmt::child_iterator ShuffleVectorExpr::child_end() {
1990  return &SubExprs[0]+NumExprs;
1991}
1992
1993// VAArgExpr
1994Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1995Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
1996
1997// InitListExpr
1998Stmt::child_iterator InitListExpr::child_begin() {
1999  return InitExprs.size() ? &InitExprs[0] : 0;
2000}
2001Stmt::child_iterator InitListExpr::child_end() {
2002  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
2003}
2004
2005// DesignatedInitExpr
2006Stmt::child_iterator DesignatedInitExpr::child_begin() {
2007  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2008  Ptr += sizeof(DesignatedInitExpr);
2009  return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2010}
2011Stmt::child_iterator DesignatedInitExpr::child_end() {
2012  return child_iterator(&*child_begin() + NumSubExprs);
2013}
2014
2015// ImplicitValueInitExpr
2016Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
2017  return child_iterator();
2018}
2019
2020Stmt::child_iterator ImplicitValueInitExpr::child_end() {
2021  return child_iterator();
2022}
2023
2024// ParenListExpr
2025Stmt::child_iterator ParenListExpr::child_begin() {
2026  return &Exprs[0];
2027}
2028Stmt::child_iterator ParenListExpr::child_end() {
2029  return &Exprs[0]+NumExprs;
2030}
2031
2032// ObjCStringLiteral
2033Stmt::child_iterator ObjCStringLiteral::child_begin() {
2034  return &String;
2035}
2036Stmt::child_iterator ObjCStringLiteral::child_end() {
2037  return &String+1;
2038}
2039
2040// ObjCEncodeExpr
2041Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
2042Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
2043
2044// ObjCSelectorExpr
2045Stmt::child_iterator ObjCSelectorExpr::child_begin() {
2046  return child_iterator();
2047}
2048Stmt::child_iterator ObjCSelectorExpr::child_end() {
2049  return child_iterator();
2050}
2051
2052// ObjCProtocolExpr
2053Stmt::child_iterator ObjCProtocolExpr::child_begin() {
2054  return child_iterator();
2055}
2056Stmt::child_iterator ObjCProtocolExpr::child_end() {
2057  return child_iterator();
2058}
2059
2060// ObjCMessageExpr
2061Stmt::child_iterator ObjCMessageExpr::child_begin() {
2062  return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
2063}
2064Stmt::child_iterator ObjCMessageExpr::child_end() {
2065  return &SubExprs[0]+ARGS_START+getNumArgs();
2066}
2067
2068// Blocks
2069Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
2070Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
2071
2072Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
2073Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
2074