Expr.cpp revision 295995c9c3196416372c9cd35d9cedb6da37bd3d 
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}
1322
1323static Expr::CanThrowResult MergeCanThrow(Expr::CanThrowResult CT1,
1324                                          Expr::CanThrowResult CT2) {
1325  // CanThrowResult constants are ordered so that the maximum is the correct
1326  // merge result.
1327  return CT1 > CT2 ? CT1 : CT2;
1328}
1329
1330static Expr::CanThrowResult CanSubExprsThrow(ASTContext &C, const Expr *CE) {
1331  Expr *E = const_cast<Expr*>(CE);
1332  Expr::CanThrowResult R = Expr::CT_Cannot;
1333  for (Expr::child_iterator I = E->child_begin(), IE = E->child_end();
1334       I != IE && R != Expr::CT_Can; ++I) {
1335    R = MergeCanThrow(R, cast<Expr>(*I)->CanThrow(C));
1336  }
1337  return R;
1338}
1339
1340static Expr::CanThrowResult CanCalleeThrow(const Decl *D,
1341                                           bool NullThrows = true) {
1342  if (!D)
1343    return NullThrows ? Expr::CT_Can : Expr::CT_Cannot;
1344
1345  // See if we can get a function type from the decl somehow.
1346  const ValueDecl *VD = dyn_cast<ValueDecl>(D);
1347  if (!VD) // If we have no clue what we're calling, assume the worst.
1348    return Expr::CT_Can;
1349
1350  QualType T = VD->getType();
1351  const FunctionProtoType *FT;
1352  if ((FT = T->getAs<FunctionProtoType>())) {
1353  } else if (const PointerType *PT = T->getAs<PointerType>())
1354    FT = PT->getPointeeType()->getAs<FunctionProtoType>();
1355  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
1356    FT = RT->getPointeeType()->getAs<FunctionProtoType>();
1357  else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
1358    FT = MT->getPointeeType()->getAs<FunctionProtoType>();
1359  else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
1360    FT = BT->getPointeeType()->getAs<FunctionProtoType>();
1361
1362  if (!FT)
1363    return Expr::CT_Can;
1364
1365  return FT->hasEmptyExceptionSpec() ? Expr::CT_Cannot : Expr::CT_Can;
1366}
1367
1368static Expr::CanThrowResult CanDynamicCastThrow(const CXXDynamicCastExpr *DC) {
1369  if (DC->isTypeDependent())
1370    return Expr::CT_Dependent;
1371
1372  if (!DC->getTypeAsWritten()->isReferenceType())
1373    return Expr::CT_Cannot;
1374
1375  return DC->getCastKind() == clang::CK_Dynamic? Expr::CT_Can : Expr::CT_Cannot;
1376}
1377
1378static Expr::CanThrowResult CanTypeidThrow(ASTContext &C,
1379                                           const CXXTypeidExpr *DC) {
1380  if (DC->isTypeOperand())
1381    return Expr::CT_Cannot;
1382
1383  Expr *Op = DC->getExprOperand();
1384  if (Op->isTypeDependent())
1385    return Expr::CT_Dependent;
1386
1387  const RecordType *RT = Op->getType()->getAs<RecordType>();
1388  if (!RT)
1389    return Expr::CT_Cannot;
1390
1391  if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1392    return Expr::CT_Cannot;
1393
1394  if (Op->Classify(C).isPRValue())
1395    return Expr::CT_Cannot;
1396
1397  return Expr::CT_Can;
1398}
1399
1400Expr::CanThrowResult Expr::CanThrow(ASTContext &C) const {
1401  // C++ [expr.unary.noexcept]p3:
1402  //   [Can throw] if in a potentially-evaluated context the expression would
1403  //   contain:
1404  switch (getStmtClass()) {
1405  case CXXThrowExprClass:
1406    //   - a potentially evaluated throw-expression
1407    return CT_Can;
1408
1409  case CXXDynamicCastExprClass: {
1410    //   - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1411    //     where T is a reference type, that requires a run-time check
1412    CanThrowResult CT = CanDynamicCastThrow(cast<CXXDynamicCastExpr>(this));
1413    if (CT == CT_Can)
1414      return CT;
1415    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1416  }
1417
1418  case CXXTypeidExprClass:
1419    //   - a potentially evaluated typeid expression applied to a glvalue
1420    //     expression whose type is a polymorphic class type
1421    return CanTypeidThrow(C, cast<CXXTypeidExpr>(this));
1422
1423    //   - a potentially evaluated call to a function, member function, function
1424    //     pointer, or member function pointer that does not have a non-throwing
1425    //     exception-specification
1426  case CallExprClass:
1427  case CXXOperatorCallExprClass:
1428  case CXXMemberCallExprClass: {
1429    CanThrowResult CT = CanCalleeThrow(cast<CallExpr>(this)->getCalleeDecl());
1430    if (CT == CT_Can)
1431      return CT;
1432    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1433  }
1434
1435  case CXXConstructExprClass:
1436  case CXXTemporaryObjectExprClass: {
1437    CanThrowResult CT = CanCalleeThrow(
1438        cast<CXXConstructExpr>(this)->getConstructor());
1439    if (CT == CT_Can)
1440      return CT;
1441    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1442  }
1443
1444  case CXXNewExprClass: {
1445    CanThrowResult CT = MergeCanThrow(
1446        CanCalleeThrow(cast<CXXNewExpr>(this)->getOperatorNew()),
1447        CanCalleeThrow(cast<CXXNewExpr>(this)->getConstructor(),
1448                       /*NullThrows*/false));
1449    if (CT == CT_Can)
1450      return CT;
1451    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1452  }
1453
1454  case CXXDeleteExprClass: {
1455    // FIXME: check if destructor might throw
1456    CanThrowResult CT = CanCalleeThrow(
1457        cast<CXXDeleteExpr>(this)->getOperatorDelete());
1458    if (CT == CT_Can)
1459      return CT;
1460    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1461  }
1462
1463    // ObjC message sends are like function calls, but never have exception
1464    // specs.
1465  case ObjCMessageExprClass:
1466  case ObjCPropertyRefExprClass:
1467  case ObjCImplicitSetterGetterRefExprClass:
1468    return CT_Can;
1469
1470    // Many other things have subexpressions, so we have to test those.
1471    // Some are simple:
1472  case ParenExprClass:
1473  case MemberExprClass:
1474  case CXXReinterpretCastExprClass:
1475  case CXXConstCastExprClass:
1476  case ConditionalOperatorClass:
1477  case CompoundLiteralExprClass:
1478  case ExtVectorElementExprClass:
1479  case InitListExprClass:
1480  case DesignatedInitExprClass:
1481  case ParenListExprClass:
1482  case VAArgExprClass:
1483  case CXXDefaultArgExprClass:
1484  case CXXBindTemporaryExprClass:
1485  case CXXExprWithTemporariesClass:
1486  case ObjCIvarRefExprClass:
1487  case ObjCIsaExprClass:
1488  case ShuffleVectorExprClass:
1489    return CanSubExprsThrow(C, this);
1490
1491    // Some might be dependent for other reasons.
1492  case UnaryOperatorClass:
1493  case ArraySubscriptExprClass:
1494  case ImplicitCastExprClass:
1495  case CStyleCastExprClass:
1496  case CXXStaticCastExprClass:
1497  case CXXFunctionalCastExprClass:
1498  case BinaryOperatorClass:
1499  case CompoundAssignOperatorClass: {
1500    CanThrowResult CT = isTypeDependent() ? CT_Dependent : CT_Cannot;
1501    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1502  }
1503
1504    // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1505  case StmtExprClass:
1506    return CT_Can;
1507
1508  case ChooseExprClass:
1509    if (isTypeDependent() || isValueDependent())
1510      return CT_Dependent;
1511    return cast<ChooseExpr>(this)->getChosenSubExpr(C)->CanThrow(C);
1512
1513    // Some expressions are always dependent.
1514  case DependentScopeDeclRefExprClass:
1515  case CXXUnresolvedConstructExprClass:
1516  case CXXDependentScopeMemberExprClass:
1517    return CT_Dependent;
1518
1519  default:
1520    // All other expressions don't have subexpressions, or else they are
1521    // unevaluated.
1522    return CT_Cannot;
1523  }
1524}
1525
1526Expr* Expr::IgnoreParens() {
1527  Expr* E = this;
1528  while (ParenExpr* P = dyn_cast<ParenExpr>(E))
1529    E = P->getSubExpr();
1530
1531  return E;
1532}
1533
1534/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
1535/// or CastExprs or ImplicitCastExprs, returning their operand.
1536Expr *Expr::IgnoreParenCasts() {
1537  Expr *E = this;
1538  while (true) {
1539    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
1540      E = P->getSubExpr();
1541    else if (CastExpr *P = dyn_cast<CastExpr>(E))
1542      E = P->getSubExpr();
1543    else
1544      return E;
1545  }
1546}
1547
1548Expr *Expr::IgnoreParenImpCasts() {
1549  Expr *E = this;
1550  while (true) {
1551    if (ParenExpr *P = dyn_cast<ParenExpr>(E))
1552      E = P->getSubExpr();
1553    else if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E))
1554      E = P->getSubExpr();
1555    else
1556      return E;
1557  }
1558}
1559
1560/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
1561/// value (including ptr->int casts of the same size).  Strip off any
1562/// ParenExpr or CastExprs, returning their operand.
1563Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
1564  Expr *E = this;
1565  while (true) {
1566    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1567      E = P->getSubExpr();
1568      continue;
1569    }
1570
1571    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1572      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
1573      // ptr<->int casts of the same width.  We also ignore all identity casts.
1574      Expr *SE = P->getSubExpr();
1575
1576      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
1577        E = SE;
1578        continue;
1579      }
1580
1581      if ((E->getType()->isPointerType() ||
1582           E->getType()->isIntegralType(Ctx)) &&
1583          (SE->getType()->isPointerType() ||
1584           SE->getType()->isIntegralType(Ctx)) &&
1585          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
1586        E = SE;
1587        continue;
1588      }
1589    }
1590
1591    return E;
1592  }
1593}
1594
1595bool Expr::isDefaultArgument() const {
1596  const Expr *E = this;
1597  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
1598    E = ICE->getSubExprAsWritten();
1599
1600  return isa<CXXDefaultArgExpr>(E);
1601}
1602
1603/// \brief Skip over any no-op casts and any temporary-binding
1604/// expressions.
1605static const Expr *skipTemporaryBindingsAndNoOpCasts(const Expr *E) {
1606  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1607    if (ICE->getCastKind() == CK_NoOp)
1608      E = ICE->getSubExpr();
1609    else
1610      break;
1611  }
1612
1613  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
1614    E = BE->getSubExpr();
1615
1616  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1617    if (ICE->getCastKind() == CK_NoOp)
1618      E = ICE->getSubExpr();
1619    else
1620      break;
1621  }
1622
1623  return E;
1624}
1625
1626const Expr *Expr::getTemporaryObject() const {
1627  const Expr *E = skipTemporaryBindingsAndNoOpCasts(this);
1628
1629  // A cast can produce a temporary object. The object's construction
1630  // is represented as a CXXConstructExpr.
1631  if (const CastExpr *Cast = dyn_cast<CastExpr>(E)) {
1632    // Only user-defined and constructor conversions can produce
1633    // temporary objects.
1634    if (Cast->getCastKind() != CK_ConstructorConversion &&
1635        Cast->getCastKind() != CK_UserDefinedConversion)
1636      return 0;
1637
1638    // Strip off temporary bindings and no-op casts.
1639    const Expr *Sub = skipTemporaryBindingsAndNoOpCasts(Cast->getSubExpr());
1640
1641    // If this is a constructor conversion, see if we have an object
1642    // construction.
1643    if (Cast->getCastKind() == CK_ConstructorConversion)
1644      return dyn_cast<CXXConstructExpr>(Sub);
1645
1646    // If this is a user-defined conversion, see if we have a call to
1647    // a function that itself returns a temporary object.
1648    if (Cast->getCastKind() == CK_UserDefinedConversion)
1649      if (const CallExpr *CE = dyn_cast<CallExpr>(Sub))
1650        if (CE->getCallReturnType()->isRecordType())
1651          return CE;
1652
1653    return 0;
1654  }
1655
1656  // A call returning a class type returns a temporary.
1657  if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
1658    if (CE->getCallReturnType()->isRecordType())
1659      return CE;
1660
1661    return 0;
1662  }
1663
1664  // Explicit temporary object constructors create temporaries.
1665  return dyn_cast<CXXTemporaryObjectExpr>(E);
1666}
1667
1668/// hasAnyTypeDependentArguments - Determines if any of the expressions
1669/// in Exprs is type-dependent.
1670bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
1671  for (unsigned I = 0; I < NumExprs; ++I)
1672    if (Exprs[I]->isTypeDependent())
1673      return true;
1674
1675  return false;
1676}
1677
1678/// hasAnyValueDependentArguments - Determines if any of the expressions
1679/// in Exprs is value-dependent.
1680bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
1681  for (unsigned I = 0; I < NumExprs; ++I)
1682    if (Exprs[I]->isValueDependent())
1683      return true;
1684
1685  return false;
1686}
1687
1688bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const {
1689  // This function is attempting whether an expression is an initializer
1690  // which can be evaluated at compile-time.  isEvaluatable handles most
1691  // of the cases, but it can't deal with some initializer-specific
1692  // expressions, and it can't deal with aggregates; we deal with those here,
1693  // and fall back to isEvaluatable for the other cases.
1694
1695  // If we ever capture reference-binding directly in the AST, we can
1696  // kill the second parameter.
1697
1698  if (IsForRef) {
1699    EvalResult Result;
1700    return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects;
1701  }
1702
1703  switch (getStmtClass()) {
1704  default: break;
1705  case StringLiteralClass:
1706  case ObjCStringLiteralClass:
1707  case ObjCEncodeExprClass:
1708    return true;
1709  case CXXTemporaryObjectExprClass:
1710  case CXXConstructExprClass: {
1711    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
1712
1713    // Only if it's
1714    // 1) an application of the trivial default constructor or
1715    if (!CE->getConstructor()->isTrivial()) return false;
1716    if (!CE->getNumArgs()) return true;
1717
1718    // 2) an elidable trivial copy construction of an operand which is
1719    //    itself a constant initializer.  Note that we consider the
1720    //    operand on its own, *not* as a reference binding.
1721    return CE->isElidable() &&
1722           CE->getArg(0)->isConstantInitializer(Ctx, false);
1723  }
1724  case CompoundLiteralExprClass: {
1725    // This handles gcc's extension that allows global initializers like
1726    // "struct x {int x;} x = (struct x) {};".
1727    // FIXME: This accepts other cases it shouldn't!
1728    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
1729    return Exp->isConstantInitializer(Ctx, false);
1730  }
1731  case InitListExprClass: {
1732    // FIXME: This doesn't deal with fields with reference types correctly.
1733    // FIXME: This incorrectly allows pointers cast to integers to be assigned
1734    // to bitfields.
1735    const InitListExpr *Exp = cast<InitListExpr>(this);
1736    unsigned numInits = Exp->getNumInits();
1737    for (unsigned i = 0; i < numInits; i++) {
1738      if (!Exp->getInit(i)->isConstantInitializer(Ctx, false))
1739        return false;
1740    }
1741    return true;
1742  }
1743  case ImplicitValueInitExprClass:
1744    return true;
1745  case ParenExprClass:
1746    return cast<ParenExpr>(this)->getSubExpr()
1747      ->isConstantInitializer(Ctx, IsForRef);
1748  case UnaryOperatorClass: {
1749    const UnaryOperator* Exp = cast<UnaryOperator>(this);
1750    if (Exp->getOpcode() == UO_Extension)
1751      return Exp->getSubExpr()->isConstantInitializer(Ctx, false);
1752    break;
1753  }
1754  case BinaryOperatorClass: {
1755    // Special case &&foo - &&bar.  It would be nice to generalize this somehow
1756    // but this handles the common case.
1757    const BinaryOperator *Exp = cast<BinaryOperator>(this);
1758    if (Exp->getOpcode() == BO_Sub &&
1759        isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) &&
1760        isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx)))
1761      return true;
1762    break;
1763  }
1764  case CXXFunctionalCastExprClass:
1765  case CXXStaticCastExprClass:
1766  case ImplicitCastExprClass:
1767  case CStyleCastExprClass:
1768    // Handle casts with a destination that's a struct or union; this
1769    // deals with both the gcc no-op struct cast extension and the
1770    // cast-to-union extension.
1771    if (getType()->isRecordType())
1772      return cast<CastExpr>(this)->getSubExpr()
1773        ->isConstantInitializer(Ctx, false);
1774
1775    // Integer->integer casts can be handled here, which is important for
1776    // things like (int)(&&x-&&y).  Scary but true.
1777    if (getType()->isIntegerType() &&
1778        cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType())
1779      return cast<CastExpr>(this)->getSubExpr()
1780        ->isConstantInitializer(Ctx, false);
1781
1782    break;
1783  }
1784  return isEvaluatable(Ctx);
1785}
1786
1787/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1788/// integer constant expression with the value zero, or if this is one that is
1789/// cast to void*.
1790bool Expr::isNullPointerConstant(ASTContext &Ctx,
1791                                 NullPointerConstantValueDependence NPC) const {
1792  if (isValueDependent()) {
1793    switch (NPC) {
1794    case NPC_NeverValueDependent:
1795      assert(false && "Unexpected value dependent expression!");
1796      // If the unthinkable happens, fall through to the safest alternative.
1797
1798    case NPC_ValueDependentIsNull:
1799      return isTypeDependent() || getType()->isIntegralType(Ctx);
1800
1801    case NPC_ValueDependentIsNotNull:
1802      return false;
1803    }
1804  }
1805
1806  // Strip off a cast to void*, if it exists. Except in C++.
1807  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1808    if (!Ctx.getLangOptions().CPlusPlus) {
1809      // Check that it is a cast to void*.
1810      if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
1811        QualType Pointee = PT->getPointeeType();
1812        if (!Pointee.hasQualifiers() &&
1813            Pointee->isVoidType() &&                              // to void*
1814            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1815          return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1816      }
1817    }
1818  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1819    // Ignore the ImplicitCastExpr type entirely.
1820    return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1821  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1822    // Accept ((void*)0) as a null pointer constant, as many other
1823    // implementations do.
1824    return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1825  } else if (const CXXDefaultArgExpr *DefaultArg
1826               = dyn_cast<CXXDefaultArgExpr>(this)) {
1827    // See through default argument expressions
1828    return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
1829  } else if (isa<GNUNullExpr>(this)) {
1830    // The GNU __null extension is always a null pointer constant.
1831    return true;
1832  }
1833
1834  // C++0x nullptr_t is always a null pointer constant.
1835  if (getType()->isNullPtrType())
1836    return true;
1837
1838  // This expression must be an integer type.
1839  if (!getType()->isIntegerType() ||
1840      (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType()))
1841    return false;
1842
1843  // If we have an integer constant expression, we need to *evaluate* it and
1844  // test for the value 0.
1845  llvm::APSInt Result;
1846  return isIntegerConstantExpr(Result, Ctx) && Result == 0;
1847}
1848
1849FieldDecl *Expr::getBitField() {
1850  Expr *E = this->IgnoreParens();
1851
1852  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1853    if (ICE->getValueKind() != VK_RValue &&
1854        ICE->getCastKind() == CK_NoOp)
1855      E = ICE->getSubExpr()->IgnoreParens();
1856    else
1857      break;
1858  }
1859
1860  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1861    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1862      if (Field->isBitField())
1863        return Field;
1864
1865  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E))
1866    if (BinOp->isAssignmentOp() && BinOp->getLHS())
1867      return BinOp->getLHS()->getBitField();
1868
1869  return 0;
1870}
1871
1872bool Expr::refersToVectorElement() const {
1873  const Expr *E = this->IgnoreParens();
1874
1875  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1876    if (ICE->getValueKind() != VK_RValue &&
1877        ICE->getCastKind() == CK_NoOp)
1878      E = ICE->getSubExpr()->IgnoreParens();
1879    else
1880      break;
1881  }
1882
1883  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
1884    return ASE->getBase()->getType()->isVectorType();
1885
1886  if (isa<ExtVectorElementExpr>(E))
1887    return true;
1888
1889  return false;
1890}
1891
1892/// isArrow - Return true if the base expression is a pointer to vector,
1893/// return false if the base expression is a vector.
1894bool ExtVectorElementExpr::isArrow() const {
1895  return getBase()->getType()->isPointerType();
1896}
1897
1898unsigned ExtVectorElementExpr::getNumElements() const {
1899  if (const VectorType *VT = getType()->getAs<VectorType>())
1900    return VT->getNumElements();
1901  return 1;
1902}
1903
1904/// containsDuplicateElements - Return true if any element access is repeated.
1905bool ExtVectorElementExpr::containsDuplicateElements() const {
1906  // FIXME: Refactor this code to an accessor on the AST node which returns the
1907  // "type" of component access, and share with code below and in Sema.
1908  llvm::StringRef Comp = Accessor->getName();
1909
1910  // Halving swizzles do not contain duplicate elements.
1911  if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
1912    return false;
1913
1914  // Advance past s-char prefix on hex swizzles.
1915  if (Comp[0] == 's' || Comp[0] == 'S')
1916    Comp = Comp.substr(1);
1917
1918  for (unsigned i = 0, e = Comp.size(); i != e; ++i)
1919    if (Comp.substr(i + 1).find(Comp[i]) != llvm::StringRef::npos)
1920        return true;
1921
1922  return false;
1923}
1924
1925/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
1926void ExtVectorElementExpr::getEncodedElementAccess(
1927                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
1928  llvm::StringRef Comp = Accessor->getName();
1929  if (Comp[0] == 's' || Comp[0] == 'S')
1930    Comp = Comp.substr(1);
1931
1932  bool isHi =   Comp == "hi";
1933  bool isLo =   Comp == "lo";
1934  bool isEven = Comp == "even";
1935  bool isOdd  = Comp == "odd";
1936
1937  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
1938    uint64_t Index;
1939
1940    if (isHi)
1941      Index = e + i;
1942    else if (isLo)
1943      Index = i;
1944    else if (isEven)
1945      Index = 2 * i;
1946    else if (isOdd)
1947      Index = 2 * i + 1;
1948    else
1949      Index = ExtVectorType::getAccessorIdx(Comp[i]);
1950
1951    Elts.push_back(Index);
1952  }
1953}
1954
1955ObjCMessageExpr::ObjCMessageExpr(QualType T,
1956                                 SourceLocation LBracLoc,
1957                                 SourceLocation SuperLoc,
1958                                 bool IsInstanceSuper,
1959                                 QualType SuperType,
1960                                 Selector Sel,
1961                                 ObjCMethodDecl *Method,
1962                                 Expr **Args, unsigned NumArgs,
1963                                 SourceLocation RBracLoc)
1964  : Expr(ObjCMessageExprClass, T, /*TypeDependent=*/false,
1965         /*ValueDependent=*/false),
1966    NumArgs(NumArgs), Kind(IsInstanceSuper? SuperInstance : SuperClass),
1967    HasMethod(Method != 0), SuperLoc(SuperLoc),
1968    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
1969                                                       : Sel.getAsOpaquePtr())),
1970    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
1971{
1972  setReceiverPointer(SuperType.getAsOpaquePtr());
1973  if (NumArgs)
1974    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
1975}
1976
1977ObjCMessageExpr::ObjCMessageExpr(QualType T,
1978                                 SourceLocation LBracLoc,
1979                                 TypeSourceInfo *Receiver,
1980                                 Selector Sel,
1981                                 ObjCMethodDecl *Method,
1982                                 Expr **Args, unsigned NumArgs,
1983                                 SourceLocation RBracLoc)
1984  : Expr(ObjCMessageExprClass, T, T->isDependentType(),
1985         (T->isDependentType() ||
1986          hasAnyValueDependentArguments(Args, NumArgs))),
1987    NumArgs(NumArgs), Kind(Class), HasMethod(Method != 0),
1988    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
1989                                                       : Sel.getAsOpaquePtr())),
1990    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
1991{
1992  setReceiverPointer(Receiver);
1993  if (NumArgs)
1994    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
1995}
1996
1997ObjCMessageExpr::ObjCMessageExpr(QualType T,
1998                                 SourceLocation LBracLoc,
1999                                 Expr *Receiver,
2000                                 Selector Sel,
2001                                 ObjCMethodDecl *Method,
2002                                 Expr **Args, unsigned NumArgs,
2003                                 SourceLocation RBracLoc)
2004  : Expr(ObjCMessageExprClass, T, Receiver->isTypeDependent(),
2005         (Receiver->isTypeDependent() ||
2006          hasAnyValueDependentArguments(Args, NumArgs))),
2007    NumArgs(NumArgs), Kind(Instance), HasMethod(Method != 0),
2008    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2009                                                       : Sel.getAsOpaquePtr())),
2010    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2011{
2012  setReceiverPointer(Receiver);
2013  if (NumArgs)
2014    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
2015}
2016
2017ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2018                                         SourceLocation LBracLoc,
2019                                         SourceLocation SuperLoc,
2020                                         bool IsInstanceSuper,
2021                                         QualType SuperType,
2022                                         Selector Sel,
2023                                         ObjCMethodDecl *Method,
2024                                         Expr **Args, unsigned NumArgs,
2025                                         SourceLocation RBracLoc) {
2026  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2027    NumArgs * sizeof(Expr *);
2028  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2029  return new (Mem) ObjCMessageExpr(T, LBracLoc, SuperLoc, IsInstanceSuper,
2030                                   SuperType, Sel, Method, Args, NumArgs,
2031                                   RBracLoc);
2032}
2033
2034ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2035                                         SourceLocation LBracLoc,
2036                                         TypeSourceInfo *Receiver,
2037                                         Selector Sel,
2038                                         ObjCMethodDecl *Method,
2039                                         Expr **Args, unsigned NumArgs,
2040                                         SourceLocation RBracLoc) {
2041  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2042    NumArgs * sizeof(Expr *);
2043  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2044  return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args,
2045                                   NumArgs, RBracLoc);
2046}
2047
2048ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2049                                         SourceLocation LBracLoc,
2050                                         Expr *Receiver,
2051                                         Selector Sel,
2052                                         ObjCMethodDecl *Method,
2053                                         Expr **Args, unsigned NumArgs,
2054                                         SourceLocation RBracLoc) {
2055  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2056    NumArgs * sizeof(Expr *);
2057  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2058  return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args,
2059                                   NumArgs, RBracLoc);
2060}
2061
2062ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context,
2063                                              unsigned NumArgs) {
2064  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2065    NumArgs * sizeof(Expr *);
2066  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2067  return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
2068}
2069
2070Selector ObjCMessageExpr::getSelector() const {
2071  if (HasMethod)
2072    return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
2073                                                               ->getSelector();
2074  return Selector(SelectorOrMethod);
2075}
2076
2077ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
2078  switch (getReceiverKind()) {
2079  case Instance:
2080    if (const ObjCObjectPointerType *Ptr
2081          = getInstanceReceiver()->getType()->getAs<ObjCObjectPointerType>())
2082      return Ptr->getInterfaceDecl();
2083    break;
2084
2085  case Class:
2086    if (const ObjCObjectType *Ty
2087          = getClassReceiver()->getAs<ObjCObjectType>())
2088      return Ty->getInterface();
2089    break;
2090
2091  case SuperInstance:
2092    if (const ObjCObjectPointerType *Ptr
2093          = getSuperType()->getAs<ObjCObjectPointerType>())
2094      return Ptr->getInterfaceDecl();
2095    break;
2096
2097  case SuperClass:
2098    if (const ObjCObjectPointerType *Iface
2099                       = getSuperType()->getAs<ObjCObjectPointerType>())
2100      return Iface->getInterfaceDecl();
2101    break;
2102  }
2103
2104  return 0;
2105}
2106
2107bool ChooseExpr::isConditionTrue(ASTContext &C) const {
2108  return getCond()->EvaluateAsInt(C) != 0;
2109}
2110
2111void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
2112                                 unsigned NumExprs) {
2113  if (SubExprs) C.Deallocate(SubExprs);
2114
2115  SubExprs = new (C) Stmt* [NumExprs];
2116  this->NumExprs = NumExprs;
2117  memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
2118}
2119
2120//===----------------------------------------------------------------------===//
2121//  DesignatedInitExpr
2122//===----------------------------------------------------------------------===//
2123
2124IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
2125  assert(Kind == FieldDesignator && "Only valid on a field designator");
2126  if (Field.NameOrField & 0x01)
2127    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
2128  else
2129    return getField()->getIdentifier();
2130}
2131
2132DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
2133                                       unsigned NumDesignators,
2134                                       const Designator *Designators,
2135                                       SourceLocation EqualOrColonLoc,
2136                                       bool GNUSyntax,
2137                                       Expr **IndexExprs,
2138                                       unsigned NumIndexExprs,
2139                                       Expr *Init)
2140  : Expr(DesignatedInitExprClass, Ty,
2141         Init->isTypeDependent(), Init->isValueDependent()),
2142    EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
2143    NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
2144  this->Designators = new (C) Designator[NumDesignators];
2145
2146  // Record the initializer itself.
2147  child_iterator Child = child_begin();
2148  *Child++ = Init;
2149
2150  // Copy the designators and their subexpressions, computing
2151  // value-dependence along the way.
2152  unsigned IndexIdx = 0;
2153  for (unsigned I = 0; I != NumDesignators; ++I) {
2154    this->Designators[I] = Designators[I];
2155
2156    if (this->Designators[I].isArrayDesignator()) {
2157      // Compute type- and value-dependence.
2158      Expr *Index = IndexExprs[IndexIdx];
2159      ValueDependent = ValueDependent ||
2160        Index->isTypeDependent() || Index->isValueDependent();
2161
2162      // Copy the index expressions into permanent storage.
2163      *Child++ = IndexExprs[IndexIdx++];
2164    } else if (this->Designators[I].isArrayRangeDesignator()) {
2165      // Compute type- and value-dependence.
2166      Expr *Start = IndexExprs[IndexIdx];
2167      Expr *End = IndexExprs[IndexIdx + 1];
2168      ValueDependent = ValueDependent ||
2169        Start->isTypeDependent() || Start->isValueDependent() ||
2170        End->isTypeDependent() || End->isValueDependent();
2171
2172      // Copy the start/end expressions into permanent storage.
2173      *Child++ = IndexExprs[IndexIdx++];
2174      *Child++ = IndexExprs[IndexIdx++];
2175    }
2176  }
2177
2178  assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
2179}
2180
2181DesignatedInitExpr *
2182DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
2183                           unsigned NumDesignators,
2184                           Expr **IndexExprs, unsigned NumIndexExprs,
2185                           SourceLocation ColonOrEqualLoc,
2186                           bool UsesColonSyntax, Expr *Init) {
2187  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2188                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2189  return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
2190                                      ColonOrEqualLoc, UsesColonSyntax,
2191                                      IndexExprs, NumIndexExprs, Init);
2192}
2193
2194DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
2195                                                    unsigned NumIndexExprs) {
2196  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2197                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2198  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
2199}
2200
2201void DesignatedInitExpr::setDesignators(ASTContext &C,
2202                                        const Designator *Desigs,
2203                                        unsigned NumDesigs) {
2204  Designators = new (C) Designator[NumDesigs];
2205  NumDesignators = NumDesigs;
2206  for (unsigned I = 0; I != NumDesigs; ++I)
2207    Designators[I] = Desigs[I];
2208}
2209
2210SourceRange DesignatedInitExpr::getSourceRange() const {
2211  SourceLocation StartLoc;
2212  Designator &First =
2213    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
2214  if (First.isFieldDesignator()) {
2215    if (GNUSyntax)
2216      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
2217    else
2218      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
2219  } else
2220    StartLoc =
2221      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
2222  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
2223}
2224
2225Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
2226  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
2227  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2228  Ptr += sizeof(DesignatedInitExpr);
2229  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2230  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2231}
2232
2233Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
2234  assert(D.Kind == Designator::ArrayRangeDesignator &&
2235         "Requires array range designator");
2236  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2237  Ptr += sizeof(DesignatedInitExpr);
2238  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2239  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2240}
2241
2242Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
2243  assert(D.Kind == Designator::ArrayRangeDesignator &&
2244         "Requires array range designator");
2245  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2246  Ptr += sizeof(DesignatedInitExpr);
2247  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2248  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
2249}
2250
2251/// \brief Replaces the designator at index @p Idx with the series
2252/// of designators in [First, Last).
2253void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
2254                                          const Designator *First,
2255                                          const Designator *Last) {
2256  unsigned NumNewDesignators = Last - First;
2257  if (NumNewDesignators == 0) {
2258    std::copy_backward(Designators + Idx + 1,
2259                       Designators + NumDesignators,
2260                       Designators + Idx);
2261    --NumNewDesignators;
2262    return;
2263  } else if (NumNewDesignators == 1) {
2264    Designators[Idx] = *First;
2265    return;
2266  }
2267
2268  Designator *NewDesignators
2269    = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
2270  std::copy(Designators, Designators + Idx, NewDesignators);
2271  std::copy(First, Last, NewDesignators + Idx);
2272  std::copy(Designators + Idx + 1, Designators + NumDesignators,
2273            NewDesignators + Idx + NumNewDesignators);
2274  Designators = NewDesignators;
2275  NumDesignators = NumDesignators - 1 + NumNewDesignators;
2276}
2277
2278ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
2279                             Expr **exprs, unsigned nexprs,
2280                             SourceLocation rparenloc)
2281: Expr(ParenListExprClass, QualType(),
2282       hasAnyTypeDependentArguments(exprs, nexprs),
2283       hasAnyValueDependentArguments(exprs, nexprs)),
2284  NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
2285
2286  Exprs = new (C) Stmt*[nexprs];
2287  for (unsigned i = 0; i != nexprs; ++i)
2288    Exprs[i] = exprs[i];
2289}
2290
2291//===----------------------------------------------------------------------===//
2292//  ExprIterator.
2293//===----------------------------------------------------------------------===//
2294
2295Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
2296Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
2297Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
2298const Expr* ConstExprIterator::operator[](size_t idx) const {
2299  return cast<Expr>(I[idx]);
2300}
2301const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
2302const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
2303
2304//===----------------------------------------------------------------------===//
2305//  Child Iterators for iterating over subexpressions/substatements
2306//===----------------------------------------------------------------------===//
2307
2308// DeclRefExpr
2309Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
2310Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
2311
2312// ObjCIvarRefExpr
2313Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
2314Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
2315
2316// ObjCPropertyRefExpr
2317Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
2318Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
2319
2320// ObjCImplicitSetterGetterRefExpr
2321Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() {
2322  // If this is accessing a class member, skip that entry.
2323  if (Base) return &Base;
2324  return &Base+1;
2325}
2326Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() {
2327  return &Base+1;
2328}
2329
2330// ObjCSuperExpr
2331Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
2332Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
2333
2334// ObjCIsaExpr
2335Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; }
2336Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; }
2337
2338// PredefinedExpr
2339Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
2340Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
2341
2342// IntegerLiteral
2343Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
2344Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
2345
2346// CharacterLiteral
2347Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
2348Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
2349
2350// FloatingLiteral
2351Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
2352Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
2353
2354// ImaginaryLiteral
2355Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
2356Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
2357
2358// StringLiteral
2359Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
2360Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
2361
2362// ParenExpr
2363Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
2364Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
2365
2366// UnaryOperator
2367Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
2368Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
2369
2370// OffsetOfExpr
2371Stmt::child_iterator OffsetOfExpr::child_begin() {
2372  return reinterpret_cast<Stmt **> (reinterpret_cast<OffsetOfNode *> (this + 1)
2373                                      + NumComps);
2374}
2375Stmt::child_iterator OffsetOfExpr::child_end() {
2376  return child_iterator(&*child_begin() + NumExprs);
2377}
2378
2379// SizeOfAlignOfExpr
2380Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
2381  // If this is of a type and the type is a VLA type (and not a typedef), the
2382  // size expression of the VLA needs to be treated as an executable expression.
2383  // Why isn't this weirdness documented better in StmtIterator?
2384  if (isArgumentType()) {
2385    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
2386                                   getArgumentType().getTypePtr()))
2387      return child_iterator(T);
2388    return child_iterator();
2389  }
2390  return child_iterator(&Argument.Ex);
2391}
2392Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
2393  if (isArgumentType())
2394    return child_iterator();
2395  return child_iterator(&Argument.Ex + 1);
2396}
2397
2398// ArraySubscriptExpr
2399Stmt::child_iterator ArraySubscriptExpr::child_begin() {
2400  return &SubExprs[0];
2401}
2402Stmt::child_iterator ArraySubscriptExpr::child_end() {
2403  return &SubExprs[0]+END_EXPR;
2404}
2405
2406// CallExpr
2407Stmt::child_iterator CallExpr::child_begin() {
2408  return &SubExprs[0];
2409}
2410Stmt::child_iterator CallExpr::child_end() {
2411  return &SubExprs[0]+NumArgs+ARGS_START;
2412}
2413
2414// MemberExpr
2415Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
2416Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
2417
2418// ExtVectorElementExpr
2419Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
2420Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
2421
2422// CompoundLiteralExpr
2423Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
2424Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
2425
2426// CastExpr
2427Stmt::child_iterator CastExpr::child_begin() { return &Op; }
2428Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
2429
2430// BinaryOperator
2431Stmt::child_iterator BinaryOperator::child_begin() {
2432  return &SubExprs[0];
2433}
2434Stmt::child_iterator BinaryOperator::child_end() {
2435  return &SubExprs[0]+END_EXPR;
2436}
2437
2438// ConditionalOperator
2439Stmt::child_iterator ConditionalOperator::child_begin() {
2440  return &SubExprs[0];
2441}
2442Stmt::child_iterator ConditionalOperator::child_end() {
2443  return &SubExprs[0]+END_EXPR;
2444}
2445
2446// AddrLabelExpr
2447Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
2448Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
2449
2450// StmtExpr
2451Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
2452Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
2453
2454// TypesCompatibleExpr
2455Stmt::child_iterator TypesCompatibleExpr::child_begin() {
2456  return child_iterator();
2457}
2458
2459Stmt::child_iterator TypesCompatibleExpr::child_end() {
2460  return child_iterator();
2461}
2462
2463// ChooseExpr
2464Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
2465Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
2466
2467// GNUNullExpr
2468Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
2469Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
2470
2471// ShuffleVectorExpr
2472Stmt::child_iterator ShuffleVectorExpr::child_begin() {
2473  return &SubExprs[0];
2474}
2475Stmt::child_iterator ShuffleVectorExpr::child_end() {
2476  return &SubExprs[0]+NumExprs;
2477}
2478
2479// VAArgExpr
2480Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
2481Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
2482
2483// InitListExpr
2484Stmt::child_iterator InitListExpr::child_begin() {
2485  return InitExprs.size() ? &InitExprs[0] : 0;
2486}
2487Stmt::child_iterator InitListExpr::child_end() {
2488  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
2489}
2490
2491// DesignatedInitExpr
2492Stmt::child_iterator DesignatedInitExpr::child_begin() {
2493  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2494  Ptr += sizeof(DesignatedInitExpr);
2495  return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2496}
2497Stmt::child_iterator DesignatedInitExpr::child_end() {
2498  return child_iterator(&*child_begin() + NumSubExprs);
2499}
2500
2501// ImplicitValueInitExpr
2502Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
2503  return child_iterator();
2504}
2505
2506Stmt::child_iterator ImplicitValueInitExpr::child_end() {
2507  return child_iterator();
2508}
2509
2510// ParenListExpr
2511Stmt::child_iterator ParenListExpr::child_begin() {
2512  return &Exprs[0];
2513}
2514Stmt::child_iterator ParenListExpr::child_end() {
2515  return &Exprs[0]+NumExprs;
2516}
2517
2518// ObjCStringLiteral
2519Stmt::child_iterator ObjCStringLiteral::child_begin() {
2520  return &String;
2521}
2522Stmt::child_iterator ObjCStringLiteral::child_end() {
2523  return &String+1;
2524}
2525
2526// ObjCEncodeExpr
2527Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
2528Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
2529
2530// ObjCSelectorExpr
2531Stmt::child_iterator ObjCSelectorExpr::child_begin() {
2532  return child_iterator();
2533}
2534Stmt::child_iterator ObjCSelectorExpr::child_end() {
2535  return child_iterator();
2536}
2537
2538// ObjCProtocolExpr
2539Stmt::child_iterator ObjCProtocolExpr::child_begin() {
2540  return child_iterator();
2541}
2542Stmt::child_iterator ObjCProtocolExpr::child_end() {
2543  return child_iterator();
2544}
2545
2546// ObjCMessageExpr
2547Stmt::child_iterator ObjCMessageExpr::child_begin() {
2548  if (getReceiverKind() == Instance)
2549    return reinterpret_cast<Stmt **>(this + 1);
2550  return getArgs();
2551}
2552Stmt::child_iterator ObjCMessageExpr::child_end() {
2553  return getArgs() + getNumArgs();
2554}
2555
2556// Blocks
2557Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
2558Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
2559
2560Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
2561Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
2562