Expr.cpp revision e2b768877b77fa4e00171ee6e6443722e0f3d111 
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  ExprBits.TypeDependent = false;
128  ExprBits.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    ExprBits.TypeDependent = true;
144    ExprBits.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    ExprBits.TypeDependent = true;
151    ExprBits.ValueDependent = true;
152  }
153  //  (TD)  - a template-id that is dependent,
154  else if (hasExplicitTemplateArgs() &&
155           TemplateSpecializationType::anyDependentTemplateArguments(
156                                                       getTemplateArgs(),
157                                                       getNumTemplateArgs())) {
158    ExprBits.TypeDependent = true;
159    ExprBits.ValueDependent = true;
160  }
161  //  (VD)  - the name of a non-type template parameter,
162  else if (isa<NonTypeTemplateParmDecl>(D))
163    ExprBits.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          ExprBits.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      ExprBits.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    ExprBits.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_Dependent:
744    return "Dependent";
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_NullToPointer:
768    return "NullToPointer";
769  case CK_BaseToDerivedMemberPointer:
770    return "BaseToDerivedMemberPointer";
771  case CK_DerivedToBaseMemberPointer:
772    return "DerivedToBaseMemberPointer";
773  case CK_UserDefinedConversion:
774    return "UserDefinedConversion";
775  case CK_ConstructorConversion:
776    return "ConstructorConversion";
777  case CK_IntegralToPointer:
778    return "IntegralToPointer";
779  case CK_PointerToIntegral:
780    return "PointerToIntegral";
781  case CK_PointerToBoolean:
782    return "PointerToBoolean";
783  case CK_ToVoid:
784    return "ToVoid";
785  case CK_VectorSplat:
786    return "VectorSplat";
787  case CK_IntegralCast:
788    return "IntegralCast";
789  case CK_IntegralToBoolean:
790    return "IntegralToBoolean";
791  case CK_IntegralToFloating:
792    return "IntegralToFloating";
793  case CK_FloatingToIntegral:
794    return "FloatingToIntegral";
795  case CK_FloatingCast:
796    return "FloatingCast";
797  case CK_FloatingToBoolean:
798    return "FloatingToBoolean";
799  case CK_MemberPointerToBoolean:
800    return "MemberPointerToBoolean";
801  case CK_AnyPointerToObjCPointerCast:
802    return "AnyPointerToObjCPointerCast";
803  case CK_AnyPointerToBlockPointerCast:
804    return "AnyPointerToBlockPointerCast";
805  case CK_ObjCObjectLValueCast:
806    return "ObjCObjectLValueCast";
807  case CK_FloatingRealToComplex:
808    return "FloatingRealToComplex";
809  case CK_FloatingComplexToReal:
810    return "FloatingComplexToReal";
811  case CK_FloatingComplexToBoolean:
812    return "FloatingComplexToBoolean";
813  case CK_FloatingComplexCast:
814    return "FloatingComplexCast";
815  case CK_FloatingComplexToIntegralComplex:
816    return "FloatingComplexToIntegralComplex";
817  case CK_IntegralRealToComplex:
818    return "IntegralRealToComplex";
819  case CK_IntegralComplexToReal:
820    return "IntegralComplexToReal";
821  case CK_IntegralComplexToBoolean:
822    return "IntegralComplexToBoolean";
823  case CK_IntegralComplexCast:
824    return "IntegralComplexCast";
825  case CK_IntegralComplexToFloatingComplex:
826    return "IntegralComplexToFloatingComplex";
827  }
828
829  llvm_unreachable("Unhandled cast kind!");
830  return 0;
831}
832
833Expr *CastExpr::getSubExprAsWritten() {
834  Expr *SubExpr = 0;
835  CastExpr *E = this;
836  do {
837    SubExpr = E->getSubExpr();
838
839    // Skip any temporary bindings; they're implicit.
840    if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
841      SubExpr = Binder->getSubExpr();
842
843    // Conversions by constructor and conversion functions have a
844    // subexpression describing the call; strip it off.
845    if (E->getCastKind() == CK_ConstructorConversion)
846      SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
847    else if (E->getCastKind() == CK_UserDefinedConversion)
848      SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
849
850    // If the subexpression we're left with is an implicit cast, look
851    // through that, too.
852  } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
853
854  return SubExpr;
855}
856
857CXXBaseSpecifier **CastExpr::path_buffer() {
858  switch (getStmtClass()) {
859#define ABSTRACT_STMT(x)
860#define CASTEXPR(Type, Base) \
861  case Stmt::Type##Class: \
862    return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1);
863#define STMT(Type, Base)
864#include "clang/AST/StmtNodes.inc"
865  default:
866    llvm_unreachable("non-cast expressions not possible here");
867    return 0;
868  }
869}
870
871void CastExpr::setCastPath(const CXXCastPath &Path) {
872  assert(Path.size() == path_size());
873  memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*));
874}
875
876ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext &C, QualType T,
877                                           CastKind Kind, Expr *Operand,
878                                           const CXXCastPath *BasePath,
879                                           ExprValueKind VK) {
880  unsigned PathSize = (BasePath ? BasePath->size() : 0);
881  void *Buffer =
882    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
883  ImplicitCastExpr *E =
884    new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
885  if (PathSize) E->setCastPath(*BasePath);
886  return E;
887}
888
889ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext &C,
890                                                unsigned PathSize) {
891  void *Buffer =
892    C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
893  return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
894}
895
896
897CStyleCastExpr *CStyleCastExpr::Create(ASTContext &C, QualType T,
898                                       CastKind K, Expr *Op,
899                                       const CXXCastPath *BasePath,
900                                       TypeSourceInfo *WrittenTy,
901                                       SourceLocation L, SourceLocation R) {
902  unsigned PathSize = (BasePath ? BasePath->size() : 0);
903  void *Buffer =
904    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
905  CStyleCastExpr *E =
906    new (Buffer) CStyleCastExpr(T, K, Op, PathSize, WrittenTy, L, R);
907  if (PathSize) E->setCastPath(*BasePath);
908  return E;
909}
910
911CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
912  void *Buffer =
913    C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
914  return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize);
915}
916
917/// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
918/// corresponds to, e.g. "<<=".
919const char *BinaryOperator::getOpcodeStr(Opcode Op) {
920  switch (Op) {
921  case BO_PtrMemD:   return ".*";
922  case BO_PtrMemI:   return "->*";
923  case BO_Mul:       return "*";
924  case BO_Div:       return "/";
925  case BO_Rem:       return "%";
926  case BO_Add:       return "+";
927  case BO_Sub:       return "-";
928  case BO_Shl:       return "<<";
929  case BO_Shr:       return ">>";
930  case BO_LT:        return "<";
931  case BO_GT:        return ">";
932  case BO_LE:        return "<=";
933  case BO_GE:        return ">=";
934  case BO_EQ:        return "==";
935  case BO_NE:        return "!=";
936  case BO_And:       return "&";
937  case BO_Xor:       return "^";
938  case BO_Or:        return "|";
939  case BO_LAnd:      return "&&";
940  case BO_LOr:       return "||";
941  case BO_Assign:    return "=";
942  case BO_MulAssign: return "*=";
943  case BO_DivAssign: return "/=";
944  case BO_RemAssign: return "%=";
945  case BO_AddAssign: return "+=";
946  case BO_SubAssign: return "-=";
947  case BO_ShlAssign: return "<<=";
948  case BO_ShrAssign: return ">>=";
949  case BO_AndAssign: return "&=";
950  case BO_XorAssign: return "^=";
951  case BO_OrAssign:  return "|=";
952  case BO_Comma:     return ",";
953  }
954
955  return "";
956}
957
958BinaryOperatorKind
959BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
960  switch (OO) {
961  default: assert(false && "Not an overloadable binary operator");
962  case OO_Plus: return BO_Add;
963  case OO_Minus: return BO_Sub;
964  case OO_Star: return BO_Mul;
965  case OO_Slash: return BO_Div;
966  case OO_Percent: return BO_Rem;
967  case OO_Caret: return BO_Xor;
968  case OO_Amp: return BO_And;
969  case OO_Pipe: return BO_Or;
970  case OO_Equal: return BO_Assign;
971  case OO_Less: return BO_LT;
972  case OO_Greater: return BO_GT;
973  case OO_PlusEqual: return BO_AddAssign;
974  case OO_MinusEqual: return BO_SubAssign;
975  case OO_StarEqual: return BO_MulAssign;
976  case OO_SlashEqual: return BO_DivAssign;
977  case OO_PercentEqual: return BO_RemAssign;
978  case OO_CaretEqual: return BO_XorAssign;
979  case OO_AmpEqual: return BO_AndAssign;
980  case OO_PipeEqual: return BO_OrAssign;
981  case OO_LessLess: return BO_Shl;
982  case OO_GreaterGreater: return BO_Shr;
983  case OO_LessLessEqual: return BO_ShlAssign;
984  case OO_GreaterGreaterEqual: return BO_ShrAssign;
985  case OO_EqualEqual: return BO_EQ;
986  case OO_ExclaimEqual: return BO_NE;
987  case OO_LessEqual: return BO_LE;
988  case OO_GreaterEqual: return BO_GE;
989  case OO_AmpAmp: return BO_LAnd;
990  case OO_PipePipe: return BO_LOr;
991  case OO_Comma: return BO_Comma;
992  case OO_ArrowStar: return BO_PtrMemI;
993  }
994}
995
996OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
997  static const OverloadedOperatorKind OverOps[] = {
998    /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
999    OO_Star, OO_Slash, OO_Percent,
1000    OO_Plus, OO_Minus,
1001    OO_LessLess, OO_GreaterGreater,
1002    OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
1003    OO_EqualEqual, OO_ExclaimEqual,
1004    OO_Amp,
1005    OO_Caret,
1006    OO_Pipe,
1007    OO_AmpAmp,
1008    OO_PipePipe,
1009    OO_Equal, OO_StarEqual,
1010    OO_SlashEqual, OO_PercentEqual,
1011    OO_PlusEqual, OO_MinusEqual,
1012    OO_LessLessEqual, OO_GreaterGreaterEqual,
1013    OO_AmpEqual, OO_CaretEqual,
1014    OO_PipeEqual,
1015    OO_Comma
1016  };
1017  return OverOps[Opc];
1018}
1019
1020InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc,
1021                           Expr **initExprs, unsigned numInits,
1022                           SourceLocation rbraceloc)
1023  : Expr(InitListExprClass, QualType(), false, false),
1024    InitExprs(C, numInits),
1025    LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
1026    UnionFieldInit(0), HadArrayRangeDesignator(false)
1027{
1028  for (unsigned I = 0; I != numInits; ++I) {
1029    if (initExprs[I]->isTypeDependent())
1030      ExprBits.TypeDependent = true;
1031    if (initExprs[I]->isValueDependent())
1032      ExprBits.ValueDependent = true;
1033  }
1034
1035  InitExprs.insert(C, InitExprs.end(), initExprs, initExprs+numInits);
1036}
1037
1038void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) {
1039  if (NumInits > InitExprs.size())
1040    InitExprs.reserve(C, NumInits);
1041}
1042
1043void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) {
1044  InitExprs.resize(C, NumInits, 0);
1045}
1046
1047Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) {
1048  if (Init >= InitExprs.size()) {
1049    InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0);
1050    InitExprs.back() = expr;
1051    return 0;
1052  }
1053
1054  Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
1055  InitExprs[Init] = expr;
1056  return Result;
1057}
1058
1059SourceRange InitListExpr::getSourceRange() const {
1060  if (SyntacticForm)
1061    return SyntacticForm->getSourceRange();
1062  SourceLocation Beg = LBraceLoc, End = RBraceLoc;
1063  if (Beg.isInvalid()) {
1064    // Find the first non-null initializer.
1065    for (InitExprsTy::const_iterator I = InitExprs.begin(),
1066                                     E = InitExprs.end();
1067      I != E; ++I) {
1068      if (Stmt *S = *I) {
1069        Beg = S->getLocStart();
1070        break;
1071      }
1072    }
1073  }
1074  if (End.isInvalid()) {
1075    // Find the first non-null initializer from the end.
1076    for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(),
1077                                             E = InitExprs.rend();
1078      I != E; ++I) {
1079      if (Stmt *S = *I) {
1080        End = S->getSourceRange().getEnd();
1081        break;
1082      }
1083    }
1084  }
1085  return SourceRange(Beg, End);
1086}
1087
1088/// getFunctionType - Return the underlying function type for this block.
1089///
1090const FunctionType *BlockExpr::getFunctionType() const {
1091  return getType()->getAs<BlockPointerType>()->
1092                    getPointeeType()->getAs<FunctionType>();
1093}
1094
1095SourceLocation BlockExpr::getCaretLocation() const {
1096  return TheBlock->getCaretLocation();
1097}
1098const Stmt *BlockExpr::getBody() const {
1099  return TheBlock->getBody();
1100}
1101Stmt *BlockExpr::getBody() {
1102  return TheBlock->getBody();
1103}
1104
1105
1106//===----------------------------------------------------------------------===//
1107// Generic Expression Routines
1108//===----------------------------------------------------------------------===//
1109
1110/// isUnusedResultAWarning - Return true if this immediate expression should
1111/// be warned about if the result is unused.  If so, fill in Loc and Ranges
1112/// with location to warn on and the source range[s] to report with the
1113/// warning.
1114bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
1115                                  SourceRange &R2, ASTContext &Ctx) const {
1116  // Don't warn if the expr is type dependent. The type could end up
1117  // instantiating to void.
1118  if (isTypeDependent())
1119    return false;
1120
1121  switch (getStmtClass()) {
1122  default:
1123    if (getType()->isVoidType())
1124      return false;
1125    Loc = getExprLoc();
1126    R1 = getSourceRange();
1127    return true;
1128  case ParenExprClass:
1129    return cast<ParenExpr>(this)->getSubExpr()->
1130      isUnusedResultAWarning(Loc, R1, R2, Ctx);
1131  case UnaryOperatorClass: {
1132    const UnaryOperator *UO = cast<UnaryOperator>(this);
1133
1134    switch (UO->getOpcode()) {
1135    default: break;
1136    case UO_PostInc:
1137    case UO_PostDec:
1138    case UO_PreInc:
1139    case UO_PreDec:                 // ++/--
1140      return false;  // Not a warning.
1141    case UO_Deref:
1142      // Dereferencing a volatile pointer is a side-effect.
1143      if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1144        return false;
1145      break;
1146    case UO_Real:
1147    case UO_Imag:
1148      // accessing a piece of a volatile complex is a side-effect.
1149      if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
1150          .isVolatileQualified())
1151        return false;
1152      break;
1153    case UO_Extension:
1154      return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1155    }
1156    Loc = UO->getOperatorLoc();
1157    R1 = UO->getSubExpr()->getSourceRange();
1158    return true;
1159  }
1160  case BinaryOperatorClass: {
1161    const BinaryOperator *BO = cast<BinaryOperator>(this);
1162    switch (BO->getOpcode()) {
1163      default:
1164        break;
1165      // Consider the RHS of comma for side effects. LHS was checked by
1166      // Sema::CheckCommaOperands.
1167      case BO_Comma:
1168        // ((foo = <blah>), 0) is an idiom for hiding the result (and
1169        // lvalue-ness) of an assignment written in a macro.
1170        if (IntegerLiteral *IE =
1171              dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
1172          if (IE->getValue() == 0)
1173            return false;
1174        return BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1175      // Consider '||', '&&' to have side effects if the LHS or RHS does.
1176      case BO_LAnd:
1177      case BO_LOr:
1178        if (!BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx) ||
1179            !BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1180          return false;
1181        break;
1182    }
1183    if (BO->isAssignmentOp())
1184      return false;
1185    Loc = BO->getOperatorLoc();
1186    R1 = BO->getLHS()->getSourceRange();
1187    R2 = BO->getRHS()->getSourceRange();
1188    return true;
1189  }
1190  case CompoundAssignOperatorClass:
1191  case VAArgExprClass:
1192    return false;
1193
1194  case ConditionalOperatorClass: {
1195    // The condition must be evaluated, but if either the LHS or RHS is a
1196    // warning, warn about them.
1197    const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1198    if (Exp->getLHS() &&
1199        Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
1200      return true;
1201    return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1202  }
1203
1204  case MemberExprClass:
1205    // If the base pointer or element is to a volatile pointer/field, accessing
1206    // it is a side effect.
1207    if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1208      return false;
1209    Loc = cast<MemberExpr>(this)->getMemberLoc();
1210    R1 = SourceRange(Loc, Loc);
1211    R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
1212    return true;
1213
1214  case ArraySubscriptExprClass:
1215    // If the base pointer or element is to a volatile pointer/field, accessing
1216    // it is a side effect.
1217    if (Ctx.getCanonicalType(getType()).isVolatileQualified())
1218      return false;
1219    Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
1220    R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
1221    R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
1222    return true;
1223
1224  case CallExprClass:
1225  case CXXOperatorCallExprClass:
1226  case CXXMemberCallExprClass: {
1227    // If this is a direct call, get the callee.
1228    const CallExpr *CE = cast<CallExpr>(this);
1229    if (const Decl *FD = CE->getCalleeDecl()) {
1230      // If the callee has attribute pure, const, or warn_unused_result, warn
1231      // about it. void foo() { strlen("bar"); } should warn.
1232      //
1233      // Note: If new cases are added here, DiagnoseUnusedExprResult should be
1234      // updated to match for QoI.
1235      if (FD->getAttr<WarnUnusedResultAttr>() ||
1236          FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
1237        Loc = CE->getCallee()->getLocStart();
1238        R1 = CE->getCallee()->getSourceRange();
1239
1240        if (unsigned NumArgs = CE->getNumArgs())
1241          R2 = SourceRange(CE->getArg(0)->getLocStart(),
1242                           CE->getArg(NumArgs-1)->getLocEnd());
1243        return true;
1244      }
1245    }
1246    return false;
1247  }
1248
1249  case CXXTemporaryObjectExprClass:
1250  case CXXConstructExprClass:
1251    return false;
1252
1253  case ObjCMessageExprClass: {
1254    const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
1255    const ObjCMethodDecl *MD = ME->getMethodDecl();
1256    if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
1257      Loc = getExprLoc();
1258      return true;
1259    }
1260    return false;
1261  }
1262
1263  case ObjCImplicitSetterGetterRefExprClass: {   // Dot syntax for message send.
1264#if 0
1265    const ObjCImplicitSetterGetterRefExpr *Ref =
1266      cast<ObjCImplicitSetterGetterRefExpr>(this);
1267    // FIXME: We really want the location of the '.' here.
1268    Loc = Ref->getLocation();
1269    R1 = SourceRange(Ref->getLocation(), Ref->getLocation());
1270    if (Ref->getBase())
1271      R2 = Ref->getBase()->getSourceRange();
1272#else
1273    Loc = getExprLoc();
1274    R1 = getSourceRange();
1275#endif
1276    return true;
1277  }
1278  case StmtExprClass: {
1279    // Statement exprs don't logically have side effects themselves, but are
1280    // sometimes used in macros in ways that give them a type that is unused.
1281    // For example ({ blah; foo(); }) will end up with a type if foo has a type.
1282    // however, if the result of the stmt expr is dead, we don't want to emit a
1283    // warning.
1284    const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
1285    if (!CS->body_empty()) {
1286      if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
1287        return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1288      if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back()))
1289        if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
1290          return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
1291    }
1292
1293    if (getType()->isVoidType())
1294      return false;
1295    Loc = cast<StmtExpr>(this)->getLParenLoc();
1296    R1 = getSourceRange();
1297    return true;
1298  }
1299  case CStyleCastExprClass:
1300    // If this is an explicit cast to void, allow it.  People do this when they
1301    // think they know what they're doing :).
1302    if (getType()->isVoidType())
1303      return false;
1304    Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
1305    R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
1306    return true;
1307  case CXXFunctionalCastExprClass: {
1308    if (getType()->isVoidType())
1309      return false;
1310    const CastExpr *CE = cast<CastExpr>(this);
1311
1312    // If this is a cast to void or a constructor conversion, check the operand.
1313    // Otherwise, the result of the cast is unused.
1314    if (CE->getCastKind() == CK_ToVoid ||
1315        CE->getCastKind() == CK_ConstructorConversion)
1316      return (cast<CastExpr>(this)->getSubExpr()
1317              ->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1318    Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
1319    R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
1320    return true;
1321  }
1322
1323  case ImplicitCastExprClass:
1324    // Check the operand, since implicit casts are inserted by Sema
1325    return (cast<ImplicitCastExpr>(this)
1326            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1327
1328  case CXXDefaultArgExprClass:
1329    return (cast<CXXDefaultArgExpr>(this)
1330            ->getExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1331
1332  case CXXNewExprClass:
1333    // FIXME: In theory, there might be new expressions that don't have side
1334    // effects (e.g. a placement new with an uninitialized POD).
1335  case CXXDeleteExprClass:
1336    return false;
1337  case CXXBindTemporaryExprClass:
1338    return (cast<CXXBindTemporaryExpr>(this)
1339            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1340  case CXXExprWithTemporariesClass:
1341    return (cast<CXXExprWithTemporaries>(this)
1342            ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1343  }
1344}
1345
1346/// isOBJCGCCandidate - Check if an expression is objc gc'able.
1347/// returns true, if it is; false otherwise.
1348bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
1349  switch (getStmtClass()) {
1350  default:
1351    return false;
1352  case ObjCIvarRefExprClass:
1353    return true;
1354  case Expr::UnaryOperatorClass:
1355    return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1356  case ParenExprClass:
1357    return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1358  case ImplicitCastExprClass:
1359    return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1360  case CStyleCastExprClass:
1361    return cast<CStyleCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1362  case DeclRefExprClass: {
1363    const Decl *D = cast<DeclRefExpr>(this)->getDecl();
1364    if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1365      if (VD->hasGlobalStorage())
1366        return true;
1367      QualType T = VD->getType();
1368      // dereferencing to a  pointer is always a gc'able candidate,
1369      // unless it is __weak.
1370      return T->isPointerType() &&
1371             (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
1372    }
1373    return false;
1374  }
1375  case MemberExprClass: {
1376    const MemberExpr *M = cast<MemberExpr>(this);
1377    return M->getBase()->isOBJCGCCandidate(Ctx);
1378  }
1379  case ArraySubscriptExprClass:
1380    return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(Ctx);
1381  }
1382}
1383
1384bool Expr::isBoundMemberFunction(ASTContext &Ctx) const {
1385  if (isTypeDependent())
1386    return false;
1387  return isLvalue(Ctx) == Expr::LV_MemberFunction;
1388}
1389
1390static Expr::CanThrowResult MergeCanThrow(Expr::CanThrowResult CT1,
1391                                          Expr::CanThrowResult CT2) {
1392  // CanThrowResult constants are ordered so that the maximum is the correct
1393  // merge result.
1394  return CT1 > CT2 ? CT1 : CT2;
1395}
1396
1397static Expr::CanThrowResult CanSubExprsThrow(ASTContext &C, const Expr *CE) {
1398  Expr *E = const_cast<Expr*>(CE);
1399  Expr::CanThrowResult R = Expr::CT_Cannot;
1400  for (Expr::child_iterator I = E->child_begin(), IE = E->child_end();
1401       I != IE && R != Expr::CT_Can; ++I) {
1402    R = MergeCanThrow(R, cast<Expr>(*I)->CanThrow(C));
1403  }
1404  return R;
1405}
1406
1407static Expr::CanThrowResult CanCalleeThrow(const Decl *D,
1408                                           bool NullThrows = true) {
1409  if (!D)
1410    return NullThrows ? Expr::CT_Can : Expr::CT_Cannot;
1411
1412  // See if we can get a function type from the decl somehow.
1413  const ValueDecl *VD = dyn_cast<ValueDecl>(D);
1414  if (!VD) // If we have no clue what we're calling, assume the worst.
1415    return Expr::CT_Can;
1416
1417  // As an extension, we assume that __attribute__((nothrow)) functions don't
1418  // throw.
1419  if (isa<FunctionDecl>(D) && D->hasAttr<NoThrowAttr>())
1420    return Expr::CT_Cannot;
1421
1422  QualType T = VD->getType();
1423  const FunctionProtoType *FT;
1424  if ((FT = T->getAs<FunctionProtoType>())) {
1425  } else if (const PointerType *PT = T->getAs<PointerType>())
1426    FT = PT->getPointeeType()->getAs<FunctionProtoType>();
1427  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
1428    FT = RT->getPointeeType()->getAs<FunctionProtoType>();
1429  else if (const MemberPointerType *MT = T->getAs<MemberPointerType>())
1430    FT = MT->getPointeeType()->getAs<FunctionProtoType>();
1431  else if (const BlockPointerType *BT = T->getAs<BlockPointerType>())
1432    FT = BT->getPointeeType()->getAs<FunctionProtoType>();
1433
1434  if (!FT)
1435    return Expr::CT_Can;
1436
1437  return FT->hasEmptyExceptionSpec() ? Expr::CT_Cannot : Expr::CT_Can;
1438}
1439
1440static Expr::CanThrowResult CanDynamicCastThrow(const CXXDynamicCastExpr *DC) {
1441  if (DC->isTypeDependent())
1442    return Expr::CT_Dependent;
1443
1444  if (!DC->getTypeAsWritten()->isReferenceType())
1445    return Expr::CT_Cannot;
1446
1447  return DC->getCastKind() == clang::CK_Dynamic? Expr::CT_Can : Expr::CT_Cannot;
1448}
1449
1450static Expr::CanThrowResult CanTypeidThrow(ASTContext &C,
1451                                           const CXXTypeidExpr *DC) {
1452  if (DC->isTypeOperand())
1453    return Expr::CT_Cannot;
1454
1455  Expr *Op = DC->getExprOperand();
1456  if (Op->isTypeDependent())
1457    return Expr::CT_Dependent;
1458
1459  const RecordType *RT = Op->getType()->getAs<RecordType>();
1460  if (!RT)
1461    return Expr::CT_Cannot;
1462
1463  if (!cast<CXXRecordDecl>(RT->getDecl())->isPolymorphic())
1464    return Expr::CT_Cannot;
1465
1466  if (Op->Classify(C).isPRValue())
1467    return Expr::CT_Cannot;
1468
1469  return Expr::CT_Can;
1470}
1471
1472Expr::CanThrowResult Expr::CanThrow(ASTContext &C) const {
1473  // C++ [expr.unary.noexcept]p3:
1474  //   [Can throw] if in a potentially-evaluated context the expression would
1475  //   contain:
1476  switch (getStmtClass()) {
1477  case CXXThrowExprClass:
1478    //   - a potentially evaluated throw-expression
1479    return CT_Can;
1480
1481  case CXXDynamicCastExprClass: {
1482    //   - a potentially evaluated dynamic_cast expression dynamic_cast<T>(v),
1483    //     where T is a reference type, that requires a run-time check
1484    CanThrowResult CT = CanDynamicCastThrow(cast<CXXDynamicCastExpr>(this));
1485    if (CT == CT_Can)
1486      return CT;
1487    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1488  }
1489
1490  case CXXTypeidExprClass:
1491    //   - a potentially evaluated typeid expression applied to a glvalue
1492    //     expression whose type is a polymorphic class type
1493    return CanTypeidThrow(C, cast<CXXTypeidExpr>(this));
1494
1495    //   - a potentially evaluated call to a function, member function, function
1496    //     pointer, or member function pointer that does not have a non-throwing
1497    //     exception-specification
1498  case CallExprClass:
1499  case CXXOperatorCallExprClass:
1500  case CXXMemberCallExprClass: {
1501    CanThrowResult CT = CanCalleeThrow(cast<CallExpr>(this)->getCalleeDecl());
1502    if (CT == CT_Can)
1503      return CT;
1504    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1505  }
1506
1507  case CXXConstructExprClass:
1508  case CXXTemporaryObjectExprClass: {
1509    CanThrowResult CT = CanCalleeThrow(
1510        cast<CXXConstructExpr>(this)->getConstructor());
1511    if (CT == CT_Can)
1512      return CT;
1513    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1514  }
1515
1516  case CXXNewExprClass: {
1517    CanThrowResult CT = MergeCanThrow(
1518        CanCalleeThrow(cast<CXXNewExpr>(this)->getOperatorNew()),
1519        CanCalleeThrow(cast<CXXNewExpr>(this)->getConstructor(),
1520                       /*NullThrows*/false));
1521    if (CT == CT_Can)
1522      return CT;
1523    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1524  }
1525
1526  case CXXDeleteExprClass: {
1527    CanThrowResult CT = CanCalleeThrow(
1528        cast<CXXDeleteExpr>(this)->getOperatorDelete());
1529    if (CT == CT_Can)
1530      return CT;
1531    const Expr *Arg = cast<CXXDeleteExpr>(this)->getArgument();
1532    // Unwrap exactly one implicit cast, which converts all pointers to void*.
1533    if (const ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(Arg))
1534      Arg = Cast->getSubExpr();
1535    if (const PointerType *PT = Arg->getType()->getAs<PointerType>()) {
1536      if (const RecordType *RT = PT->getPointeeType()->getAs<RecordType>()) {
1537        CanThrowResult CT2 = CanCalleeThrow(
1538            cast<CXXRecordDecl>(RT->getDecl())->getDestructor());
1539        if (CT2 == CT_Can)
1540          return CT2;
1541        CT = MergeCanThrow(CT, CT2);
1542      }
1543    }
1544    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1545  }
1546
1547  case CXXBindTemporaryExprClass: {
1548    // The bound temporary has to be destroyed again, which might throw.
1549    CanThrowResult CT = CanCalleeThrow(
1550      cast<CXXBindTemporaryExpr>(this)->getTemporary()->getDestructor());
1551    if (CT == CT_Can)
1552      return CT;
1553    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1554  }
1555
1556    // ObjC message sends are like function calls, but never have exception
1557    // specs.
1558  case ObjCMessageExprClass:
1559  case ObjCPropertyRefExprClass:
1560  case ObjCImplicitSetterGetterRefExprClass:
1561    return CT_Can;
1562
1563    // Many other things have subexpressions, so we have to test those.
1564    // Some are simple:
1565  case ParenExprClass:
1566  case MemberExprClass:
1567  case CXXReinterpretCastExprClass:
1568  case CXXConstCastExprClass:
1569  case ConditionalOperatorClass:
1570  case CompoundLiteralExprClass:
1571  case ExtVectorElementExprClass:
1572  case InitListExprClass:
1573  case DesignatedInitExprClass:
1574  case ParenListExprClass:
1575  case VAArgExprClass:
1576  case CXXDefaultArgExprClass:
1577  case CXXExprWithTemporariesClass:
1578  case ObjCIvarRefExprClass:
1579  case ObjCIsaExprClass:
1580  case ShuffleVectorExprClass:
1581    return CanSubExprsThrow(C, this);
1582
1583    // Some might be dependent for other reasons.
1584  case UnaryOperatorClass:
1585  case ArraySubscriptExprClass:
1586  case ImplicitCastExprClass:
1587  case CStyleCastExprClass:
1588  case CXXStaticCastExprClass:
1589  case CXXFunctionalCastExprClass:
1590  case BinaryOperatorClass:
1591  case CompoundAssignOperatorClass: {
1592    CanThrowResult CT = isTypeDependent() ? CT_Dependent : CT_Cannot;
1593    return MergeCanThrow(CT, CanSubExprsThrow(C, this));
1594  }
1595
1596    // FIXME: We should handle StmtExpr, but that opens a MASSIVE can of worms.
1597  case StmtExprClass:
1598    return CT_Can;
1599
1600  case ChooseExprClass:
1601    if (isTypeDependent() || isValueDependent())
1602      return CT_Dependent;
1603    return cast<ChooseExpr>(this)->getChosenSubExpr(C)->CanThrow(C);
1604
1605    // Some expressions are always dependent.
1606  case DependentScopeDeclRefExprClass:
1607  case CXXUnresolvedConstructExprClass:
1608  case CXXDependentScopeMemberExprClass:
1609    return CT_Dependent;
1610
1611  default:
1612    // All other expressions don't have subexpressions, or else they are
1613    // unevaluated.
1614    return CT_Cannot;
1615  }
1616}
1617
1618Expr* Expr::IgnoreParens() {
1619  Expr* E = this;
1620  while (true) {
1621    if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
1622      E = P->getSubExpr();
1623      continue;
1624    }
1625    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
1626      if (P->getOpcode() == UO_Extension) {
1627        E = P->getSubExpr();
1628        continue;
1629      }
1630    }
1631    return E;
1632  }
1633}
1634
1635/// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
1636/// or CastExprs or ImplicitCastExprs, returning their operand.
1637Expr *Expr::IgnoreParenCasts() {
1638  Expr *E = this;
1639  while (true) {
1640    if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
1641      E = P->getSubExpr();
1642      continue;
1643    }
1644    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1645      E = P->getSubExpr();
1646      continue;
1647    }
1648    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
1649      if (P->getOpcode() == UO_Extension) {
1650        E = P->getSubExpr();
1651        continue;
1652      }
1653    }
1654    return E;
1655  }
1656}
1657
1658Expr *Expr::IgnoreParenImpCasts() {
1659  Expr *E = this;
1660  while (true) {
1661    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1662      E = P->getSubExpr();
1663      continue;
1664    }
1665    if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) {
1666      E = P->getSubExpr();
1667      continue;
1668    }
1669    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
1670      if (P->getOpcode() == UO_Extension) {
1671        E = P->getSubExpr();
1672        continue;
1673      }
1674    }
1675    return E;
1676  }
1677}
1678
1679/// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
1680/// value (including ptr->int casts of the same size).  Strip off any
1681/// ParenExpr or CastExprs, returning their operand.
1682Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
1683  Expr *E = this;
1684  while (true) {
1685    if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1686      E = P->getSubExpr();
1687      continue;
1688    }
1689
1690    if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1691      // We ignore integer <-> casts that are of the same width, ptr<->ptr and
1692      // ptr<->int casts of the same width.  We also ignore all identity casts.
1693      Expr *SE = P->getSubExpr();
1694
1695      if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
1696        E = SE;
1697        continue;
1698      }
1699
1700      if ((E->getType()->isPointerType() ||
1701           E->getType()->isIntegralType(Ctx)) &&
1702          (SE->getType()->isPointerType() ||
1703           SE->getType()->isIntegralType(Ctx)) &&
1704          Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
1705        E = SE;
1706        continue;
1707      }
1708    }
1709
1710    if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
1711      if (P->getOpcode() == UO_Extension) {
1712        E = P->getSubExpr();
1713        continue;
1714      }
1715    }
1716
1717    return E;
1718  }
1719}
1720
1721bool Expr::isDefaultArgument() const {
1722  const Expr *E = this;
1723  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
1724    E = ICE->getSubExprAsWritten();
1725
1726  return isa<CXXDefaultArgExpr>(E);
1727}
1728
1729/// \brief Skip over any no-op casts and any temporary-binding
1730/// expressions.
1731static const Expr *skipTemporaryBindingsAndNoOpCasts(const Expr *E) {
1732  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1733    if (ICE->getCastKind() == CK_NoOp)
1734      E = ICE->getSubExpr();
1735    else
1736      break;
1737  }
1738
1739  while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
1740    E = BE->getSubExpr();
1741
1742  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1743    if (ICE->getCastKind() == CK_NoOp)
1744      E = ICE->getSubExpr();
1745    else
1746      break;
1747  }
1748
1749  return E;
1750}
1751
1752/// isTemporaryObject - Determines if this expression produces a
1753/// temporary of the given class type.
1754bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
1755  if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy)))
1756    return false;
1757
1758  const Expr *E = skipTemporaryBindingsAndNoOpCasts(this);
1759
1760  // Temporaries are by definition pr-values of class type.
1761  if (!E->Classify(C).isPRValue()) {
1762    // In this context, property reference is a message call and is pr-value.
1763    if (!isa<ObjCPropertyRefExpr>(E) &&
1764        !isa<ObjCImplicitSetterGetterRefExpr>(E))
1765      return false;
1766  }
1767
1768  // Black-list a few cases which yield pr-values of class type that don't
1769  // refer to temporaries of that type:
1770
1771  // - implicit derived-to-base conversions
1772  if (isa<ImplicitCastExpr>(E)) {
1773    switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
1774    case CK_DerivedToBase:
1775    case CK_UncheckedDerivedToBase:
1776      return false;
1777    default:
1778      break;
1779    }
1780  }
1781
1782  // - member expressions (all)
1783  if (isa<MemberExpr>(E))
1784    return false;
1785
1786  return true;
1787}
1788
1789/// hasAnyTypeDependentArguments - Determines if any of the expressions
1790/// in Exprs is type-dependent.
1791bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
1792  for (unsigned I = 0; I < NumExprs; ++I)
1793    if (Exprs[I]->isTypeDependent())
1794      return true;
1795
1796  return false;
1797}
1798
1799/// hasAnyValueDependentArguments - Determines if any of the expressions
1800/// in Exprs is value-dependent.
1801bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
1802  for (unsigned I = 0; I < NumExprs; ++I)
1803    if (Exprs[I]->isValueDependent())
1804      return true;
1805
1806  return false;
1807}
1808
1809bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const {
1810  // This function is attempting whether an expression is an initializer
1811  // which can be evaluated at compile-time.  isEvaluatable handles most
1812  // of the cases, but it can't deal with some initializer-specific
1813  // expressions, and it can't deal with aggregates; we deal with those here,
1814  // and fall back to isEvaluatable for the other cases.
1815
1816  // If we ever capture reference-binding directly in the AST, we can
1817  // kill the second parameter.
1818
1819  if (IsForRef) {
1820    EvalResult Result;
1821    return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects;
1822  }
1823
1824  switch (getStmtClass()) {
1825  default: break;
1826  case StringLiteralClass:
1827  case ObjCStringLiteralClass:
1828  case ObjCEncodeExprClass:
1829    return true;
1830  case CXXTemporaryObjectExprClass:
1831  case CXXConstructExprClass: {
1832    const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
1833
1834    // Only if it's
1835    // 1) an application of the trivial default constructor or
1836    if (!CE->getConstructor()->isTrivial()) return false;
1837    if (!CE->getNumArgs()) return true;
1838
1839    // 2) an elidable trivial copy construction of an operand which is
1840    //    itself a constant initializer.  Note that we consider the
1841    //    operand on its own, *not* as a reference binding.
1842    return CE->isElidable() &&
1843           CE->getArg(0)->isConstantInitializer(Ctx, false);
1844  }
1845  case CompoundLiteralExprClass: {
1846    // This handles gcc's extension that allows global initializers like
1847    // "struct x {int x;} x = (struct x) {};".
1848    // FIXME: This accepts other cases it shouldn't!
1849    const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
1850    return Exp->isConstantInitializer(Ctx, false);
1851  }
1852  case InitListExprClass: {
1853    // FIXME: This doesn't deal with fields with reference types correctly.
1854    // FIXME: This incorrectly allows pointers cast to integers to be assigned
1855    // to bitfields.
1856    const InitListExpr *Exp = cast<InitListExpr>(this);
1857    unsigned numInits = Exp->getNumInits();
1858    for (unsigned i = 0; i < numInits; i++) {
1859      if (!Exp->getInit(i)->isConstantInitializer(Ctx, false))
1860        return false;
1861    }
1862    return true;
1863  }
1864  case ImplicitValueInitExprClass:
1865    return true;
1866  case ParenExprClass:
1867    return cast<ParenExpr>(this)->getSubExpr()
1868      ->isConstantInitializer(Ctx, IsForRef);
1869  case ChooseExprClass:
1870    return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)
1871      ->isConstantInitializer(Ctx, IsForRef);
1872  case UnaryOperatorClass: {
1873    const UnaryOperator* Exp = cast<UnaryOperator>(this);
1874    if (Exp->getOpcode() == UO_Extension)
1875      return Exp->getSubExpr()->isConstantInitializer(Ctx, false);
1876    break;
1877  }
1878  case BinaryOperatorClass: {
1879    // Special case &&foo - &&bar.  It would be nice to generalize this somehow
1880    // but this handles the common case.
1881    const BinaryOperator *Exp = cast<BinaryOperator>(this);
1882    if (Exp->getOpcode() == BO_Sub &&
1883        isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) &&
1884        isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx)))
1885      return true;
1886    break;
1887  }
1888  case CXXFunctionalCastExprClass:
1889  case CXXStaticCastExprClass:
1890  case ImplicitCastExprClass:
1891  case CStyleCastExprClass:
1892    // Handle casts with a destination that's a struct or union; this
1893    // deals with both the gcc no-op struct cast extension and the
1894    // cast-to-union extension.
1895    if (getType()->isRecordType())
1896      return cast<CastExpr>(this)->getSubExpr()
1897        ->isConstantInitializer(Ctx, false);
1898
1899    // Integer->integer casts can be handled here, which is important for
1900    // things like (int)(&&x-&&y).  Scary but true.
1901    if (getType()->isIntegerType() &&
1902        cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType())
1903      return cast<CastExpr>(this)->getSubExpr()
1904        ->isConstantInitializer(Ctx, false);
1905
1906    break;
1907  }
1908  return isEvaluatable(Ctx);
1909}
1910
1911/// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1912/// integer constant expression with the value zero, or if this is one that is
1913/// cast to void*.
1914bool Expr::isNullPointerConstant(ASTContext &Ctx,
1915                                 NullPointerConstantValueDependence NPC) const {
1916  if (isValueDependent()) {
1917    switch (NPC) {
1918    case NPC_NeverValueDependent:
1919      assert(false && "Unexpected value dependent expression!");
1920      // If the unthinkable happens, fall through to the safest alternative.
1921
1922    case NPC_ValueDependentIsNull:
1923      return isTypeDependent() || getType()->isIntegralType(Ctx);
1924
1925    case NPC_ValueDependentIsNotNull:
1926      return false;
1927    }
1928  }
1929
1930  // Strip off a cast to void*, if it exists. Except in C++.
1931  if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1932    if (!Ctx.getLangOptions().CPlusPlus) {
1933      // Check that it is a cast to void*.
1934      if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
1935        QualType Pointee = PT->getPointeeType();
1936        if (!Pointee.hasQualifiers() &&
1937            Pointee->isVoidType() &&                              // to void*
1938            CE->getSubExpr()->getType()->isIntegerType())         // from int.
1939          return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1940      }
1941    }
1942  } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1943    // Ignore the ImplicitCastExpr type entirely.
1944    return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1945  } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1946    // Accept ((void*)0) as a null pointer constant, as many other
1947    // implementations do.
1948    return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1949  } else if (const CXXDefaultArgExpr *DefaultArg
1950               = dyn_cast<CXXDefaultArgExpr>(this)) {
1951    // See through default argument expressions
1952    return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
1953  } else if (isa<GNUNullExpr>(this)) {
1954    // The GNU __null extension is always a null pointer constant.
1955    return true;
1956  }
1957
1958  // C++0x nullptr_t is always a null pointer constant.
1959  if (getType()->isNullPtrType())
1960    return true;
1961
1962  if (const RecordType *UT = getType()->getAsUnionType())
1963    if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
1964      if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
1965        const Expr *InitExpr = CLE->getInitializer();
1966        if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
1967          return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
1968      }
1969  // This expression must be an integer type.
1970  if (!getType()->isIntegerType() ||
1971      (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType()))
1972    return false;
1973
1974  // If we have an integer constant expression, we need to *evaluate* it and
1975  // test for the value 0.
1976  llvm::APSInt Result;
1977  return isIntegerConstantExpr(Result, Ctx) && Result == 0;
1978}
1979
1980FieldDecl *Expr::getBitField() {
1981  Expr *E = this->IgnoreParens();
1982
1983  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
1984    if (ICE->getValueKind() != VK_RValue &&
1985        ICE->getCastKind() == CK_NoOp)
1986      E = ICE->getSubExpr()->IgnoreParens();
1987    else
1988      break;
1989  }
1990
1991  if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
1992    if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
1993      if (Field->isBitField())
1994        return Field;
1995
1996  if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E))
1997    if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
1998      if (Field->isBitField())
1999        return Field;
2000
2001  if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E))
2002    if (BinOp->isAssignmentOp() && BinOp->getLHS())
2003      return BinOp->getLHS()->getBitField();
2004
2005  return 0;
2006}
2007
2008bool Expr::refersToVectorElement() const {
2009  const Expr *E = this->IgnoreParens();
2010
2011  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2012    if (ICE->getValueKind() != VK_RValue &&
2013        ICE->getCastKind() == CK_NoOp)
2014      E = ICE->getSubExpr()->IgnoreParens();
2015    else
2016      break;
2017  }
2018
2019  if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
2020    return ASE->getBase()->getType()->isVectorType();
2021
2022  if (isa<ExtVectorElementExpr>(E))
2023    return true;
2024
2025  return false;
2026}
2027
2028/// isArrow - Return true if the base expression is a pointer to vector,
2029/// return false if the base expression is a vector.
2030bool ExtVectorElementExpr::isArrow() const {
2031  return getBase()->getType()->isPointerType();
2032}
2033
2034unsigned ExtVectorElementExpr::getNumElements() const {
2035  if (const VectorType *VT = getType()->getAs<VectorType>())
2036    return VT->getNumElements();
2037  return 1;
2038}
2039
2040/// containsDuplicateElements - Return true if any element access is repeated.
2041bool ExtVectorElementExpr::containsDuplicateElements() const {
2042  // FIXME: Refactor this code to an accessor on the AST node which returns the
2043  // "type" of component access, and share with code below and in Sema.
2044  llvm::StringRef Comp = Accessor->getName();
2045
2046  // Halving swizzles do not contain duplicate elements.
2047  if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
2048    return false;
2049
2050  // Advance past s-char prefix on hex swizzles.
2051  if (Comp[0] == 's' || Comp[0] == 'S')
2052    Comp = Comp.substr(1);
2053
2054  for (unsigned i = 0, e = Comp.size(); i != e; ++i)
2055    if (Comp.substr(i + 1).find(Comp[i]) != llvm::StringRef::npos)
2056        return true;
2057
2058  return false;
2059}
2060
2061/// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
2062void ExtVectorElementExpr::getEncodedElementAccess(
2063                                  llvm::SmallVectorImpl<unsigned> &Elts) const {
2064  llvm::StringRef Comp = Accessor->getName();
2065  if (Comp[0] == 's' || Comp[0] == 'S')
2066    Comp = Comp.substr(1);
2067
2068  bool isHi =   Comp == "hi";
2069  bool isLo =   Comp == "lo";
2070  bool isEven = Comp == "even";
2071  bool isOdd  = Comp == "odd";
2072
2073  for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
2074    uint64_t Index;
2075
2076    if (isHi)
2077      Index = e + i;
2078    else if (isLo)
2079      Index = i;
2080    else if (isEven)
2081      Index = 2 * i;
2082    else if (isOdd)
2083      Index = 2 * i + 1;
2084    else
2085      Index = ExtVectorType::getAccessorIdx(Comp[i]);
2086
2087    Elts.push_back(Index);
2088  }
2089}
2090
2091ObjCMessageExpr::ObjCMessageExpr(QualType T,
2092                                 SourceLocation LBracLoc,
2093                                 SourceLocation SuperLoc,
2094                                 bool IsInstanceSuper,
2095                                 QualType SuperType,
2096                                 Selector Sel,
2097                                 ObjCMethodDecl *Method,
2098                                 Expr **Args, unsigned NumArgs,
2099                                 SourceLocation RBracLoc)
2100  : Expr(ObjCMessageExprClass, T, /*TypeDependent=*/false,
2101         /*ValueDependent=*/false),
2102    NumArgs(NumArgs), Kind(IsInstanceSuper? SuperInstance : SuperClass),
2103    HasMethod(Method != 0), SuperLoc(SuperLoc),
2104    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2105                                                       : Sel.getAsOpaquePtr())),
2106    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2107{
2108  setReceiverPointer(SuperType.getAsOpaquePtr());
2109  if (NumArgs)
2110    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
2111}
2112
2113ObjCMessageExpr::ObjCMessageExpr(QualType T,
2114                                 SourceLocation LBracLoc,
2115                                 TypeSourceInfo *Receiver,
2116                                 Selector Sel,
2117                                 ObjCMethodDecl *Method,
2118                                 Expr **Args, unsigned NumArgs,
2119                                 SourceLocation RBracLoc)
2120  : Expr(ObjCMessageExprClass, T, T->isDependentType(),
2121         (T->isDependentType() ||
2122          hasAnyValueDependentArguments(Args, NumArgs))),
2123    NumArgs(NumArgs), Kind(Class), HasMethod(Method != 0),
2124    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2125                                                       : Sel.getAsOpaquePtr())),
2126    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2127{
2128  setReceiverPointer(Receiver);
2129  if (NumArgs)
2130    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
2131}
2132
2133ObjCMessageExpr::ObjCMessageExpr(QualType T,
2134                                 SourceLocation LBracLoc,
2135                                 Expr *Receiver,
2136                                 Selector Sel,
2137                                 ObjCMethodDecl *Method,
2138                                 Expr **Args, unsigned NumArgs,
2139                                 SourceLocation RBracLoc)
2140  : Expr(ObjCMessageExprClass, T, Receiver->isTypeDependent(),
2141         (Receiver->isTypeDependent() ||
2142          hasAnyValueDependentArguments(Args, NumArgs))),
2143    NumArgs(NumArgs), Kind(Instance), HasMethod(Method != 0),
2144    SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
2145                                                       : Sel.getAsOpaquePtr())),
2146    LBracLoc(LBracLoc), RBracLoc(RBracLoc)
2147{
2148  setReceiverPointer(Receiver);
2149  if (NumArgs)
2150    memcpy(getArgs(), Args, NumArgs * sizeof(Expr *));
2151}
2152
2153ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2154                                         SourceLocation LBracLoc,
2155                                         SourceLocation SuperLoc,
2156                                         bool IsInstanceSuper,
2157                                         QualType SuperType,
2158                                         Selector Sel,
2159                                         ObjCMethodDecl *Method,
2160                                         Expr **Args, unsigned NumArgs,
2161                                         SourceLocation RBracLoc) {
2162  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2163    NumArgs * sizeof(Expr *);
2164  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2165  return new (Mem) ObjCMessageExpr(T, LBracLoc, SuperLoc, IsInstanceSuper,
2166                                   SuperType, Sel, Method, Args, NumArgs,
2167                                   RBracLoc);
2168}
2169
2170ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2171                                         SourceLocation LBracLoc,
2172                                         TypeSourceInfo *Receiver,
2173                                         Selector Sel,
2174                                         ObjCMethodDecl *Method,
2175                                         Expr **Args, unsigned NumArgs,
2176                                         SourceLocation RBracLoc) {
2177  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2178    NumArgs * sizeof(Expr *);
2179  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2180  return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args,
2181                                   NumArgs, RBracLoc);
2182}
2183
2184ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
2185                                         SourceLocation LBracLoc,
2186                                         Expr *Receiver,
2187                                         Selector Sel,
2188                                         ObjCMethodDecl *Method,
2189                                         Expr **Args, unsigned NumArgs,
2190                                         SourceLocation RBracLoc) {
2191  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2192    NumArgs * sizeof(Expr *);
2193  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2194  return new (Mem) ObjCMessageExpr(T, LBracLoc, Receiver, Sel, Method, Args,
2195                                   NumArgs, RBracLoc);
2196}
2197
2198ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context,
2199                                              unsigned NumArgs) {
2200  unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
2201    NumArgs * sizeof(Expr *);
2202  void *Mem = Context.Allocate(Size, llvm::AlignOf<ObjCMessageExpr>::Alignment);
2203  return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
2204}
2205
2206Selector ObjCMessageExpr::getSelector() const {
2207  if (HasMethod)
2208    return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
2209                                                               ->getSelector();
2210  return Selector(SelectorOrMethod);
2211}
2212
2213ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
2214  switch (getReceiverKind()) {
2215  case Instance:
2216    if (const ObjCObjectPointerType *Ptr
2217          = getInstanceReceiver()->getType()->getAs<ObjCObjectPointerType>())
2218      return Ptr->getInterfaceDecl();
2219    break;
2220
2221  case Class:
2222    if (const ObjCObjectType *Ty
2223          = getClassReceiver()->getAs<ObjCObjectType>())
2224      return Ty->getInterface();
2225    break;
2226
2227  case SuperInstance:
2228    if (const ObjCObjectPointerType *Ptr
2229          = getSuperType()->getAs<ObjCObjectPointerType>())
2230      return Ptr->getInterfaceDecl();
2231    break;
2232
2233  case SuperClass:
2234    if (const ObjCObjectPointerType *Iface
2235                       = getSuperType()->getAs<ObjCObjectPointerType>())
2236      return Iface->getInterfaceDecl();
2237    break;
2238  }
2239
2240  return 0;
2241}
2242
2243bool ChooseExpr::isConditionTrue(ASTContext &C) const {
2244  return getCond()->EvaluateAsInt(C) != 0;
2245}
2246
2247void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
2248                                 unsigned NumExprs) {
2249  if (SubExprs) C.Deallocate(SubExprs);
2250
2251  SubExprs = new (C) Stmt* [NumExprs];
2252  this->NumExprs = NumExprs;
2253  memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
2254}
2255
2256//===----------------------------------------------------------------------===//
2257//  DesignatedInitExpr
2258//===----------------------------------------------------------------------===//
2259
2260IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
2261  assert(Kind == FieldDesignator && "Only valid on a field designator");
2262  if (Field.NameOrField & 0x01)
2263    return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
2264  else
2265    return getField()->getIdentifier();
2266}
2267
2268DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
2269                                       unsigned NumDesignators,
2270                                       const Designator *Designators,
2271                                       SourceLocation EqualOrColonLoc,
2272                                       bool GNUSyntax,
2273                                       Expr **IndexExprs,
2274                                       unsigned NumIndexExprs,
2275                                       Expr *Init)
2276  : Expr(DesignatedInitExprClass, Ty,
2277         Init->isTypeDependent(), Init->isValueDependent()),
2278    EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
2279    NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
2280  this->Designators = new (C) Designator[NumDesignators];
2281
2282  // Record the initializer itself.
2283  child_iterator Child = child_begin();
2284  *Child++ = Init;
2285
2286  // Copy the designators and their subexpressions, computing
2287  // value-dependence along the way.
2288  unsigned IndexIdx = 0;
2289  for (unsigned I = 0; I != NumDesignators; ++I) {
2290    this->Designators[I] = Designators[I];
2291
2292    if (this->Designators[I].isArrayDesignator()) {
2293      // Compute type- and value-dependence.
2294      Expr *Index = IndexExprs[IndexIdx];
2295      ExprBits.ValueDependent = ExprBits.ValueDependent ||
2296        Index->isTypeDependent() || Index->isValueDependent();
2297
2298      // Copy the index expressions into permanent storage.
2299      *Child++ = IndexExprs[IndexIdx++];
2300    } else if (this->Designators[I].isArrayRangeDesignator()) {
2301      // Compute type- and value-dependence.
2302      Expr *Start = IndexExprs[IndexIdx];
2303      Expr *End = IndexExprs[IndexIdx + 1];
2304      ExprBits.ValueDependent = ExprBits.ValueDependent ||
2305        Start->isTypeDependent() || Start->isValueDependent() ||
2306        End->isTypeDependent() || End->isValueDependent();
2307
2308      // Copy the start/end expressions into permanent storage.
2309      *Child++ = IndexExprs[IndexIdx++];
2310      *Child++ = IndexExprs[IndexIdx++];
2311    }
2312  }
2313
2314  assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
2315}
2316
2317DesignatedInitExpr *
2318DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
2319                           unsigned NumDesignators,
2320                           Expr **IndexExprs, unsigned NumIndexExprs,
2321                           SourceLocation ColonOrEqualLoc,
2322                           bool UsesColonSyntax, Expr *Init) {
2323  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2324                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2325  return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
2326                                      ColonOrEqualLoc, UsesColonSyntax,
2327                                      IndexExprs, NumIndexExprs, Init);
2328}
2329
2330DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
2331                                                    unsigned NumIndexExprs) {
2332  void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2333                         sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2334  return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
2335}
2336
2337void DesignatedInitExpr::setDesignators(ASTContext &C,
2338                                        const Designator *Desigs,
2339                                        unsigned NumDesigs) {
2340  Designators = new (C) Designator[NumDesigs];
2341  NumDesignators = NumDesigs;
2342  for (unsigned I = 0; I != NumDesigs; ++I)
2343    Designators[I] = Desigs[I];
2344}
2345
2346SourceRange DesignatedInitExpr::getSourceRange() const {
2347  SourceLocation StartLoc;
2348  Designator &First =
2349    *const_cast<DesignatedInitExpr*>(this)->designators_begin();
2350  if (First.isFieldDesignator()) {
2351    if (GNUSyntax)
2352      StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
2353    else
2354      StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
2355  } else
2356    StartLoc =
2357      SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
2358  return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
2359}
2360
2361Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
2362  assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
2363  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2364  Ptr += sizeof(DesignatedInitExpr);
2365  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2366  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2367}
2368
2369Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
2370  assert(D.Kind == Designator::ArrayRangeDesignator &&
2371         "Requires array range designator");
2372  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2373  Ptr += sizeof(DesignatedInitExpr);
2374  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2375  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2376}
2377
2378Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
2379  assert(D.Kind == Designator::ArrayRangeDesignator &&
2380         "Requires array range designator");
2381  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2382  Ptr += sizeof(DesignatedInitExpr);
2383  Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2384  return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
2385}
2386
2387/// \brief Replaces the designator at index @p Idx with the series
2388/// of designators in [First, Last).
2389void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
2390                                          const Designator *First,
2391                                          const Designator *Last) {
2392  unsigned NumNewDesignators = Last - First;
2393  if (NumNewDesignators == 0) {
2394    std::copy_backward(Designators + Idx + 1,
2395                       Designators + NumDesignators,
2396                       Designators + Idx);
2397    --NumNewDesignators;
2398    return;
2399  } else if (NumNewDesignators == 1) {
2400    Designators[Idx] = *First;
2401    return;
2402  }
2403
2404  Designator *NewDesignators
2405    = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
2406  std::copy(Designators, Designators + Idx, NewDesignators);
2407  std::copy(First, Last, NewDesignators + Idx);
2408  std::copy(Designators + Idx + 1, Designators + NumDesignators,
2409            NewDesignators + Idx + NumNewDesignators);
2410  Designators = NewDesignators;
2411  NumDesignators = NumDesignators - 1 + NumNewDesignators;
2412}
2413
2414ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
2415                             Expr **exprs, unsigned nexprs,
2416                             SourceLocation rparenloc)
2417: Expr(ParenListExprClass, QualType(),
2418       hasAnyTypeDependentArguments(exprs, nexprs),
2419       hasAnyValueDependentArguments(exprs, nexprs)),
2420  NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
2421
2422  Exprs = new (C) Stmt*[nexprs];
2423  for (unsigned i = 0; i != nexprs; ++i)
2424    Exprs[i] = exprs[i];
2425}
2426
2427//===----------------------------------------------------------------------===//
2428//  ExprIterator.
2429//===----------------------------------------------------------------------===//
2430
2431Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
2432Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
2433Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
2434const Expr* ConstExprIterator::operator[](size_t idx) const {
2435  return cast<Expr>(I[idx]);
2436}
2437const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
2438const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
2439
2440//===----------------------------------------------------------------------===//
2441//  Child Iterators for iterating over subexpressions/substatements
2442//===----------------------------------------------------------------------===//
2443
2444// DeclRefExpr
2445Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
2446Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
2447
2448// ObjCIvarRefExpr
2449Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
2450Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
2451
2452// ObjCPropertyRefExpr
2453Stmt::child_iterator ObjCPropertyRefExpr::child_begin()
2454{
2455  if (BaseExprOrSuperType.is<Stmt*>()) {
2456    // Hack alert!
2457    return reinterpret_cast<Stmt**> (&BaseExprOrSuperType);
2458  }
2459  return child_iterator();
2460}
2461
2462Stmt::child_iterator ObjCPropertyRefExpr::child_end()
2463{ return BaseExprOrSuperType.is<Stmt*>() ?
2464          reinterpret_cast<Stmt**> (&BaseExprOrSuperType)+1 :
2465          child_iterator();
2466}
2467
2468// ObjCImplicitSetterGetterRefExpr
2469Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() {
2470  // If this is accessing a class member or super, skip that entry.
2471  // Technically, 2nd condition is sufficient. But I want to be verbose
2472  if (isSuperReceiver() || !Base)
2473    return child_iterator();
2474  return &Base;
2475}
2476Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() {
2477  if (isSuperReceiver() || !Base)
2478    return child_iterator();
2479  return &Base+1;
2480}
2481
2482// ObjCIsaExpr
2483Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; }
2484Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; }
2485
2486// PredefinedExpr
2487Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
2488Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
2489
2490// IntegerLiteral
2491Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
2492Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
2493
2494// CharacterLiteral
2495Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
2496Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
2497
2498// FloatingLiteral
2499Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
2500Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
2501
2502// ImaginaryLiteral
2503Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
2504Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
2505
2506// StringLiteral
2507Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
2508Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
2509
2510// ParenExpr
2511Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
2512Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
2513
2514// UnaryOperator
2515Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
2516Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
2517
2518// OffsetOfExpr
2519Stmt::child_iterator OffsetOfExpr::child_begin() {
2520  return reinterpret_cast<Stmt **> (reinterpret_cast<OffsetOfNode *> (this + 1)
2521                                      + NumComps);
2522}
2523Stmt::child_iterator OffsetOfExpr::child_end() {
2524  return child_iterator(&*child_begin() + NumExprs);
2525}
2526
2527// SizeOfAlignOfExpr
2528Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
2529  // If this is of a type and the type is a VLA type (and not a typedef), the
2530  // size expression of the VLA needs to be treated as an executable expression.
2531  // Why isn't this weirdness documented better in StmtIterator?
2532  if (isArgumentType()) {
2533    if (VariableArrayType* T = dyn_cast<VariableArrayType>(
2534                                   getArgumentType().getTypePtr()))
2535      return child_iterator(T);
2536    return child_iterator();
2537  }
2538  return child_iterator(&Argument.Ex);
2539}
2540Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
2541  if (isArgumentType())
2542    return child_iterator();
2543  return child_iterator(&Argument.Ex + 1);
2544}
2545
2546// ArraySubscriptExpr
2547Stmt::child_iterator ArraySubscriptExpr::child_begin() {
2548  return &SubExprs[0];
2549}
2550Stmt::child_iterator ArraySubscriptExpr::child_end() {
2551  return &SubExprs[0]+END_EXPR;
2552}
2553
2554// CallExpr
2555Stmt::child_iterator CallExpr::child_begin() {
2556  return &SubExprs[0];
2557}
2558Stmt::child_iterator CallExpr::child_end() {
2559  return &SubExprs[0]+NumArgs+ARGS_START;
2560}
2561
2562// MemberExpr
2563Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
2564Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
2565
2566// ExtVectorElementExpr
2567Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
2568Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
2569
2570// CompoundLiteralExpr
2571Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
2572Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
2573
2574// CastExpr
2575Stmt::child_iterator CastExpr::child_begin() { return &Op; }
2576Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
2577
2578// BinaryOperator
2579Stmt::child_iterator BinaryOperator::child_begin() {
2580  return &SubExprs[0];
2581}
2582Stmt::child_iterator BinaryOperator::child_end() {
2583  return &SubExprs[0]+END_EXPR;
2584}
2585
2586// ConditionalOperator
2587Stmt::child_iterator ConditionalOperator::child_begin() {
2588  return &SubExprs[0];
2589}
2590Stmt::child_iterator ConditionalOperator::child_end() {
2591  return &SubExprs[0]+END_EXPR;
2592}
2593
2594// AddrLabelExpr
2595Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
2596Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
2597
2598// StmtExpr
2599Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
2600Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
2601
2602// TypesCompatibleExpr
2603Stmt::child_iterator TypesCompatibleExpr::child_begin() {
2604  return child_iterator();
2605}
2606
2607Stmt::child_iterator TypesCompatibleExpr::child_end() {
2608  return child_iterator();
2609}
2610
2611// ChooseExpr
2612Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
2613Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
2614
2615// GNUNullExpr
2616Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
2617Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
2618
2619// ShuffleVectorExpr
2620Stmt::child_iterator ShuffleVectorExpr::child_begin() {
2621  return &SubExprs[0];
2622}
2623Stmt::child_iterator ShuffleVectorExpr::child_end() {
2624  return &SubExprs[0]+NumExprs;
2625}
2626
2627// VAArgExpr
2628Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
2629Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
2630
2631// InitListExpr
2632Stmt::child_iterator InitListExpr::child_begin() {
2633  return InitExprs.size() ? &InitExprs[0] : 0;
2634}
2635Stmt::child_iterator InitListExpr::child_end() {
2636  return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
2637}
2638
2639// DesignatedInitExpr
2640Stmt::child_iterator DesignatedInitExpr::child_begin() {
2641  char* Ptr = static_cast<char*>(static_cast<void *>(this));
2642  Ptr += sizeof(DesignatedInitExpr);
2643  return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2644}
2645Stmt::child_iterator DesignatedInitExpr::child_end() {
2646  return child_iterator(&*child_begin() + NumSubExprs);
2647}
2648
2649// ImplicitValueInitExpr
2650Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
2651  return child_iterator();
2652}
2653
2654Stmt::child_iterator ImplicitValueInitExpr::child_end() {
2655  return child_iterator();
2656}
2657
2658// ParenListExpr
2659Stmt::child_iterator ParenListExpr::child_begin() {
2660  return &Exprs[0];
2661}
2662Stmt::child_iterator ParenListExpr::child_end() {
2663  return &Exprs[0]+NumExprs;
2664}
2665
2666// ObjCStringLiteral
2667Stmt::child_iterator ObjCStringLiteral::child_begin() {
2668  return &String;
2669}
2670Stmt::child_iterator ObjCStringLiteral::child_end() {
2671  return &String+1;
2672}
2673
2674// ObjCEncodeExpr
2675Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
2676Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
2677
2678// ObjCSelectorExpr
2679Stmt::child_iterator ObjCSelectorExpr::child_begin() {
2680  return child_iterator();
2681}
2682Stmt::child_iterator ObjCSelectorExpr::child_end() {
2683  return child_iterator();
2684}
2685
2686// ObjCProtocolExpr
2687Stmt::child_iterator ObjCProtocolExpr::child_begin() {
2688  return child_iterator();
2689}
2690Stmt::child_iterator ObjCProtocolExpr::child_end() {
2691  return child_iterator();
2692}
2693
2694// ObjCMessageExpr
2695Stmt::child_iterator ObjCMessageExpr::child_begin() {
2696  if (getReceiverKind() == Instance)
2697    return reinterpret_cast<Stmt **>(this + 1);
2698  return getArgs();
2699}
2700Stmt::child_iterator ObjCMessageExpr::child_end() {
2701  return getArgs() + getNumArgs();
2702}
2703
2704// Blocks
2705Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
2706Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
2707
2708Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
2709Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }
2710
2711// OpaqueValueExpr
2712SourceRange OpaqueValueExpr::getSourceRange() const { return SourceRange(); }
2713Stmt::child_iterator OpaqueValueExpr::child_begin() { return child_iterator(); }
2714Stmt::child_iterator OpaqueValueExpr::child_end() { return child_iterator(); }
2715
2716