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