Expr.cpp revision 200121569dc6cff10a1fb6ed7500098770b9dd25 
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/ExprCXX.h"
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/DeclCXX.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/RecordLayout.h"
22#include "clang/AST/StmtVisitor.h"
23#include "clang/Basic/Builtins.h"
24#include "clang/Basic/TargetInfo.h"
25#include "llvm/Support/ErrorHandling.h"
26#include "llvm/Support/raw_ostream.h"
27#include <algorithm>
28using namespace clang;
29
30void Expr::ANCHOR() {} // key function for Expr class.
31
32/// isKnownToHaveBooleanValue - Return true if this is an integer expression
33/// that is known to return 0 or 1.  This happens for _Bool/bool expressions
34/// but also int expressions which are produced by things like comparisons in
35/// C.
36bool Expr::isKnownToHaveBooleanValue() const {
37  // If this value has _Bool type, it is obvious 0/1.
38  if (getType()->isBooleanType()) return true;
39  // If this is a non-scalar-integer type, we don't care enough to try.
40  if (!getType()->isIntegralOrEnumerationType()) return false;
41
42  if (const ParenExpr *PE = dyn_cast<ParenExpr>(this))
43    return PE->getSubExpr()->isKnownToHaveBooleanValue();
44
45  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(this)) {
46    switch (UO->getOpcode()) {
47    case UO_Plus:
48    case UO_Extension:
49      return UO->getSubExpr()->isKnownToHaveBooleanValue();
50    default:
51      return false;
52    }
53  }
54
55  // Only look through implicit casts.  If the user writes
56  // '(int) (a && b)' treat it as an arbitrary int.
57  if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(this))
58    return CE->getSubExpr()->isKnownToHaveBooleanValue();
59
60  if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(this)) {
61    switch (BO->getOpcode()) {
62    default: return false;
63    case BO_LT:   // Relational operators.
64    case BO_GT:
65    case BO_LE:
66    case BO_GE:
67    case BO_EQ:   // Equality operators.
68    case BO_NE:
69    case BO_LAnd: // AND operator.
70    case BO_LOr:  // Logical OR operator.
71      return true;
72
73    case BO_And:  // Bitwise AND operator.
74    case BO_Xor:  // Bitwise XOR operator.
75    case BO_Or:   // Bitwise OR operator.
76      // Handle things like (x==2)|(y==12).
77      return BO->getLHS()->isKnownToHaveBooleanValue() &&
78             BO->getRHS()->isKnownToHaveBooleanValue();
79
80    case BO_Comma:
81    case BO_Assign:
82      return BO->getRHS()->isKnownToHaveBooleanValue();
83    }
84  }
85
86  if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(this))
87    return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
88           CO->getFalseExpr()->isKnownToHaveBooleanValue();
89
90  return false;
91}
92
93//===----------------------------------------------------------------------===//
94// Primary Expressions.
95//===----------------------------------------------------------------------===//
96
97void ExplicitTemplateArgumentList::initializeFrom(
98                                      const TemplateArgumentListInfo &Info) {
99  LAngleLoc = Info.getLAngleLoc();
100  RAngleLoc = Info.getRAngleLoc();
101  NumTemplateArgs = Info.size();
102
103  TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
104  for (unsigned i = 0; i != NumTemplateArgs; ++i)
105    new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
106}
107
108void ExplicitTemplateArgumentList::copyInto(
109                                      TemplateArgumentListInfo &Info) const {
110  Info.setLAngleLoc(LAngleLoc);
111  Info.setRAngleLoc(RAngleLoc);
112  for (unsigned I = 0; I != NumTemplateArgs; ++I)
113    Info.addArgument(getTemplateArgs()[I]);
114}
115
116std::size_t ExplicitTemplateArgumentList::sizeFor(unsigned NumTemplateArgs) {
117  return sizeof(ExplicitTemplateArgumentList) +
118         sizeof(TemplateArgumentLoc) * NumTemplateArgs;
119}
120
121std::size_t ExplicitTemplateArgumentList::sizeFor(
122                                      const TemplateArgumentListInfo &Info) {
123  return sizeFor(Info.size());
124}
125
126void DeclRefExpr::computeDependence() {
127  TypeDependent = false;
128  ValueDependent = false;
129
130  NamedDecl *D = getDecl();
131
132  // (TD) C++ [temp.dep.expr]p3:
133  //   An id-expression is type-dependent if it contains:
134  //
135  // and
136  //
137  // (VD) C++ [temp.dep.constexpr]p2:
138  //  An identifier is value-dependent if it is:
139
140  //  (TD)  - an identifier that was declared with dependent type
141  //  (VD)  - a name declared with a dependent type,
142  if (getType()->isDependentType()) {
143    TypeDependent = true;
144    ValueDependent = true;
145  }
146  //  (TD)  - a conversion-function-id that specifies a dependent type
147  else if (D->getDeclName().getNameKind()
148                               == DeclarationName::CXXConversionFunctionName &&
149           D->getDeclName().getCXXNameType()->isDependentType()) {
150    TypeDependent = true;
151    ValueDependent = true;
152  }
153  //  (TD)  - a template-id that is dependent,
154  else if (hasExplicitTemplateArgs() &&
155           TemplateSpecializationType::anyDependentTemplateArguments(
156                                                       getTemplateArgs(),
157                                                       getNumTemplateArgs())) {
158    TypeDependent = true;
159    ValueDependent = true;
160  }
161  //  (VD)  - the name of a non-type template parameter,
162  else if (isa<NonTypeTemplateParmDecl>(D))
163    ValueDependent = true;
164  //  (VD) - a constant with integral or enumeration type and is
165  //         initialized with an expression that is value-dependent.
166  else if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
167    if (Var->getType()->isIntegralOrEnumerationType() &&
168        Var->getType().getCVRQualifiers() == Qualifiers::Const) {
169      if (const Expr *Init = Var->getAnyInitializer())
170        if (Init->isValueDependent())
171          ValueDependent = true;
172    }
173    // (VD) - FIXME: Missing from the standard:
174    //      -  a member function or a static data member of the current
175    //         instantiation
176    else if (Var->isStaticDataMember() &&
177             Var->getDeclContext()->isDependentContext())
178      ValueDependent = true;
179  }
180  // (VD) - FIXME: Missing from the standard:
181  //      -  a member function or a static data member of the current
182  //         instantiation
183  else if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext())
184    ValueDependent = true;
185  //  (TD)  - a nested-name-specifier or a qualified-id that names a
186  //          member of an unknown specialization.
187  //        (handled by DependentScopeDeclRefExpr)
188}
189
190DeclRefExpr::DeclRefExpr(NestedNameSpecifier *Qualifier,
191                         SourceRange QualifierRange,
192                         ValueDecl *D, SourceLocation NameLoc,
193                         const TemplateArgumentListInfo *TemplateArgs,
194                         QualType T)
195  : Expr(DeclRefExprClass, T, false, false),
196    DecoratedD(D,
197               (Qualifier? HasQualifierFlag : 0) |
198               (TemplateArgs ? HasExplicitTemplateArgumentListFlag : 0)),
199    Loc(NameLoc) {
200  if (Qualifier) {
201    NameQualifier *NQ = getNameQualifier();
202    NQ->NNS = Qualifier;
203    NQ->Range = QualifierRange;
204  }
205
206  if (TemplateArgs)
207    getExplicitTemplateArgs().initializeFrom(*TemplateArgs);
208
209  computeDependence();
210}
211
212DeclRefExpr::DeclRefExpr(NestedNameSpecifier *Qualifier,
213                         SourceRange QualifierRange,
214                         ValueDecl *D, const DeclarationNameInfo &NameInfo,
215                         const TemplateArgumentListInfo *TemplateArgs,
216                         QualType T)
217  : Expr(DeclRefExprClass, T, false, false),
218    DecoratedD(D,
219               (Qualifier? HasQualifierFlag : 0) |
220               (TemplateArgs ? HasExplicitTemplateArgumentListFlag : 0)),
221    Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) {
222  if (Qualifier) {
223    NameQualifier *NQ = getNameQualifier();
224    NQ->NNS = Qualifier;
225    NQ->Range = QualifierRange;
226  }
227
228  if (TemplateArgs)
229    getExplicitTemplateArgs().initializeFrom(*TemplateArgs);
230
231  computeDependence();
232}
233
234DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
235                                 NestedNameSpecifier *Qualifier,
236                                 SourceRange QualifierRange,
237                                 ValueDecl *D,
238                                 SourceLocation NameLoc,
239                                 QualType T,
240                                 const TemplateArgumentListInfo *TemplateArgs) {
241  return Create(Context, Qualifier, QualifierRange, D,
242                DeclarationNameInfo(D->getDeclName(), NameLoc),
243                T, TemplateArgs);
244}
245
246DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
247                                 NestedNameSpecifier *Qualifier,
248                                 SourceRange QualifierRange,
249                                 ValueDecl *D,
250                                 const DeclarationNameInfo &NameInfo,
251                                 QualType T,
252                                 const TemplateArgumentListInfo *TemplateArgs) {
253  std::size_t Size = sizeof(DeclRefExpr);
254  if (Qualifier != 0)
255    Size += sizeof(NameQualifier);
256
257  if (TemplateArgs)
258    Size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
259
260  void *Mem = Context.Allocate(Size, llvm::alignof<DeclRefExpr>());
261  return new (Mem) DeclRefExpr(Qualifier, QualifierRange, D, NameInfo,
262                               TemplateArgs, T);
263}
264
265DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext &Context, bool HasQualifier,
266                                      unsigned NumTemplateArgs) {
267  std::size_t Size = sizeof(DeclRefExpr);
268  if (HasQualifier)
269    Size += sizeof(NameQualifier);
270
271  if (NumTemplateArgs)
272    Size += ExplicitTemplateArgumentList::sizeFor(NumTemplateArgs);
273
274  void *Mem = Context.Allocate(Size, llvm::alignof<DeclRefExpr>());
275  return new (Mem) DeclRefExpr(EmptyShell());
276}
277
278SourceRange DeclRefExpr::getSourceRange() const {
279  SourceRange R = getNameInfo().getSourceRange();
280  if (hasQualifier())
281    R.setBegin(getQualifierRange().getBegin());
282  if (hasExplicitTemplateArgs())
283    R.setEnd(getRAngleLoc());
284  return R;
285}
286
287// FIXME: Maybe this should use DeclPrinter with a special "print predefined
288// expr" policy instead.
289std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
290  ASTContext &Context = CurrentDecl->getASTContext();
291
292  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
293    if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual)
294      return FD->getNameAsString();
295
296    llvm::SmallString<256> Name;
297    llvm::raw_svector_ostream Out(Name);
298
299    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
300      if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
301        Out << "virtual ";
302      if (MD->isStatic())
303        Out << "static ";
304    }
305
306    PrintingPolicy Policy(Context.getLangOptions());
307
308    std::string Proto = FD->getQualifiedNameAsString(Policy);
309
310    const FunctionType *AFT = FD->getType()->getAs<FunctionType>();
311    const FunctionProtoType *FT = 0;
312    if (FD->hasWrittenPrototype())
313      FT = dyn_cast<FunctionProtoType>(AFT);
314
315    Proto += "(";
316    if (FT) {
317      llvm::raw_string_ostream POut(Proto);
318      for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
319        if (i) POut << ", ";
320        std::string Param;
321        FD->getParamDecl(i)->getType().getAsStringInternal(Param, Policy);
322        POut << Param;
323      }
324
325      if (FT->isVariadic()) {
326        if (FD->getNumParams()) POut << ", ";
327        POut << "...";
328      }
329    }
330    Proto += ")";
331
332    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
333      Qualifiers ThisQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
334      if (ThisQuals.hasConst())
335        Proto += " const";
336      if (ThisQuals.hasVolatile())
337        Proto += " volatile";
338    }
339
340    if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
341      AFT->getResultType().getAsStringInternal(Proto, Policy);
342
343    Out << Proto;
344
345    Out.flush();
346    return Name.str().str();
347  }
348  if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
349    llvm::SmallString<256> Name;
350    llvm::raw_svector_ostream Out(Name);
351    Out << (MD->isInstanceMethod() ? '-' : '+');
352    Out << '[';
353
354    // For incorrect code, there might not be an ObjCInterfaceDecl.  Do
355    // a null check to avoid a crash.
356    if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
357      Out << ID;
358
359    if (const ObjCCategoryImplDecl *CID =
360        dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
361      Out << '(' << CID << ')';
362
363    Out <<  ' ';
364    Out << MD->getSelector().getAsString();
365    Out <<  ']';
366
367    Out.flush();
368    return Name.str().str();
369  }
370  if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
371    // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
372    return "top level";
373  }
374  return "";
375}
376
377void APNumericStorage::setIntValue(ASTContext &C, const llvm::APInt &Val) {
378  if (hasAllocation())
379    C.Deallocate(pVal);
380
381  BitWidth = Val.getBitWidth();
382  unsigned NumWords = Val.getNumWords();
383  const uint64_t* Words = Val.getRawData();
384  if (NumWords > 1) {
385    pVal = new (C) uint64_t[NumWords];
386    std::copy(Words, Words + NumWords, pVal);
387  } else if (NumWords == 1)
388    VAL = Words[0];
389  else
390    VAL = 0;
391}
392
393IntegerLiteral *
394IntegerLiteral::Create(ASTContext &C, const llvm::APInt &V,
395                       QualType type, SourceLocation l) {
396  return new (C) IntegerLiteral(C, V, type, l);
397}
398
399IntegerLiteral *
400IntegerLiteral::Create(ASTContext &C, EmptyShell Empty) {
401  return new (C) IntegerLiteral(Empty);
402}
403
404FloatingLiteral *
405FloatingLiteral::Create(ASTContext &C, const llvm::APFloat &V,
406                        bool isexact, QualType Type, SourceLocation L) {
407  return new (C) FloatingLiteral(C, V, isexact, Type, L);
408}
409
410FloatingLiteral *
411FloatingLiteral::Create(ASTContext &C, EmptyShell Empty) {
412  return new (C) FloatingLiteral(Empty);
413}
414
415/// getValueAsApproximateDouble - This returns the value as an inaccurate
416/// double.  Note that this may cause loss of precision, but is useful for
417/// debugging dumps, etc.
418double FloatingLiteral::getValueAsApproximateDouble() const {
419  llvm::APFloat V = getValue();
420  bool ignored;
421  V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
422            &ignored);
423  return V.convertToDouble();
424}
425
426StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
427                                     unsigned ByteLength, bool Wide,
428                                     QualType Ty,
429                                     const SourceLocation *Loc,
430                                     unsigned NumStrs) {
431  // Allocate enough space for the StringLiteral plus an array of locations for
432  // any concatenated string tokens.
433  void *Mem = C.Allocate(sizeof(StringLiteral)+
434                         sizeof(SourceLocation)*(NumStrs-1),
435                         llvm::alignof<StringLiteral>());
436  StringLiteral *SL = new (Mem) StringLiteral(Ty);
437
438  // OPTIMIZE: could allocate this appended to the StringLiteral.
439  char *AStrData = new (C, 1) char[ByteLength];
440  memcpy(AStrData, StrData, ByteLength);
441  SL->StrData = AStrData;
442  SL->ByteLength = ByteLength;
443  SL->IsWide = Wide;
444  SL->TokLocs[0] = Loc[0];
445  SL->NumConcatenated = NumStrs;
446
447  if (NumStrs != 1)
448    memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
449  return SL;
450}
451
452StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
453  void *Mem = C.Allocate(sizeof(StringLiteral)+
454                         sizeof(SourceLocation)*(NumStrs-1),
455                         llvm::alignof<StringLiteral>());
456  StringLiteral *SL = new (Mem) StringLiteral(QualType());
457  SL->StrData = 0;
458  SL->ByteLength = 0;
459  SL->NumConcatenated = NumStrs;
460  return SL;
461}
462
463void StringLiteral::setString(ASTContext &C, llvm::StringRef Str) {
464  char *AStrData = new (C, 1) char[Str.size()];
465  memcpy(AStrData, Str.data(), Str.size());
466  StrData = AStrData;
467  ByteLength = Str.size();
468}
469
470/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
471/// corresponds to, e.g. "sizeof" or "[pre]++".
472const char *UnaryOperator::getOpcodeStr(Opcode Op) {
473  switch (Op) {
474  default: assert(0 && "Unknown unary operator");
475  case UO_PostInc: return "++";
476  case UO_PostDec: return "--";
477  case UO_PreInc:  return "++";
478  case UO_PreDec:  return "--";
479  case UO_AddrOf:  return "&";
480  case UO_Deref:   return "*";
481  case UO_Plus:    return "+";
482  case UO_Minus:   return "-";
483  case UO_Not:     return "~";
484  case UO_LNot:    return "!";
485  case UO_Real:    return "__real";
486  case UO_Imag:    return "__imag";
487  case UO_Extension: return "__extension__";
488  }
489}
490
491UnaryOperatorKind
492UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
493  switch (OO) {
494  default: assert(false && "No unary operator for overloaded function");
495  case OO_PlusPlus:   return Postfix ? UO_PostInc : UO_PreInc;
496  case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;
497  case OO_Amp:        return UO_AddrOf;
498  case OO_Star:       return UO_Deref;
499  case OO_Plus:       return UO_Plus;
500  case OO_Minus:      return UO_Minus;
501  case OO_Tilde:      return UO_Not;
502  case OO_Exclaim:    return UO_LNot;
503  }
504}
505
506OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
507  switch (Opc) {
508  case UO_PostInc: case UO_PreInc: return OO_PlusPlus;
509  case UO_PostDec: case UO_PreDec: return OO_MinusMinus;
510  case UO_AddrOf: return OO_Amp;
511  case UO_Deref: return OO_Star;
512  case UO_Plus: return OO_Plus;
513  case UO_Minus: return OO_Minus;
514  case UO_Not: return OO_Tilde;
515  case UO_LNot: return OO_Exclaim;
516  default: return OO_None;
517  }
518}
519
520
521//===----------------------------------------------------------------------===//
522// Postfix Operators.
523//===----------------------------------------------------------------------===//
524
525CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args,
526                   unsigned numargs, QualType t, SourceLocation rparenloc)
527  : Expr(SC, t,
528         fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
529         fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
530    NumArgs(numargs) {
531
532  SubExprs = new (C) Stmt*[numargs+1];
533  SubExprs[FN] = fn;
534  for (unsigned i = 0; i != numargs; ++i)
535    SubExprs[i+ARGS_START] = args[i];
536
537  RParenLoc = rparenloc;
538}
539
540CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
541                   QualType t, SourceLocation rparenloc)
542  : Expr(CallExprClass, t,
543         fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
544         fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
545    NumArgs(numargs) {
546
547  SubExprs = new (C) Stmt*[numargs+1];
548  SubExprs[FN] = fn;
549  for (unsigned i = 0; i != numargs; ++i)
550    SubExprs[i+ARGS_START] = args[i];
551
552  RParenLoc = rparenloc;
553}
554
555CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
556  : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
557  SubExprs = new (C) Stmt*[1];
558}
559
560Decl *CallExpr::getCalleeDecl() {
561  Expr *CEE = getCallee()->IgnoreParenCasts();
562  // If we're calling a dereference, look at the pointer instead.
563  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) {
564    if (BO->isPtrMemOp())
565      CEE = BO->getRHS()->IgnoreParenCasts();
566  } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
567    if (UO->getOpcode() == UO_Deref)
568      CEE = UO->getSubExpr()->IgnoreParenCasts();
569  }
570  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
571    return DRE->getDecl();
572  if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
573    return ME->getMemberDecl();
574
575  return 0;
576}
577
578FunctionDecl *CallExpr::getDirectCallee() {
579  return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
580}
581
582/// setNumArgs - This changes the number of arguments present in this call.
583/// Any orphaned expressions are deleted by this, and any new operands are set
584/// to null.
585void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
586  // No change, just return.
587  if (NumArgs == getNumArgs()) return;
588
589  // If shrinking # arguments, just delete the extras and forgot them.
590  if (NumArgs < getNumArgs()) {
591    this->NumArgs = NumArgs;
592    return;
593  }
594
595  // Otherwise, we are growing the # arguments.  New an bigger argument array.
596  Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1];
597  // Copy over args.
598  for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
599    NewSubExprs[i] = SubExprs[i];
600  // Null out new args.
601  for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
602    NewSubExprs[i] = 0;
603
604  if (SubExprs) C.Deallocate(SubExprs);
605  SubExprs = NewSubExprs;
606  this->NumArgs = NumArgs;
607}
608
609/// isBuiltinCall - If this is a call to a builtin, return the builtin ID.  If
610/// not, return 0.
611unsigned CallExpr::isBuiltinCall(ASTContext &Context) const {
612  // All simple function calls (e.g. func()) are implicitly cast to pointer to
613  // function. As a result, we try and obtain the DeclRefExpr from the
614  // ImplicitCastExpr.
615  const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
616  if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
617    return 0;
618
619  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
620  if (!DRE)
621    return 0;
622
623  const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
624  if (!FDecl)
625    return 0;
626
627  if (!FDecl->getIdentifier())
628    return 0;
629
630  return FDecl->getBuiltinID();
631}
632
633QualType CallExpr::getCallReturnType() const {
634  QualType CalleeType = getCallee()->getType();
635  if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
636    CalleeType = FnTypePtr->getPointeeType();
637  else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
638    CalleeType = BPT->getPointeeType();
639  else if (const MemberPointerType *MPT
640                                      = CalleeType->getAs<MemberPointerType>())
641    CalleeType = MPT->getPointeeType();
642
643  const FunctionType *FnType = CalleeType->getAs<FunctionType>();
644  return FnType->getResultType();
645}
646
647OffsetOfExpr *OffsetOfExpr::Create(ASTContext &C, QualType type,
648                                   SourceLocation OperatorLoc,
649                                   TypeSourceInfo *tsi,
650                                   OffsetOfNode* compsPtr, unsigned numComps,
651                                   Expr** exprsPtr, unsigned numExprs,
652                                   SourceLocation RParenLoc) {
653  void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
654                         sizeof(OffsetOfNode) * numComps +
655                         sizeof(Expr*) * numExprs);
656
657  return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, compsPtr, numComps,
658                                exprsPtr, numExprs, RParenLoc);
659}
660
661OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext &C,
662                                        unsigned numComps, unsigned numExprs) {
663  void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
664                         sizeof(OffsetOfNode) * numComps +
665                         sizeof(Expr*) * numExprs);
666  return new (Mem) OffsetOfExpr(numComps, numExprs);
667}
668
669OffsetOfExpr::OffsetOfExpr(ASTContext &C, QualType type,
670                           SourceLocation OperatorLoc, TypeSourceInfo *tsi,
671                           OffsetOfNode* compsPtr, unsigned numComps,
672                           Expr** exprsPtr, unsigned numExprs,
673                           SourceLocation RParenLoc)
674  : Expr(OffsetOfExprClass, type, /*TypeDependent=*/false,
675         /*ValueDependent=*/tsi->getType()->isDependentType() ||
676         hasAnyTypeDependentArguments(exprsPtr, numExprs) ||
677         hasAnyValueDependentArguments(exprsPtr, numExprs)),
678    OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
679    NumComps(numComps), NumExprs(numExprs)
680{
681  for(unsigned i = 0; i < numComps; ++i) {
682    setComponent(i, compsPtr[i]);
683  }
684
685  for(unsigned i = 0; i < numExprs; ++i) {
686    setIndexExpr(i, exprsPtr[i]);
687  }
688}
689
690IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const {
691  assert(getKind() == Field || getKind() == Identifier);
692  if (getKind() == Field)
693    return getField()->getIdentifier();
694
695  return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
696}
697
698MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
699                               NestedNameSpecifier *qual,
700                               SourceRange qualrange,
701                               ValueDecl *memberdecl,
702                               DeclAccessPair founddecl,
703                               DeclarationNameInfo nameinfo,
704                               const TemplateArgumentListInfo *targs,
705                               QualType ty) {
706  std::size_t Size = sizeof(MemberExpr);
707
708  bool hasQualOrFound = (qual != 0 ||
709                         founddecl.getDecl() != memberdecl ||
710                         founddecl.getAccess() != memberdecl->getAccess());
711  if (hasQualOrFound)
712    Size += sizeof(MemberNameQualifier);
713
714  if (targs)
715    Size += ExplicitTemplateArgumentList::sizeFor(*targs);
716
717  void *Mem = C.Allocate(Size, llvm::alignof<MemberExpr>());
718  MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo, ty);
719
720  if (hasQualOrFound) {
721    if (qual && qual->isDependent()) {
722      E->setValueDependent(true);
723      E->setTypeDependent(true);
724    }
725    E->HasQualifierOrFoundDecl = true;
726
727    MemberNameQualifier *NQ = E->getMemberQualifier();
728    NQ->NNS = qual;
729    NQ->Range = qualrange;
730    NQ->FoundDecl = founddecl;
731  }
732
733  if (targs) {
734    E->HasExplicitTemplateArgumentList = true;
735    E->getExplicitTemplateArgs().initializeFrom(*targs);
736  }
737
738  return E;
739}
740
741const char *CastExpr::getCastKindName() const {
742  switch (getCastKind()) {
743  case CK_Unknown:
744    return "Unknown";
745  case CK_BitCast:
746    return "BitCast";
747  case CK_LValueBitCast:
748    return "LValueBitCast";
749  case CK_NoOp:
750    return "NoOp";
751  case CK_BaseToDerived:
752    return "BaseToDerived";
753  case CK_DerivedToBase:
754    return "DerivedToBase";
755  case CK_UncheckedDerivedToBase:
756    return "UncheckedDerivedToBase";
757  case CK_Dynamic:
758    return "Dynamic";
759  case CK_ToUnion:
760    return "ToUnion";
761  case CK_ArrayToPointerDecay:
762    return "ArrayToPointerDecay";
763  case CK_FunctionToPointerDecay:
764    return "FunctionToPointerDecay";
765  case CK_NullToMemberPointer:
766    return "NullToMemberPointer";
767  case CK_BaseToDerivedMemberPointer:
768    return "BaseToDerivedMemberPointer";
769  case CK_DerivedToBaseMemberPointer:
770    return "DerivedToBaseMemberPointer";
771  case CK_UserDefinedConversion:
772    return "UserDefinedConversion";
773  case CK_ConstructorConversion:
774    return "ConstructorConversion";
775  case CK_IntegralToPointer:
776    return "IntegralToPointer";
777  case CK_PointerToIntegral:
778    return "PointerToIntegral";
779  case CK_ToVoid:
780    return "ToVoid";
781  case CK_VectorSplat:
782    return "VectorSplat";
783  case CK_IntegralCast:
784    return "IntegralCast";
785  case CK_IntegralToFloating:
786    return "IntegralToFloating";
787  case CK_FloatingToIntegral:
788    return "FloatingToIntegral";
789  case CK_FloatingCast:
790    return "FloatingCast";
791  case CK_MemberPointerToBoolean:
792    return "MemberPointerToBoolean";
793  case CK_AnyPointerToObjCPointerCast:
794    return "AnyPointerToObjCPointerCast";
795  case CK_AnyPointerToBlockPointerCast:
796    return "AnyPointerToBlockPointerCast";
797  case CK_ObjCObjectLValueCast:
798    return "ObjCObjectLValueCast";
799  }
800
801  assert(0 && "Unhandled cast kind!");
802  return 0;
803}
804
805Expr *CastExpr::getSubExprAsWritten() {
806  Expr *SubExpr = 0;
807  CastExpr *E = this;
808  do {
809    SubExpr = E->getSubExpr();
810
811    // Skip any temporary bindings; they're implicit.
812    if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
813      SubExpr = Binder->getSubExpr();
814
815    // Conversions by constructor and conversion functions have a
816    // subexpression describing the call; strip it off.
817    if (E->getCastKind() == CK_ConstructorConversion)
818      SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
819    else if (E->getCastKind() == CK_UserDefinedConversion)
820      SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
821
822    // If the subexpression we're left with is an implicit cast, look
823    // through that, too.
824  } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
825
826  return SubExpr;
827}
828
829CXXBaseSpecifier **CastExpr::path_buffer() {
830  switch (getStmtClass()) {
831#define ABSTRACT_STMT(x)
832#define CASTEXPR(Type, Base) \
833  case Stmt::Type##Class: \
834    return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1);
835#define STMT(Type, Base)
836#include "clang/AST/StmtNodes.inc"
837  default:
838    llvm_unreachable("non-cast expressions not possible here");
839    return 0;
840  }
841}
842
843void CastExpr::setCastPath(const CXXCastPath &Path) {
844  assert(Path.size() == path_size());
845  memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*));
846}
847
848ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext &C, QualType T,
849                                           CastKind Kind, Expr *Operand,
850                                           const CXXCastPath *BasePath,
851                                           ExprValueKind VK) {
852  unsigned PathSize = (BasePath ? BasePath->size() : 0);
853  void *Buffer =
854    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
855  ImplicitCastExpr *E =
856    new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
857  if (PathSize) E->setCastPath(*BasePath);
858  return E;
859}
860
861ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext &C,
862                                                unsigned PathSize) {
863  void *Buffer =
864    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
865  return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
866}
867
868
869CStyleCastExpr *CStyleCastExpr::Create(ASTContext &C, QualType T,
870                                       CastKind K, Expr *Op,
871                                       const CXXCastPath *BasePath,
872                                       TypeSourceInfo *WrittenTy,
873                                       SourceLocation L, SourceLocation R) {
874  unsigned PathSize = (BasePath ? BasePath->size() : 0);
875  void *Buffer =
876    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
877  CStyleCastExpr *E =
878    new (Buffer) CStyleCastExpr(T, K, Op, PathSize, WrittenTy, L, R);
879  if (PathSize) E->setCastPath(*BasePath);
880  return E;
881}
882
883CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
884  void *Buffer =
885    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
886  return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize);
887}
888
889/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
890/// corresponds to, e.g. "<<=".
891const char *BinaryOperator::getOpcodeStr(Opcode Op) {
892  switch (Op) {
893  case BO_PtrMemD:   return ".*";
894  case BO_PtrMemI:   return "->*";
895  case BO_Mul:       return "*";
896  case BO_Div:       return "/";
897  case BO_Rem:       return "%";
898  case BO_Add:       return "+";
899  case BO_Sub:       return "-";
900  case BO_Shl:       return "<<";
901  case BO_Shr:       return ">>";
902  case BO_LT:        return "<";
903  case BO_GT:        return ">";
904  case BO_LE:        return "<=";
905  case BO_GE:        return ">=";
906  case BO_EQ:        return "==";
907  case BO_NE:        return "!=";
908  case BO_And:       return "&";
909  case BO_Xor:       return "^";
910  case BO_Or:        return "|";
911  case BO_LAnd:      return "&&";
912  case BO_LOr:       return "||";
913  case BO_Assign:    return "=";
914  case BO_MulAssign: return "*=";
915  case BO_DivAssign: return "/=";
916  case BO_RemAssign: return "%=";
917  case BO_AddAssign: return "+=";
918  case BO_SubAssign: return "-=";
919  case BO_ShlAssign: return "<<=";
920  case BO_ShrAssign: return ">>=";
921  case BO_AndAssign: return "&=";
922  case BO_XorAssign: return "^=";
923  case BO_OrAssign:  return "|=";
924  case BO_Comma:     return ",";
925  }
926
927  return "";
928}
929
930BinaryOperatorKind
931BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
932  switch (OO) {
933  default: assert(false && "Not an overloadable binary operator");
934  case OO_Plus: return BO_Add;
935  case OO_Minus: return BO_Sub;
936  case OO_Star: return BO_Mul;
937  case OO_Slash: return BO_Div;
938  case OO_Percent: return BO_Rem;
939  case OO_Caret: return BO_Xor;
940  case OO_Amp: return BO_And;
941  case OO_Pipe: return BO_Or;
942  case OO_Equal: return BO_Assign;
943  case OO_Less: return BO_LT;
944  case OO_Greater: return BO_GT;
945  case OO_PlusEqual: return BO_AddAssign;
946  case OO_MinusEqual: return BO_SubAssign;
947  case OO_StarEqual: return BO_MulAssign;
948  case OO_SlashEqual: return BO_DivAssign;
949  case OO_PercentEqual: return BO_RemAssign;
950  case OO_CaretEqual: return BO_XorAssign;
951  case OO_AmpEqual: return BO_AndAssign;
952  case OO_PipeEqual: return BO_OrAssign;
953  case OO_LessLess: return BO_Shl;
954  case OO_GreaterGreater: return BO_Shr;
955  case OO_LessLessEqual: return BO_ShlAssign;
956  case OO_GreaterGreaterEqual: return BO_ShrAssign;
957  case OO_EqualEqual: return BO_EQ;
958  case OO_ExclaimEqual: return BO_NE;
959  case OO_LessEqual: return BO_LE;
960  case OO_GreaterEqual: return BO_GE;
961  case OO_AmpAmp: return BO_LAnd;
962  case OO_PipePipe: return BO_LOr;
963  case OO_Comma: return BO_Comma;
964  case OO_ArrowStar: return BO_PtrMemI;
965  }
966}
967
968OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
969  static const OverloadedOperatorKind OverOps[] = {
970    /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
971    OO_Star, OO_Slash, OO_Percent,
972    OO_Plus, OO_Minus,
973    OO_LessLess, OO_GreaterGreater,
974    OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
975    OO_EqualEqual, OO_ExclaimEqual,
976    OO_Amp,
977    OO_Caret,
978    OO_Pipe,
979    OO_AmpAmp,
980    OO_PipePipe,
981    OO_Equal, OO_StarEqual,
982    OO_SlashEqual, OO_PercentEqual,
983    OO_PlusEqual, OO_MinusEqual,
984    OO_LessLessEqual, OO_GreaterGreaterEqual,
985    OO_AmpEqual, OO_CaretEqual,
986    OO_PipeEqual,
987    OO_Comma
988  };
989  return OverOps[Opc];
990}
991
992InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc,
993                           Expr **initExprs, unsigned numInits,
994                           SourceLocation rbraceloc)
995  : Expr(InitListExprClass, QualType(), false, false),
996    InitExprs(C, numInits),
997    LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
998    UnionFieldInit(0), HadArrayRangeDesignator(false)
999{
1000  for (unsigned I = 0; I != numInits; ++I) {
1001    if (initExprs[I]->isTypeDependent())
1002      TypeDependent = true;
1003    if (initExprs[I]->isValueDependent())
1004      ValueDependent = true;
1005  }
1006
1007  InitExprs.insert(C, InitExprs.end(), initExprs, initExprs+numInits);
1008}
1009
1010void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) {
1011  if (NumInits > InitExprs.size())
1012    InitExprs.reserve(C, NumInits);
1013}
1014
1015void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) {
1016  InitExprs.resize(C, NumInits, 0);
1017}
1018
1019Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) {
1020  if (Init >= InitExprs.size()) {
1021    InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0);
1022    InitExprs.back() = expr;
1023    return 0;
1024  }
1025
1026  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
1027  InitExprs[Init] = expr;
1028  return Result;
1029}
1030
1031/// getFunctionType - Return the underlying function type for this block.
1032///
1033const FunctionType *BlockExpr::getFunctionType() const {
1034  return getType()->getAs<BlockPointerType>()->
1035                    getPointeeType()->getAs<FunctionType>();
1036}
1037
1038SourceLocation BlockExpr::getCaretLocation() const {
1039  return TheBlock->getCaretLocation();
1040}
1041const Stmt *BlockExpr::getBody() const {
1042  return TheBlock->getBody();
1043}
1044Stmt *BlockExpr::getBody() {
1045  return TheBlock->getBody();
1046}
1047
1048
1049//===----------------------------------------------------------------------===//
1050// Generic Expression Routines
1051//===----------------------------------------------------------------------===//
1052
1053/// isUnusedResultAWarning - Return true if this immediate expression should
1054/// be warned about if the result is unused.  If so, fill in Loc and Ranges
1055/// with location to warn on and the source range[s] to report with the
1056/// warning.
1057bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
1058                                  SourceRange &R2, ASTContext &Ctx) const {
1059  // Don't warn if the expr is type dependent. The type could end up
1060  // instantiating to void.
1061  if (isTypeDependent())
1062    return false;
1063
1064  switch (getStmtClass()) {
1065  default:
1066    if (getType()->isVoidType())
1067      return false;
1068    Loc = getExprLoc();
1069    R1 = getSourceRange();
1070    return true;
1071  case ParenExprClass:
1072    return cast<ParenExpr>(this)->getSubExpr()->
1073      isUnusedResultAWarning(Loc, R1, R2, Ctx);
1074  case UnaryOperatorClass: {
1075    const UnaryOperator *UO = cast<UnaryOperator>(this);
1076
1077    switch (UO->getOpcode()) {
1078    default: break;
1079    case UO_PostInc:
1080    case UO_PostDec:
1081    case UO_PreInc:
1082    case UO_PreDec:                 // ++/--
1083      return false;  // Not a warning.
1084    case UO_Deref:
1085      // Dereferencing a volatile pointer is a side-effect.
1086      if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1087        return false;
1088      break;
1089    case UO_Real:
1090    case UO_Imag:
1091      // accessing a piece of a volatile complex is a side-effect.
1092      if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
1093          .isVolatileQualified())
1094        return false;
1095      break;
1096    case UO_Extension:
1097      return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1098    }
1099    Loc = UO->getOperatorLoc();
1100    R1 = UO->getSubExpr()->getSourceRange();
1101    return true;
1102  }
1103  case BinaryOperatorClass: {
1104    const BinaryOperator *BO = cast<BinaryOperator>(this);
1105    switch (BO->getOpcode()) {
1106      default:
1107        break;
1108      // Consider the RHS of comma for side effects. LHS was checked by
1109      // Sema::CheckCommaOperands.
1110      case BO_Comma:
1111        // ((foo = <blah>), 0) is an idiom for hiding the result (and
1112        // lvalue-ness) of an assignment written in a macro.
1113        if (IntegerLiteral *IE =
1114              dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
1115          if (IE->getValue() == 0)
1116            return false;
1117        return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1118      // Consider '||', '&&' to have side effects if the LHS or RHS does.
1119      case BO_LAnd:
1120      case BO_LOr:
1121        if (!BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx) ||
1122            !BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1123          return false;
1124        break;
1125    }
1126    if (BO->isAssignmentOp())
1127      return false;
1128    Loc = BO->getOperatorLoc();
1129    R1 = BO->getLHS()->getSourceRange();
1130    R2 = BO->getRHS()->getSourceRange();
1131    return true;
1132  }
1133  case CompoundAssignOperatorClass:
1134  case VAArgExprClass:
1135    return false;
1136
1137  case ConditionalOperatorClass: {
1138    // The condition must be evaluated, but if either the LHS or RHS is a
1139    // warning, warn about them.
1140    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1141    if (Exp->getLHS() &&
1142        Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1143      return true;
1144    return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1145  }
1146
1147  case MemberExprClass:
1148    // If the base pointer or element is to a volatile pointer/field, accessing
1149    // it is a side effect.
1150    if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1151      return false;
1152    Loc = cast<MemberExpr>(this)->getMemberLoc();
1153    R1 = SourceRange(Loc, Loc);
1154    R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
1155    return true;
1156
1157  case ArraySubscriptExprClass:
1158    // If the base pointer or element is to a volatile pointer/field, accessing
1159    // it is a side effect.
1160    if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1161      return false;
1162    Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
1163    R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
1164    R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
1165    return true;
1166
1167  case CallExprClass:
1168  case CXXOperatorCallExprClass:
1169  case CXXMemberCallExprClass: {
1170    // If this is a direct call, get the callee.
1171    const CallExpr *CE = cast<CallExpr>(this);
1172    if (const Decl *FD = CE->getCalleeDecl()) {
1173      // If the callee has attribute pure, const, or warn_unused_result, warn
1174      // about it. void foo() { strlen("bar"); } should warn.
1175      //
1176      // Note: If new cases are added here, DiagnoseUnusedExprResult should be
1177      // updated to match for QoI.
1178      if (FD->getAttr<WarnUnusedResultAttr>() ||
1179          FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
1180        Loc = CE->getCallee()->getLocStart();
1181        R1 = CE->getCallee()->getSourceRange();
1182
1183        if (unsigned NumArgs = CE->getNumArgs())
1184          R2 = SourceRange(CE->getArg(0)->getLocStart(),
1185                           CE->getArg(NumArgs-1)->getLocEnd());
1186        return true;
1187      }
1188    }
1189    return false;
1190  }
1191
1192  case CXXTemporaryObjectExprClass:
1193  case CXXConstructExprClass:
1194    return false;
1195
1196  case ObjCMessageExprClass: {
1197    const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
1198    const ObjCMethodDecl *MD = ME->getMethodDecl();
1199    if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
1200      Loc = getExprLoc();
1201      return true;
1202    }
1203    return false;
1204  }
1205
1206  case ObjCImplicitSetterGetterRefExprClass: {   // Dot syntax for message send.
1207#if 0
1208    const ObjCImplicitSetterGetterRefExpr *Ref =
1209      cast<ObjCImplicitSetterGetterRefExpr>(this);
1210    // FIXME: We really want the location of the '.' here.
1211    Loc = Ref->getLocation();
1212    R1 = SourceRange(Ref->getLocation(), Ref->getLocation());
1213    if (Ref->getBase())
1214      R2 = Ref->getBase()->getSourceRange();
1215#else
1216    Loc = getExprLoc();
1217    R1 = getSourceRange();
1218#endif
1219    return true;
1220  }
1221  case StmtExprClass: {
1222    // Statement exprs don't logically have side effects themselves, but are
1223    // sometimes used in macros in ways that give them a type that is unused.
1224    // For example ({ blah; foo(); }) will end up with a type if foo has a type.
1225    // however, if the result of the stmt expr is dead, we don't want to emit a
1226    // warning.
1227    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
1228    if (!CS->body_empty())
1229      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
1230        return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1231
1232    if (getType()->isVoidType())
1233      return false;
1234    Loc = cast<StmtExpr>(this)->getLParenLoc();
1235    R1 = getSourceRange();
1236    return true;
1237  }
1238  case CStyleCastExprClass:
1239    // If this is an explicit cast to void, allow it.  People do this when they
1240    // think they know what they're doing :).
1241    if (getType()->isVoidType())
1242      return false;
1243    Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
1244    R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
1245    return true;
1246  case CXXFunctionalCastExprClass: {
1247    if (getType()->isVoidType())
1248      return false;
1249    const CastExpr *CE = cast<CastExpr>(this);
1250
1251    // If this is a cast to void or a constructor conversion, check the operand.
1252    // Otherwise, the result of the cast is unused.
1253    if (CE->getCastKind() == CK_ToVoid ||
1254        CE->getCastKind() == CK_ConstructorConversion)
1255      return (cast<CastExpr>(this)->getSubExpr()
1256              ->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1257    Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
1258    R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
1259    return true;
1260  }
1261
1262  case ImplicitCastExprClass:
1263    // Check the operand, since implicit casts are inserted by Sema
1264    return (cast<ImplicitCastExpr>(this)
1265            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1266
1267  case CXXDefaultArgExprClass:
1268    return (cast<CXXDefaultArgExpr>(this)
1269            ->getExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1270
1271  case CXXNewExprClass:
1272    // FIXME: In theory, there might be new expressions that don't have side
1273    // effects (e.g. a placement new with an uninitialized POD).
1274  case CXXDeleteExprClass:
1275    return false;
1276  case CXXBindTemporaryExprClass:
1277    return (cast<CXXBindTemporaryExpr>(this)
1278            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1279  case CXXExprWithTemporariesClass:
1280    return (cast<CXXExprWithTemporaries>(this)
1281            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1282  }
1283}
1284
1285/// isOBJCGCCandidate - Check if an expression is objc gc'able.
1286/// returns true, if it is; false otherwise.
1287bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
1288  switch (getStmtClass()) {
1289  default:
1290    return false;
1291  case ObjCIvarRefExprClass:
1292    return true;
1293  case Expr::UnaryOperatorClass:
1294    return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1295  case ParenExprClass:
1296    return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1297  case ImplicitCastExprClass:
1298    return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1299  case CStyleCastExprClass:
1300    return cast<CStyleCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1301  case DeclRefExprClass: {
1302    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
1303    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1304      if (VD->hasGlobalStorage())
1305        return true;
1306      QualType T = VD->getType();
1307      // dereferencing to a  pointer is always a gc'able candidate,
1308      // unless it is __weak.
1309      return T->isPointerType() &&
1310             (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
1311    }
1312    return false;
1313  }
1314  case MemberExprClass: {
1315    const MemberExpr *M = cast<MemberExpr>(this);
1316    return M->getBase()->isOBJCGCCandidate(Ctx);
1317  }
1318  case ArraySubscriptExprClass:
1319    return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(Ctx);
1320  }
1321}
1322Expr* Expr::IgnoreParens() {
1323  Expr* E = this;
1324  while (ParenExpr* P = dyn_cast<ParenExpr>(E))
1325    E = P->getSubExpr();
1326
1327  return E;
1328}
1329
1330/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
1331/// or CastExprs or ImplicitCastExprs, returning their operand.
1332Expr *Expr::IgnoreParenCasts() {
1333  Expr *E = this;
1334  while (true) {
1335    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
1336      E = P->getSubExpr();
1337    else if (CastExpr *P = dyn_cast<CastExpr>(E))
1338      E = P->getSubExpr();
1339    else
1340      return E;
1341  }
1342}
1343
1344Expr *Expr::IgnoreParenImpCasts() {
1345  Expr *E = this;
1346  while (true) {
1347    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
1348      E = P->getSubExpr();
1349    else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E))
1350      E = P->getSubExpr();
1351    else
1352      return E;
1353  }
1354}
1355
1356/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
1357/// value (including ptr->int casts of the same size).  Strip off any
1358/// ParenExpr or CastExprs, returning their operand.
1359Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
1360  Expr *E = this;
1361  while (true) {
1362    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1363      E = P->getSubExpr();
1364      continue;
1365    }
1366
1367    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1368      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
1369      // ptr<->int casts of the same width.  We also ignore all identity casts.
1370      Expr *SE = P->getSubExpr();
1371
1372      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
1373        E = SE;
1374        continue;
1375      }
1376
1377      if ((E->getType()->isPointerType() ||
1378           E->getType()->isIntegralType(Ctx)) &&
1379          (SE->getType()->isPointerType() ||
1380           SE->getType()->isIntegralType(Ctx)) &&
1381          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
1382        E = SE;
1383        continue;
1384      }
1385    }
1386
1387    return E;
1388  }
1389}
1390
1391bool Expr::isDefaultArgument() const {
1392  const Expr *E = this;
1393  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
1394    E = ICE->getSubExprAsWritten();
1395
1396  return isa<CXXDefaultArgExpr>(E);
1397}
1398
1399/// \brief Skip over any no-op casts and any temporary-binding
1400/// expressions.
1401static const Expr *skipTemporaryBindingsAndNoOpCasts(const Expr *E) {
1402  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1403    if (ICE->getCastKind() == CK_NoOp)
1404      E = ICE->getSubExpr();
1405    else
1406      break;
1407  }
1408
1409  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
1410    E = BE->getSubExpr();
1411
1412  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1413    if (ICE->getCastKind() == CK_NoOp)
1414      E = ICE->getSubExpr();
1415    else
1416      break;
1417  }
1418
1419  return E;
1420}
1421
1422const Expr *Expr::getTemporaryObject() const {
1423  const Expr *E = skipTemporaryBindingsAndNoOpCasts(this);
1424
1425  // A cast can produce a temporary object. The object's construction
1426  // is represented as a CXXConstructExpr.
1427  if (const CastExpr *Cast = dyn_cast<CastExpr>(E)) {
1428    // Only user-defined and constructor conversions can produce
1429    // temporary objects.
1430    if (Cast->getCastKind() != CK_ConstructorConversion &&
1431        Cast->getCastKind() != CK_UserDefinedConversion)
1432      return 0;
1433
1434    // Strip off temporary bindings and no-op casts.
1435    const Expr *Sub = skipTemporaryBindingsAndNoOpCasts(Cast->getSubExpr());
1436
1437    // If this is a constructor conversion, see if we have an object
1438    // construction.
1439    if (Cast->getCastKind() == CK_ConstructorConversion)
1440      return dyn_cast<CXXConstructExpr>(Sub);
1441
1442    // If this is a user-defined conversion, see if we have a call to
1443    // a function that itself returns a temporary object.
1444    if (Cast->getCastKind() == CK_UserDefinedConversion)
1445      if (const CallExpr *CE = dyn_cast<CallExpr>(Sub))
1446        if (CE->getCallReturnType()->isRecordType())
1447          return CE;
1448
1449    return 0;
1450  }
1451
1452  // A call returning a class type returns a temporary.
1453  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1454    if (CE->getCallReturnType()->isRecordType())
1455      return CE;
1456
1457    return 0;
1458  }
1459
1460  // Explicit temporary object constructors create temporaries.
1461  return dyn_cast<CXXTemporaryObjectExpr>(E);
1462}
1463
1464/// hasAnyTypeDependentArguments - Determines if any of the expressions
1465/// in Exprs is type-dependent.
1466bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
1467  for (unsigned I = 0; I < NumExprs; ++I)
1468    if (Exprs[I]->isTypeDependent())
1469      return true;
1470
1471  return false;
1472}
1473
1474/// hasAnyValueDependentArguments - Determines if any of the expressions
1475/// in Exprs is value-dependent.
1476bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
1477  for (unsigned I = 0; I < NumExprs; ++I)
1478    if (Exprs[I]->isValueDependent())
1479      return true;
1480
1481  return false;
1482}
1483
1484bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const {
1485  // This function is attempting whether an expression is an initializer
1486  // which can be evaluated at compile-time.  isEvaluatable handles most
1487  // of the cases, but it can't deal with some initializer-specific
1488  // expressions, and it can't deal with aggregates; we deal with those here,
1489  // and fall back to isEvaluatable for the other cases.
1490
1491  // If we ever capture reference-binding directly in the AST, we can
1492  // kill the second parameter.
1493
1494  if (IsForRef) {
1495    EvalResult Result;
1496    return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects;
1497  }
1498
1499  switch (getStmtClass()) {
1500  default: break;
1501  case StringLiteralClass:
1502  case ObjCStringLiteralClass:
1503  case ObjCEncodeExprClass:
1504    return true;
1505  case CXXTemporaryObjectExprClass:
1506  case CXXConstructExprClass: {
1507    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
1508
1509    // Only if it's
1510    // 1) an application of the trivial default constructor or
1511    if (!CE->getConstructor()->isTrivial()) return false;
1512    if (!CE->getNumArgs()) return true;
1513
1514    // 2) an elidable trivial copy construction of an operand which is
1515    //    itself a constant initializer.  Note that we consider the
1516    //    operand on its own, *not* as a reference binding.
1517    return CE->isElidable() &&
1518           CE->getArg(0)->isConstantInitializer(Ctx, false);
1519  }
1520  case CompoundLiteralExprClass: {
1521    // This handles gcc's extension that allows global initializers like
1522    // "struct x {int x;} x = (struct x) {};".
1523    // FIXME: This accepts other cases it shouldn't!
1524    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
1525    return Exp->isConstantInitializer(Ctx, false);
1526  }
1527  case InitListExprClass: {
1528    // FIXME: This doesn't deal with fields with reference types correctly.
1529    // FIXME: This incorrectly allows pointers cast to integers to be assigned
1530    // to bitfields.
1531    const InitListExpr *Exp = cast<InitListExpr>(this);
1532    unsigned numInits = Exp->getNumInits();
1533    for (unsigned i = 0; i < numInits; i++) {
1534      if (!Exp->getInit(i)->isConstantInitializer(Ctx, false))
1535        return false;
1536    }
1537    return true;
1538  }
1539  case ImplicitValueInitExprClass:
1540    return true;
1541  case ParenExprClass:
1542    return cast<ParenExpr>(this)->getSubExpr()
1543      ->isConstantInitializer(Ctx, IsForRef);
1544  case UnaryOperatorClass: {
1545    const UnaryOperator* Exp = cast<UnaryOperator>(this);
1546    if (Exp->getOpcode() == UO_Extension)
1547      return Exp->getSubExpr()->isConstantInitializer(Ctx, false);
1548    break;
1549  }
1550  case BinaryOperatorClass: {
1551    // Special case &&foo - &&bar.  It would be nice to generalize this somehow
1552    // but this handles the common case.
1553    const BinaryOperator *Exp = cast<BinaryOperator>(this);
1554    if (Exp->getOpcode() == BO_Sub &&
1555        isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) &&
1556        isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx)))
1557      return true;
1558    break;
1559  }
1560  case CXXFunctionalCastExprClass:
1561  case CXXStaticCastExprClass:
1562  case ImplicitCastExprClass:
1563  case CStyleCastExprClass:
1564    // Handle casts with a destination that's a struct or union; this
1565    // deals with both the gcc no-op struct cast extension and the
1566    // cast-to-union extension.
1567    if (getType()->isRecordType())
1568      return cast<CastExpr>(this)->getSubExpr()
1569        ->isConstantInitializer(Ctx, false);
1570
1571    // Integer->integer casts can be handled here, which is important for
1572    // things like (int)(&&x-&&y).  Scary but true.
1573    if (getType()->isIntegerType() &&
1574        cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType())
1575      return cast<CastExpr>(this)->getSubExpr()
1576        ->isConstantInitializer(Ctx, false);
1577
1578    break;
1579  }
1580  return isEvaluatable(Ctx);
1581}
1582
1583/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1584/// integer constant expression with the value zero, or if this is one that is
1585/// cast to void*.
1586bool Expr::isNullPointerConstant(ASTContext &Ctx,
1587                                 NullPointerConstantValueDependence NPC) const {
1588  if (isValueDependent()) {
1589    switch (NPC) {
1590    case NPC_NeverValueDependent:
1591      assert(false && "Unexpected value dependent expression!");
1592      // If the unthinkable happens, fall through to the safest alternative.
1593
1594    case NPC_ValueDependentIsNull:
1595      return isTypeDependent() || getType()->isIntegralType(Ctx);
1596
1597    case NPC_ValueDependentIsNotNull:
1598      return false;
1599    }
1600  }
1601
1602  // Strip off a cast to void*, if it exists. Except in C++.
1603  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1604    if (!Ctx.getLangOptions().CPlusPlus) {
1605      // Check that it is a cast to void*.
1606      if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
1607        QualType Pointee = PT->getPointeeType();
1608        if (!Pointee.hasQualifiers() &&
1609            Pointee->isVoidType() &&                              // to void*
1610            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1611          return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1612      }
1613    }
1614  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1615    // Ignore the ImplicitCastExpr type entirely.
1616    return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1617  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1618    // Accept ((void*)0) as a null pointer constant, as many other
1619    // implementations do.
1620    return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1621  } else if (const CXXDefaultArgExpr *DefaultArg
1622               = dyn_cast<CXXDefaultArgExpr>(this)) {
1623    // See through default argument expressions
1624    return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
1625  } else if (isa<GNUNullExpr>(this)) {
1626    // The GNU __null extension is always a null pointer constant.
1627    return true;
1628  }
1629
1630  // C++0x nullptr_t is always a null pointer constant.
1631  if (getType()->isNullPtrType())
1632    return true;
1633
1634  // This expression must be an integer type.
1635  if (!getType()->isIntegerType() ||
1636      (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType()))
1637    return false;
1638
1639  // If we have an integer constant expression, we need to *evaluate* it and
1640  // test for the value 0.
1641  llvm::APSInt Result;
1642  return isIntegerConstantExpr(Result, Ctx) && Result == 0;
1643}
1644
1645FieldDecl *Expr::getBitField() {
1646  Expr *E = this->IgnoreParens();
1647
1648  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1649    if (ICE->getValueKind() != VK_RValue &&
1650        ICE->getCastKind() == CK_NoOp)
1651      E = ICE->getSubExpr()->IgnoreParens();
1652    else
1653      break;
1654  }
1655
1656  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1657    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1658      if (Field->isBitField())
1659        return Field;
1660
1661  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E))
1662    if (BinOp->isAssignmentOp() && BinOp->getLHS())
1663      return BinOp->getLHS()->getBitField();
1664
1665  return 0;
1666}
1667
1668bool Expr::refersToVectorElement() const {
1669  const Expr *E = this->IgnoreParens();
1670
1671  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1672    if (ICE->getValueKind() != VK_RValue &&
1673        ICE->getCastKind() == CK_NoOp)
1674      E = ICE->getSubExpr()->IgnoreParens();
1675    else
1676      break;
1677  }
1678
1679  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
1680    return ASE->getBase()->getType()->isVectorType();
1681
1682  if (isa<ExtVectorElementExpr>(E))
1683    return true;
1684
1685  return false;
1686}
1687
1688/// isArrow - Return true if the base expression is a pointer to vector,
1689/// return false if the base expression is a vector.
1690bool ExtVectorElementExpr::isArrow() const {
1691  return getBase()->getType()->isPointerType();
1692}
1693
1694unsigned ExtVectorElementExpr::getNumElements() const {
1695  if (const VectorType *VT = getType()->getAs<VectorType>())
1696    return VT->getNumElements();
1697  return 1;
1698}
1699
1700/// containsDuplicateElements - Return true if any element access is repeated.
1701bool ExtVectorElementExpr::containsDuplicateElements() const {
1702  // FIXME: Refactor this code to an accessor on the AST node which returns the
1703  // "type" of component access, and share with code below and in Sema.
1704  llvm::StringRef Comp = Accessor->getName();
1705
1706  // Halving swizzles do not contain duplicate elements.
1707  if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
1708    return false;
1709
1710  // Advance past s-char prefix on hex swizzles.
1711  if (Comp[0] == 's' || Comp[0] == 'S')
1712    Comp = Comp.substr(1);
1713
1714  for (unsigned i = 0, e = Comp.size(); i != e; ++i)
1715    if (Comp.substr(i + 1).find(Comp[i]) != llvm::StringRef::npos)
1716        return true;
1717
1718  return false;
1719}
1720
1721/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1722void ExtVectorElementExpr::getEncodedElementAccess(
1723                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1724  llvm::StringRef Comp = Accessor->getName();
1725  if (Comp[0] == 's' || Comp[0] == 'S')
1726    Comp = Comp.substr(1);
1727
1728  bool isHi =   Comp == "hi";
1729  bool isLo =   Comp == "lo";
1730  bool isEven = Comp == "even";
1731  bool isOdd  = Comp == "odd";
1732
1733  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1734    uint64_t Index;
1735
1736    if (isHi)
1737      Index = e + i;
1738    else if (isLo)
1739      Index = i;
1740    else if (isEven)
1741      Index = 2 * i;
1742    else if (isOdd)
1743      Index = 2 * i + 1;
1744    else
1745      Index = ExtVectorType::getAccessorIdx(Comp[i]);
1746
1747    Elts.push_back(Index);
1748  }
1749}
1750
1751ObjCMessageExpr::ObjCMessageExpr(QualType T,
1752                                 SourceLocation LBracLoc,
1753                                 SourceLocation SuperLoc,
1754                                 bool IsInstanceSuper,
1755                                 QualType SuperType,
1756                                 Selector Sel,
1757                                 ObjCMethodDecl *Method,
1758                                 Expr **Args, unsigned NumArgs,
1759                                 SourceLocation RBracLoc)
1760  : Expr(ObjCMessageExprClass, T, /*TypeDependent=*/false,
1761         /*ValueDependent=*/false),
1762    NumArgs(NumArgs), Kind(IsInstanceSuper? SuperInstance : SuperClass),
1763    HasMethod(Method != 0), SuperLoc(SuperLoc),
1764    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
1765                                                       : Sel.getAsOpaquePtr())),
1766    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
1767{
1768  setReceiverPointer(SuperType.getAsOpaquePtr());
1769  if (NumArgs)
1770    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
1771}
1772
1773ObjCMessageExpr::ObjCMessageExpr(QualType T,
1774                                 SourceLocation LBracLoc,
1775                                 TypeSourceInfo *Receiver,
1776                                 Selector Sel,
1777                                 ObjCMethodDecl *Method,
1778                                 Expr **Args, unsigned NumArgs,
1779                                 SourceLocation RBracLoc)
1780  : Expr(ObjCMessageExprClass, T, T->isDependentType(),
1781         (T->isDependentType() ||
1782          hasAnyValueDependentArguments(Args, NumArgs))),
1783    NumArgs(NumArgs), Kind(Class), HasMethod(Method != 0),
1784    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
1785                                                       : Sel.getAsOpaquePtr())),
1786    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
1787{
1788  setReceiverPointer(Receiver);
1789  if (NumArgs)
1790    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
1791}
1792
1793ObjCMessageExpr::ObjCMessageExpr(QualType T,
1794                                 SourceLocation LBracLoc,
1795                                 Expr *Receiver,
1796                                 Selector Sel,
1797                                 ObjCMethodDecl *Method,
1798                                 Expr **Args, unsigned NumArgs,
1799                                 SourceLocation RBracLoc)
1800  : Expr(ObjCMessageExprClass, T, Receiver->isTypeDependent(),
1801         (Receiver->isTypeDependent() ||
1802          hasAnyValueDependentArguments(Args, NumArgs))),
1803    NumArgs(NumArgs), Kind(Instance), HasMethod(Method != 0),
1804    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
1805                                                       : Sel.getAsOpaquePtr())),
1806    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
1807{
1808  setReceiverPointer(Receiver);
1809  if (NumArgs)
1810    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
1811}
1812
1813ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
1814                                         SourceLocation LBracLoc,
1815                                         SourceLocation SuperLoc,
1816                                         bool IsInstanceSuper,
1817                                         QualType SuperType,
1818                                         Selector Sel,
1819                                         ObjCMethodDecl *Method,
1820                                         Expr **Args, unsigned NumArgs,
1821                                         SourceLocation RBracLoc) {
1822  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
1823    NumArgs * sizeof(Expr *);
1824  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
1825  return new (Mem) ObjCMessageExpr(T, LBracLoc, SuperLoc, IsInstanceSuper,
1826                                   SuperType, Sel, Method, Args, NumArgs,
1827                                   RBracLoc);
1828}
1829
1830ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
1831                                         SourceLocation LBracLoc,
1832                                         TypeSourceInfo *Receiver,
1833                                         Selector Sel,
1834                                         ObjCMethodDecl *Method,
1835                                         Expr **Args, unsigned NumArgs,
1836                                         SourceLocation RBracLoc) {
1837  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
1838    NumArgs * sizeof(Expr *);
1839  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
1840  return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args,
1841                                   NumArgs, RBracLoc);
1842}
1843
1844ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
1845                                         SourceLocation LBracLoc,
1846                                         Expr *Receiver,
1847                                         Selector Sel,
1848                                         ObjCMethodDecl *Method,
1849                                         Expr **Args, unsigned NumArgs,
1850                                         SourceLocation RBracLoc) {
1851  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
1852    NumArgs * sizeof(Expr *);
1853  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
1854  return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args,
1855                                   NumArgs, RBracLoc);
1856}
1857
1858ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context,
1859                                              unsigned NumArgs) {
1860  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
1861    NumArgs * sizeof(Expr *);
1862  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
1863  return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
1864}
1865
1866Selector ObjCMessageExpr::getSelector() const {
1867  if (HasMethod)
1868    return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
1869                                                               ->getSelector();
1870  return Selector(SelectorOrMethod);
1871}
1872
1873ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
1874  switch (getReceiverKind()) {
1875  case Instance:
1876    if (const ObjCObjectPointerType *Ptr
1877          = getInstanceReceiver()->getType()->getAs<ObjCObjectPointerType>())
1878      return Ptr->getInterfaceDecl();
1879    break;
1880
1881  case Class:
1882    if (const ObjCObjectType *Ty
1883          = getClassReceiver()->getAs<ObjCObjectType>())
1884      return Ty->getInterface();
1885    break;
1886
1887  case SuperInstance:
1888    if (const ObjCObjectPointerType *Ptr
1889          = getSuperType()->getAs<ObjCObjectPointerType>())
1890      return Ptr->getInterfaceDecl();
1891    break;
1892
1893  case SuperClass:
1894    if (const ObjCObjectPointerType *Iface
1895                       = getSuperType()->getAs<ObjCObjectPointerType>())
1896      return Iface->getInterfaceDecl();
1897    break;
1898  }
1899
1900  return 0;
1901}
1902
1903bool ChooseExpr::isConditionTrue(ASTContext &C) const {
1904  return getCond()->EvaluateAsInt(C) != 0;
1905}
1906
1907void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
1908                                 unsigned NumExprs) {
1909  if (SubExprs) C.Deallocate(SubExprs);
1910
1911  SubExprs = new (C) Stmt* [NumExprs];
1912  this->NumExprs = NumExprs;
1913  memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
1914}
1915
1916//===----------------------------------------------------------------------===//
1917//  DesignatedInitExpr
1918//===----------------------------------------------------------------------===//
1919
1920IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
1921  assert(Kind == FieldDesignator && "Only valid on a field designator");
1922  if (Field.NameOrField & 0x01)
1923    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
1924  else
1925    return getField()->getIdentifier();
1926}
1927
1928DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
1929                                       unsigned NumDesignators,
1930                                       const Designator *Designators,
1931                                       SourceLocation EqualOrColonLoc,
1932                                       bool GNUSyntax,
1933                                       Expr **IndexExprs,
1934                                       unsigned NumIndexExprs,
1935                                       Expr *Init)
1936  : Expr(DesignatedInitExprClass, Ty,
1937         Init->isTypeDependent(), Init->isValueDependent()),
1938    EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
1939    NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
1940  this->Designators = new (C) Designator[NumDesignators];
1941
1942  // Record the initializer itself.
1943  child_iterator Child = child_begin();
1944  *Child++ = Init;
1945
1946  // Copy the designators and their subexpressions, computing
1947  // value-dependence along the way.
1948  unsigned IndexIdx = 0;
1949  for (unsigned I = 0; I != NumDesignators; ++I) {
1950    this->Designators[I] = Designators[I];
1951
1952    if (this->Designators[I].isArrayDesignator()) {
1953      // Compute type- and value-dependence.
1954      Expr *Index = IndexExprs[IndexIdx];
1955      ValueDependent = ValueDependent ||
1956        Index->isTypeDependent() || Index->isValueDependent();
1957
1958      // Copy the index expressions into permanent storage.
1959      *Child++ = IndexExprs[IndexIdx++];
1960    } else if (this->Designators[I].isArrayRangeDesignator()) {
1961      // Compute type- and value-dependence.
1962      Expr *Start = IndexExprs[IndexIdx];
1963      Expr *End = IndexExprs[IndexIdx + 1];
1964      ValueDependent = ValueDependent ||
1965        Start->isTypeDependent() || Start->isValueDependent() ||
1966        End->isTypeDependent() || End->isValueDependent();
1967
1968      // Copy the start/end expressions into permanent storage.
1969      *Child++ = IndexExprs[IndexIdx++];
1970      *Child++ = IndexExprs[IndexIdx++];
1971    }
1972  }
1973
1974  assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
1975}
1976
1977DesignatedInitExpr *
1978DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
1979                           unsigned NumDesignators,
1980                           Expr **IndexExprs, unsigned NumIndexExprs,
1981                           SourceLocation ColonOrEqualLoc,
1982                           bool UsesColonSyntax, Expr *Init) {
1983  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1984                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1985  return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
1986                                      ColonOrEqualLoc, UsesColonSyntax,
1987                                      IndexExprs, NumIndexExprs, Init);
1988}
1989
1990DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
1991                                                    unsigned NumIndexExprs) {
1992  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
1993                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
1994  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
1995}
1996
1997void DesignatedInitExpr::setDesignators(ASTContext &C,
1998                                        const Designator *Desigs,
1999                                        unsigned NumDesigs) {
2000  Designators = new (C) Designator[NumDesigs];
2001  NumDesignators = NumDesigs;
2002  for (unsigned I = 0; I != NumDesigs; ++I)
2003    Designators[I] = Desigs[I];
2004}
2005
2006SourceRange DesignatedInitExpr::getSourceRange() const {
2007  SourceLocation StartLoc;
2008  Designator &First =
2009    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
2010  if (First.isFieldDesignator()) {
2011    if (GNUSyntax)
2012      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
2013    else
2014      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
2015  } else
2016    StartLoc =
2017      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
2018  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
2019}
2020
2021Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
2022  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
2023  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2024  Ptr += sizeof(DesignatedInitExpr);
2025  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2026  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2027}
2028
2029Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
2030  assert(D.Kind == Designator::ArrayRangeDesignator &&
2031         "Requires array range designator");
2032  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2033  Ptr += sizeof(DesignatedInitExpr);
2034  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2035  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2036}
2037
2038Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
2039  assert(D.Kind == Designator::ArrayRangeDesignator &&
2040         "Requires array range designator");
2041  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2042  Ptr += sizeof(DesignatedInitExpr);
2043  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2044  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
2045}
2046
2047/// \brief Replaces the designator at index @p Idx with the series
2048/// of designators in [First, Last).
2049void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
2050                                          const Designator *First,
2051                                          const Designator *Last) {
2052  unsigned NumNewDesignators = Last - First;
2053  if (NumNewDesignators == 0) {
2054    std::copy_backward(Designators + Idx + 1,
2055                       Designators + NumDesignators,
2056                       Designators + Idx);
2057    --NumNewDesignators;
2058    return;
2059  } else if (NumNewDesignators == 1) {
2060    Designators[Idx] = *First;
2061    return;
2062  }
2063
2064  Designator *NewDesignators
2065    = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
2066  std::copy(Designators, Designators + Idx, NewDesignators);
2067  std::copy(First, Last, NewDesignators + Idx);
2068  std::copy(Designators + Idx + 1, Designators + NumDesignators,
2069            NewDesignators + Idx + NumNewDesignators);
2070  Designators = NewDesignators;
2071  NumDesignators = NumDesignators - 1 + NumNewDesignators;
2072}
2073
2074ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
2075                             Expr **exprs, unsigned nexprs,
2076                             SourceLocation rparenloc)
2077: Expr(ParenListExprClass, QualType(),
2078       hasAnyTypeDependentArguments(exprs, nexprs),
2079       hasAnyValueDependentArguments(exprs, nexprs)),
2080  NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
2081
2082  Exprs = new (C) Stmt*[nexprs];
2083  for (unsigned i = 0; i != nexprs; ++i)
2084    Exprs[i] = exprs[i];
2085}
2086
2087//===----------------------------------------------------------------------===//
2088//  ExprIterator.
2089//===----------------------------------------------------------------------===//
2090
2091Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
2092Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
2093Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
2094const Expr* ConstExprIterator::operator[](size_t idx) const {
2095  return cast<Expr>(I[idx]);
2096}
2097const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
2098const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
2099
2100//===----------------------------------------------------------------------===//
2101//  Child Iterators for iterating over subexpressions/substatements
2102//===----------------------------------------------------------------------===//
2103
2104// DeclRefExpr
2105Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
2106Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
2107
2108// ObjCIvarRefExpr
2109Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
2110Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
2111
2112// ObjCPropertyRefExpr
2113Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
2114Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
2115
2116// ObjCImplicitSetterGetterRefExpr
2117Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() {
2118  // If this is accessing a class member, skip that entry.
2119  if (Base) return &Base;
2120  return &Base+1;
2121}
2122Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() {
2123  return &Base+1;
2124}
2125
2126// ObjCSuperExpr
2127Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
2128Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
2129
2130// ObjCIsaExpr
2131Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; }
2132Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; }
2133
2134// PredefinedExpr
2135Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
2136Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
2137
2138// IntegerLiteral
2139Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
2140Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
2141
2142// CharacterLiteral
2143Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
2144Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
2145
2146// FloatingLiteral
2147Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
2148Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
2149
2150// ImaginaryLiteral
2151Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
2152Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
2153
2154// StringLiteral
2155Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
2156Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
2157
2158// ParenExpr
2159Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
2160Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
2161
2162// UnaryOperator
2163Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
2164Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
2165
2166// OffsetOfExpr
2167Stmt::child_iterator OffsetOfExpr::child_begin() {
2168  return reinterpret_cast<Stmt **> (reinterpret_cast<OffsetOfNode *> (this + 1)
2169                                      + NumComps);
2170}
2171Stmt::child_iterator OffsetOfExpr::child_end() {
2172  return child_iterator(&*child_begin() + NumExprs);
2173}
2174
2175// SizeOfAlignOfExpr
2176Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
2177  // If this is of a type and the type is a VLA type (and not a typedef), the
2178  // size expression of the VLA needs to be treated as an executable expression.
2179  // Why isn't this weirdness documented better in StmtIterator?
2180  if (isArgumentType()) {
2181    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
2182                                   getArgumentType().getTypePtr()))
2183      return child_iterator(T);
2184    return child_iterator();
2185  }
2186  return child_iterator(&Argument.Ex);
2187}
2188Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
2189  if (isArgumentType())
2190    return child_iterator();
2191  return child_iterator(&Argument.Ex + 1);
2192}
2193
2194// ArraySubscriptExpr
2195Stmt::child_iterator ArraySubscriptExpr::child_begin() {
2196  return &SubExprs[0];
2197}
2198Stmt::child_iterator ArraySubscriptExpr::child_end() {
2199  return &SubExprs[0]+END_EXPR;
2200}
2201
2202// CallExpr
2203Stmt::child_iterator CallExpr::child_begin() {
2204  return &SubExprs[0];
2205}
2206Stmt::child_iterator CallExpr::child_end() {
2207  return &SubExprs[0]+NumArgs+ARGS_START;
2208}
2209
2210// MemberExpr
2211Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
2212Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
2213
2214// ExtVectorElementExpr
2215Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
2216Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
2217
2218// CompoundLiteralExpr
2219Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
2220Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
2221
2222// CastExpr
2223Stmt::child_iterator CastExpr::child_begin() { return &Op; }
2224Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
2225
2226// BinaryOperator
2227Stmt::child_iterator BinaryOperator::child_begin() {
2228  return &SubExprs[0];
2229}
2230Stmt::child_iterator BinaryOperator::child_end() {
2231  return &SubExprs[0]+END_EXPR;
2232}
2233
2234// ConditionalOperator
2235Stmt::child_iterator ConditionalOperator::child_begin() {
2236  return &SubExprs[0];
2237}
2238Stmt::child_iterator ConditionalOperator::child_end() {
2239  return &SubExprs[0]+END_EXPR;
2240}
2241
2242// AddrLabelExpr
2243Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
2244Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
2245
2246// StmtExpr
2247Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
2248Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
2249
2250// TypesCompatibleExpr
2251Stmt::child_iterator TypesCompatibleExpr::child_begin() {
2252  return child_iterator();
2253}
2254
2255Stmt::child_iterator TypesCompatibleExpr::child_end() {
2256  return child_iterator();
2257}
2258
2259// ChooseExpr
2260Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
2261Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
2262
2263// GNUNullExpr
2264Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
2265Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
2266
2267// ShuffleVectorExpr
2268Stmt::child_iterator ShuffleVectorExpr::child_begin() {
2269  return &SubExprs[0];
2270}
2271Stmt::child_iterator ShuffleVectorExpr::child_end() {
2272  return &SubExprs[0]+NumExprs;
2273}
2274
2275// VAArgExpr
2276Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
2277Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
2278
2279// InitListExpr
2280Stmt::child_iterator InitListExpr::child_begin() {
2281  return InitExprs.size() ? &InitExprs[0] : 0;
2282}
2283Stmt::child_iterator InitListExpr::child_end() {
2284  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
2285}
2286
2287// DesignatedInitExpr
2288Stmt::child_iterator DesignatedInitExpr::child_begin() {
2289  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2290  Ptr += sizeof(DesignatedInitExpr);
2291  return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2292}
2293Stmt::child_iterator DesignatedInitExpr::child_end() {
2294  return child_iterator(&*child_begin() + NumSubExprs);
2295}
2296
2297// ImplicitValueInitExpr
2298Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
2299  return child_iterator();
2300}
2301
2302Stmt::child_iterator ImplicitValueInitExpr::child_end() {
2303  return child_iterator();
2304}
2305
2306// ParenListExpr
2307Stmt::child_iterator ParenListExpr::child_begin() {
2308  return &Exprs[0];
2309}
2310Stmt::child_iterator ParenListExpr::child_end() {
2311  return &Exprs[0]+NumExprs;
2312}
2313
2314// ObjCStringLiteral
2315Stmt::child_iterator ObjCStringLiteral::child_begin() {
2316  return &String;
2317}
2318Stmt::child_iterator ObjCStringLiteral::child_end() {
2319  return &String+1;
2320}
2321
2322// ObjCEncodeExpr
2323Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
2324Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
2325
2326// ObjCSelectorExpr
2327Stmt::child_iterator ObjCSelectorExpr::child_begin() {
2328  return child_iterator();
2329}
2330Stmt::child_iterator ObjCSelectorExpr::child_end() {
2331  return child_iterator();
2332}
2333
2334// ObjCProtocolExpr
2335Stmt::child_iterator ObjCProtocolExpr::child_begin() {
2336  return child_iterator();
2337}
2338Stmt::child_iterator ObjCProtocolExpr::child_end() {
2339  return child_iterator();
2340}
2341
2342// ObjCMessageExpr
2343Stmt::child_iterator ObjCMessageExpr::child_begin() {
2344  if (getReceiverKind() == Instance)
2345    return reinterpret_cast<Stmt **>(this + 1);
2346  return getArgs();
2347}
2348Stmt::child_iterator ObjCMessageExpr::child_end() {
2349  return getArgs() + getNumArgs();
2350}
2351
2352// Blocks
2353Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
2354Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
2355
2356Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
2357Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
2358