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