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