Expr.cpp revision 09de1767990d4828bcaf0dd22033a5dddeecbe08 
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  llvm::APSInt Result;
1378  return isIntegerConstantExpr(Result, Ctx) && Result == 0;
1379}
1380
1381/// isBitField - Return true if this expression is a bit-field.
1382bool Expr::isBitField() {
1383  Expr *E = this->IgnoreParenCasts();
1384  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1385    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1386        return Field->isBitField();
1387  return false;
1388}
1389
1390/// isArrow - Return true if the base expression is a pointer to vector,
1391/// return false if the base expression is a vector.
1392bool ExtVectorElementExpr::isArrow() const {
1393  return getBase()->getType()->isPointerType();
1394}
1395
1396unsigned ExtVectorElementExpr::getNumElements() const {
1397  if (const VectorType *VT = getType()->getAsVectorType())
1398    return VT->getNumElements();
1399  return 1;
1400}
1401
1402/// containsDuplicateElements - Return true if any element access is repeated.
1403bool ExtVectorElementExpr::containsDuplicateElements() const {
1404  const char *compStr = Accessor->getName();
1405  unsigned length = Accessor->getLength();
1406
1407  // Halving swizzles do not contain duplicate elements.
1408  if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
1409      !strcmp(compStr, "even") || !strcmp(compStr, "odd"))
1410    return false;
1411
1412  // Advance past s-char prefix on hex swizzles.
1413  if (*compStr == 's') {
1414    compStr++;
1415    length--;
1416  }
1417
1418  for (unsigned i = 0; i != length-1; i++) {
1419    const char *s = compStr+i;
1420    for (const char c = *s++; *s; s++)
1421      if (c == *s)
1422        return true;
1423  }
1424  return false;
1425}
1426
1427/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1428void ExtVectorElementExpr::getEncodedElementAccess(
1429                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1430  const char *compStr = Accessor->getName();
1431  if (*compStr == 's')
1432    compStr++;
1433
1434  bool isHi =   !strcmp(compStr, "hi");
1435  bool isLo =   !strcmp(compStr, "lo");
1436  bool isEven = !strcmp(compStr, "even");
1437  bool isOdd  = !strcmp(compStr, "odd");
1438
1439  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1440    uint64_t Index;
1441
1442    if (isHi)
1443      Index = e + i;
1444    else if (isLo)
1445      Index = i;
1446    else if (isEven)
1447      Index = 2 * i;
1448    else if (isOdd)
1449      Index = 2 * i + 1;
1450    else
1451      Index = ExtVectorType::getAccessorIdx(compStr[i]);
1452
1453    Elts.push_back(Index);
1454  }
1455}
1456
1457// constructor for instance messages.
1458ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
1459                QualType retType, ObjCMethodDecl *mproto,
1460                SourceLocation LBrac, SourceLocation RBrac,
1461                Expr **ArgExprs, unsigned nargs)
1462  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1463    MethodProto(mproto) {
1464  NumArgs = nargs;
1465  SubExprs = new Stmt*[NumArgs+1];
1466  SubExprs[RECEIVER] = receiver;
1467  if (NumArgs) {
1468    for (unsigned i = 0; i != NumArgs; ++i)
1469      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1470  }
1471  LBracloc = LBrac;
1472  RBracloc = RBrac;
1473}
1474
1475// constructor for class messages.
1476// FIXME: clsName should be typed to ObjCInterfaceType
1477ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
1478                QualType retType, ObjCMethodDecl *mproto,
1479                SourceLocation LBrac, SourceLocation RBrac,
1480                Expr **ArgExprs, unsigned nargs)
1481  : Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1482    MethodProto(mproto) {
1483  NumArgs = nargs;
1484  SubExprs = new Stmt*[NumArgs+1];
1485  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
1486  if (NumArgs) {
1487    for (unsigned i = 0; i != NumArgs; ++i)
1488      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1489  }
1490  LBracloc = LBrac;
1491  RBracloc = RBrac;
1492}
1493
1494// constructor for class messages.
1495ObjCMessageExpr::ObjCMessageExpr(ObjCInterfaceDecl *cls, Selector selInfo,
1496                                 QualType retType, ObjCMethodDecl *mproto,
1497                                 SourceLocation LBrac, SourceLocation RBrac,
1498                                 Expr **ArgExprs, unsigned nargs)
1499: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
1500MethodProto(mproto) {
1501  NumArgs = nargs;
1502  SubExprs = new Stmt*[NumArgs+1];
1503  SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
1504  if (NumArgs) {
1505    for (unsigned i = 0; i != NumArgs; ++i)
1506      SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
1507  }
1508  LBracloc = LBrac;
1509  RBracloc = RBrac;
1510}
1511
1512ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
1513  uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
1514  switch (x & Flags) {
1515    default:
1516      assert(false && "Invalid ObjCMessageExpr.");
1517    case IsInstMeth:
1518      return ClassInfo(0, 0);
1519    case IsClsMethDeclUnknown:
1520      return ClassInfo(0, (IdentifierInfo*) (x & ~Flags));
1521    case IsClsMethDeclKnown: {
1522      ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
1523      return ClassInfo(D, D->getIdentifier());
1524    }
1525  }
1526}
1527
1528bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1529  return getCond()->getIntegerConstantExprValue(C) != 0;
1530}
1531
1532void ShuffleVectorExpr::setExprs(Expr ** Exprs, unsigned NumExprs) {
1533  if (NumExprs)
1534    delete [] SubExprs;
1535
1536  SubExprs = new Stmt* [NumExprs];
1537  this->NumExprs = NumExprs;
1538  memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
1539}
1540
1541void SizeOfAlignOfExpr::Destroy(ASTContext& C) {
1542  // Override default behavior of traversing children. If this has a type
1543  // operand and the type is a variable-length array, the child iteration
1544  // will iterate over the size expression. However, this expression belongs
1545  // to the type, not to this, so we don't want to delete it.
1546  // We still want to delete this expression.
1547  if (isArgumentType()) {
1548    this->~SizeOfAlignOfExpr();
1549    C.Deallocate(this);
1550  }
1551  else
1552    Expr::Destroy(C);
1553}
1554
1555//===----------------------------------------------------------------------===//
1556//  DesignatedInitExpr
1557//===----------------------------------------------------------------------===//
1558
1559IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
1560  assert(Kind == FieldDesignator && "Only valid on a field designator");
1561  if (Field.NameOrField & 0x01)
1562    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
1563  else
1564    return getField()->getIdentifier();
1565}
1566
1567DesignatedInitExpr::DesignatedInitExpr(QualType Ty, unsigned NumDesignators,
1568                                       const Designator *Designators,
1569                                       SourceLocation EqualOrColonLoc,
1570                                       bool GNUSyntax,
1571                                       unsigned NumSubExprs)
1572  : Expr(DesignatedInitExprClass, Ty),
1573    EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
1574    NumDesignators(NumDesignators), NumSubExprs(NumSubExprs) {
1575  this->Designators = new Designator[NumDesignators];
1576  for (unsigned I = 0; I != NumDesignators; ++I)
1577    this->Designators[I] = Designators[I];
1578}
1579
1580DesignatedInitExpr *
1581DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
1582                           unsigned NumDesignators,
1583                           Expr **IndexExprs, unsigned NumIndexExprs,
1584                           SourceLocation ColonOrEqualLoc,
1585                           bool UsesColonSyntax, Expr *Init) {
1586  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1587                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1588  DesignatedInitExpr *DIE
1589    = new (Mem) DesignatedInitExpr(C.VoidTy, NumDesignators, Designators,
1590                                   ColonOrEqualLoc, UsesColonSyntax,
1591                                   NumIndexExprs + 1);
1592
1593  // Fill in the designators
1594  unsigned ExpectedNumSubExprs = 0;
1595  designators_iterator Desig = DIE->designators_begin();
1596  for (unsigned Idx = 0; Idx < NumDesignators; ++Idx, ++Desig) {
1597    if (Designators[Idx].isArrayDesignator())
1598      ++ExpectedNumSubExprs;
1599    else if (Designators[Idx].isArrayRangeDesignator())
1600      ExpectedNumSubExprs += 2;
1601  }
1602  assert(ExpectedNumSubExprs == NumIndexExprs && "Wrong number of indices!");
1603
1604  // Fill in the subexpressions, including the initializer expression.
1605  child_iterator Child = DIE->child_begin();
1606  *Child++ = Init;
1607  for (unsigned Idx = 0; Idx < NumIndexExprs; ++Idx, ++Child)
1608    *Child = IndexExprs[Idx];
1609
1610  return DIE;
1611}
1612
1613DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
1614                                                    unsigned NumIndexExprs) {
1615  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1616                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1617  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
1618}
1619
1620void DesignatedInitExpr::setDesignators(const Designator *Desigs,
1621                                        unsigned NumDesigs) {
1622  if (Designators)
1623    delete [] Designators;
1624
1625  Designators = new Designator[NumDesigs];
1626  NumDesignators = NumDesigs;
1627  for (unsigned I = 0; I != NumDesigs; ++I)
1628    Designators[I] = Desigs[I];
1629}
1630
1631SourceRange DesignatedInitExpr::getSourceRange() const {
1632  SourceLocation StartLoc;
1633  Designator &First =
1634    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
1635  if (First.isFieldDesignator()) {
1636    if (GNUSyntax)
1637      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
1638    else
1639      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
1640  } else
1641    StartLoc =
1642      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
1643  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
1644}
1645
1646Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
1647  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
1648  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1649  Ptr += sizeof(DesignatedInitExpr);
1650  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1651  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1652}
1653
1654Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
1655  assert(D.Kind == Designator::ArrayRangeDesignator &&
1656         "Requires array range designator");
1657  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1658  Ptr += sizeof(DesignatedInitExpr);
1659  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1660  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
1661}
1662
1663Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
1664  assert(D.Kind == Designator::ArrayRangeDesignator &&
1665         "Requires array range designator");
1666  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1667  Ptr += sizeof(DesignatedInitExpr);
1668  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1669  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
1670}
1671
1672/// \brief Replaces the designator at index @p Idx with the series
1673/// of designators in [First, Last).
1674void DesignatedInitExpr::ExpandDesignator(unsigned Idx,
1675                                          const Designator *First,
1676                                          const Designator *Last) {
1677  unsigned NumNewDesignators = Last - First;
1678  if (NumNewDesignators == 0) {
1679    std::copy_backward(Designators + Idx + 1,
1680                       Designators + NumDesignators,
1681                       Designators + Idx);
1682    --NumNewDesignators;
1683    return;
1684  } else if (NumNewDesignators == 1) {
1685    Designators[Idx] = *First;
1686    return;
1687  }
1688
1689  Designator *NewDesignators
1690    = new Designator[NumDesignators - 1 + NumNewDesignators];
1691  std::copy(Designators, Designators + Idx, NewDesignators);
1692  std::copy(First, Last, NewDesignators + Idx);
1693  std::copy(Designators + Idx + 1, Designators + NumDesignators,
1694            NewDesignators + Idx + NumNewDesignators);
1695  delete [] Designators;
1696  Designators = NewDesignators;
1697  NumDesignators = NumDesignators - 1 + NumNewDesignators;
1698}
1699
1700void DesignatedInitExpr::Destroy(ASTContext &C) {
1701  delete [] Designators;
1702  Expr::Destroy(C);
1703}
1704
1705//===----------------------------------------------------------------------===//
1706//  ExprIterator.
1707//===----------------------------------------------------------------------===//
1708
1709Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
1710Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
1711Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
1712const Expr* ConstExprIterator::operator[](size_t idx) const {
1713  return cast<Expr>(I[idx]);
1714}
1715const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
1716const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
1717
1718//===----------------------------------------------------------------------===//
1719//  Child Iterators for iterating over subexpressions/substatements
1720//===----------------------------------------------------------------------===//
1721
1722// DeclRefExpr
1723Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
1724Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
1725
1726// ObjCIvarRefExpr
1727Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
1728Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
1729
1730// ObjCPropertyRefExpr
1731Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
1732Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
1733
1734// ObjCKVCRefExpr
1735Stmt::child_iterator ObjCKVCRefExpr::child_begin() { return &Base; }
1736Stmt::child_iterator ObjCKVCRefExpr::child_end() { return &Base+1; }
1737
1738// ObjCSuperExpr
1739Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
1740Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
1741
1742// PredefinedExpr
1743Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
1744Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
1745
1746// IntegerLiteral
1747Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
1748Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
1749
1750// CharacterLiteral
1751Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
1752Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
1753
1754// FloatingLiteral
1755Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
1756Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
1757
1758// ImaginaryLiteral
1759Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
1760Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
1761
1762// StringLiteral
1763Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
1764Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
1765
1766// ParenExpr
1767Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
1768Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
1769
1770// UnaryOperator
1771Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
1772Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
1773
1774// SizeOfAlignOfExpr
1775Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
1776  // If this is of a type and the type is a VLA type (and not a typedef), the
1777  // size expression of the VLA needs to be treated as an executable expression.
1778  // Why isn't this weirdness documented better in StmtIterator?
1779  if (isArgumentType()) {
1780    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
1781                                   getArgumentType().getTypePtr()))
1782      return child_iterator(T);
1783    return child_iterator();
1784  }
1785  return child_iterator(&Argument.Ex);
1786}
1787Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
1788  if (isArgumentType())
1789    return child_iterator();
1790  return child_iterator(&Argument.Ex + 1);
1791}
1792
1793// ArraySubscriptExpr
1794Stmt::child_iterator ArraySubscriptExpr::child_begin() {
1795  return &SubExprs[0];
1796}
1797Stmt::child_iterator ArraySubscriptExpr::child_end() {
1798  return &SubExprs[0]+END_EXPR;
1799}
1800
1801// CallExpr
1802Stmt::child_iterator CallExpr::child_begin() {
1803  return &SubExprs[0];
1804}
1805Stmt::child_iterator CallExpr::child_end() {
1806  return &SubExprs[0]+NumArgs+ARGS_START;
1807}
1808
1809// MemberExpr
1810Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
1811Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
1812
1813// ExtVectorElementExpr
1814Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
1815Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
1816
1817// CompoundLiteralExpr
1818Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
1819Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
1820
1821// CastExpr
1822Stmt::child_iterator CastExpr::child_begin() { return &Op; }
1823Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
1824
1825// BinaryOperator
1826Stmt::child_iterator BinaryOperator::child_begin() {
1827  return &SubExprs[0];
1828}
1829Stmt::child_iterator BinaryOperator::child_end() {
1830  return &SubExprs[0]+END_EXPR;
1831}
1832
1833// ConditionalOperator
1834Stmt::child_iterator ConditionalOperator::child_begin() {
1835  return &SubExprs[0];
1836}
1837Stmt::child_iterator ConditionalOperator::child_end() {
1838  return &SubExprs[0]+END_EXPR;
1839}
1840
1841// AddrLabelExpr
1842Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
1843Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
1844
1845// StmtExpr
1846Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
1847Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
1848
1849// TypesCompatibleExpr
1850Stmt::child_iterator TypesCompatibleExpr::child_begin() {
1851  return child_iterator();
1852}
1853
1854Stmt::child_iterator TypesCompatibleExpr::child_end() {
1855  return child_iterator();
1856}
1857
1858// ChooseExpr
1859Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
1860Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
1861
1862// GNUNullExpr
1863Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
1864Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
1865
1866// ShuffleVectorExpr
1867Stmt::child_iterator ShuffleVectorExpr::child_begin() {
1868  return &SubExprs[0];
1869}
1870Stmt::child_iterator ShuffleVectorExpr::child_end() {
1871  return &SubExprs[0]+NumExprs;
1872}
1873
1874// VAArgExpr
1875Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
1876Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
1877
1878// InitListExpr
1879Stmt::child_iterator InitListExpr::child_begin() {
1880  return InitExprs.size() ? &InitExprs[0] : 0;
1881}
1882Stmt::child_iterator InitListExpr::child_end() {
1883  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
1884}
1885
1886// DesignatedInitExpr
1887Stmt::child_iterator DesignatedInitExpr::child_begin() {
1888  char* Ptr = static_cast<char*>(static_cast<void *>(this));
1889  Ptr += sizeof(DesignatedInitExpr);
1890  return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
1891}
1892Stmt::child_iterator DesignatedInitExpr::child_end() {
1893  return child_iterator(&*child_begin() + NumSubExprs);
1894}
1895
1896// ImplicitValueInitExpr
1897Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
1898  return child_iterator();
1899}
1900
1901Stmt::child_iterator ImplicitValueInitExpr::child_end() {
1902  return child_iterator();
1903}
1904
1905// ObjCStringLiteral
1906Stmt::child_iterator ObjCStringLiteral::child_begin() {
1907  return &String;
1908}
1909Stmt::child_iterator ObjCStringLiteral::child_end() {
1910  return &String+1;
1911}
1912
1913// ObjCEncodeExpr
1914Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
1915Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
1916
1917// ObjCSelectorExpr
1918Stmt::child_iterator ObjCSelectorExpr::child_begin() {
1919  return child_iterator();
1920}
1921Stmt::child_iterator ObjCSelectorExpr::child_end() {
1922  return child_iterator();
1923}
1924
1925// ObjCProtocolExpr
1926Stmt::child_iterator ObjCProtocolExpr::child_begin() {
1927  return child_iterator();
1928}
1929Stmt::child_iterator ObjCProtocolExpr::child_end() {
1930  return child_iterator();
1931}
1932
1933// ObjCMessageExpr
1934Stmt::child_iterator ObjCMessageExpr::child_begin() {
1935  return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
1936}
1937Stmt::child_iterator ObjCMessageExpr::child_end() {
1938  return &SubExprs[0]+ARGS_START+getNumArgs();
1939}
1940
1941// Blocks
1942Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
1943Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
1944
1945Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
1946Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
1947