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