contrib/llvm/tools/clang/lib/AST/Expr.cpp

   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/APValue.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/Attr.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclObjC.h"
  19 #include "clang/AST/DeclTemplate.h"
  20 #include "clang/AST/EvaluatedExprVisitor.h"
  21 #include "clang/AST/Expr.h"
  22 #include "clang/AST/ExprCXX.h"
  23 #include "clang/AST/RecordLayout.h"
  24 #include "clang/AST/StmtVisitor.h"
  25 #include "clang/Basic/Builtins.h"
  26 #include "clang/Basic/CharInfo.h"
  27 #include "clang/Basic/SourceManager.h"
  28 #include "clang/Basic/TargetInfo.h"
  29 #include "clang/Lex/Lexer.h"
  30 #include "clang/Lex/LiteralSupport.h"
  31 #include "clang/Sema/SemaDiagnostic.h"
  32 #include "llvm/Support/ErrorHandling.h"
  33 #include "llvm/Support/raw_ostream.h"
  34 #include <algorithm>
  35 #include <cstring>
  36 using namespace clang;
  37
  38 const CXXRecordDecl *Expr::getBestDynamicClassType() const {
  39   const Expr *E = ignoreParenBaseCasts();
  40
  41   QualType DerivedType = E->getType();
  42   if (const PointerType *PTy = DerivedType->getAs<PointerType>())
  43     DerivedType = PTy->getPointeeType();
  44
  45   if (DerivedType->isDependentType())
  46     return NULL;
  47
  48   const RecordType *Ty = DerivedType->castAs<RecordType>();
  49   Decl *D = Ty->getDecl();
  50   return cast<CXXRecordDecl>(D);
  51 }
  52
  53 const Expr *
  54 Expr::skipRValueSubobjectAdjustments(
  55                      SmallVectorImpl<SubobjectAdjustment> &Adjustments) const  {
  56   const Expr *E = this;
  57   while (true) {
  58     E = E->IgnoreParens();
  59
  60     if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
  61       if ((CE->getCastKind() == CK_DerivedToBase ||
  62            CE->getCastKind() == CK_UncheckedDerivedToBase) &&
  63           E->getType()->isRecordType()) {
  64         E = CE->getSubExpr();
  65         CXXRecordDecl *Derived
  66           = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
  67         Adjustments.push_back(SubobjectAdjustment(CE, Derived));
  68         continue;
  69       }
  70
  71       if (CE->getCastKind() == CK_NoOp) {
  72         E = CE->getSubExpr();
  73         continue;
  74       }
  75     } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
  76       if (!ME->isArrow() && ME->getBase()->isRValue()) {
  77         assert(ME->getBase()->getType()->isRecordType());
  78         if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
  79           E = ME->getBase();
  80           Adjustments.push_back(SubobjectAdjustment(Field));
  81           continue;
  82         }
  83       }
  84     } else if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
  85       if (BO->isPtrMemOp()) {
  86         assert(BO->getRHS()->isRValue());
  87         E = BO->getLHS();
  88         const MemberPointerType *MPT =
  89           BO->getRHS()->getType()->getAs<MemberPointerType>();
  90         Adjustments.push_back(SubobjectAdjustment(MPT, BO->getRHS()));
  91       }
  92     }
  93
  94     // Nothing changed.
  95     break;
  96   }
  97   return E;
  98 }
  99
 100 const Expr *
 101 Expr::findMaterializedTemporary(const MaterializeTemporaryExpr *&MTE) const {
 102   const Expr *E = this;
 103
 104   // This might be a default initializer for a reference member. Walk over the
 105   // wrapper node for that.
 106   if (const CXXDefaultInitExpr *DAE = dyn_cast<CXXDefaultInitExpr>(E))
 107     E = DAE->getExpr();
 108
 109   // Look through single-element init lists that claim to be lvalues. They're
 110   // just syntactic wrappers in this case.
 111   if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) {
 112     if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
 113       E = ILE->getInit(0);
 114       if (const CXXDefaultInitExpr *DAE = dyn_cast<CXXDefaultInitExpr>(E))
 115         E = DAE->getExpr();
 116     }
 117   }
 118
 119   // Look through expressions for materialized temporaries (for now).
 120   if (const MaterializeTemporaryExpr *M
 121       = dyn_cast<MaterializeTemporaryExpr>(E)) {
 122     MTE = M;
 123     E = M->GetTemporaryExpr();
 124   }
 125
 126   if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
 127     E = DAE->getExpr();
 128   return E;
 129 }
 130
 131 /// isKnownToHaveBooleanValue - Return true if this is an integer expression
 132 /// that is known to return 0 or 1.  This happens for _Bool/bool expressions
 133 /// but also int expressions which are produced by things like comparisons in
 134 /// C.
 135 bool Expr::isKnownToHaveBooleanValue() const {
 136   const Expr *E = IgnoreParens();
 137
 138   // If this value has _Bool type, it is obvious 0/1.
 139   if (E->getType()->isBooleanType()) return true;
 140   // If this is a non-scalar-integer type, we don't care enough to try.
 141   if (!E->getType()->isIntegralOrEnumerationType()) return false;
 142
 143   if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
 144     switch (UO->getOpcode()) {
 145     case UO_Plus:
 146       return UO->getSubExpr()->isKnownToHaveBooleanValue();
 147     default:
 148       return false;
 149     }
 150   }
 151
 152   // Only look through implicit casts.  If the user writes
 153   // '(int) (a && b)' treat it as an arbitrary int.
 154   if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E))
 155     return CE->getSubExpr()->isKnownToHaveBooleanValue();
 156
 157   if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
 158     switch (BO->getOpcode()) {
 159     default: return false;
 160     case BO_LT:   // Relational operators.
 161     case BO_GT:
 162     case BO_LE:
 163     case BO_GE:
 164     case BO_EQ:   // Equality operators.
 165     case BO_NE:
 166     case BO_LAnd: // AND operator.
 167     case BO_LOr:  // Logical OR operator.
 168       return true;
 169
 170     case BO_And:  // Bitwise AND operator.
 171     case BO_Xor:  // Bitwise XOR operator.
 172     case BO_Or:   // Bitwise OR operator.
 173       // Handle things like (x==2)|(y==12).
 174       return BO->getLHS()->isKnownToHaveBooleanValue() &&
 175              BO->getRHS()->isKnownToHaveBooleanValue();
 176
 177     case BO_Comma:
 178     case BO_Assign:
 179       return BO->getRHS()->isKnownToHaveBooleanValue();
 180     }
 181   }
 182
 183   if (const ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E))
 184     return CO->getTrueExpr()->isKnownToHaveBooleanValue() &&
 185            CO->getFalseExpr()->isKnownToHaveBooleanValue();
 186
 187   return false;
 188 }
 189
 190 // Amusing macro metaprogramming hack: check whether a class provides
 191 // a more specific implementation of getExprLoc().
 192 //
 193 // See also Stmt.cpp:{getLocStart(),getLocEnd()}.
 194 namespace {
 195   /// This implementation is used when a class provides a custom
 196   /// implementation of getExprLoc.
 197   template <class E, class T>
 198   SourceLocation getExprLocImpl(const Expr *expr,
 199                                 SourceLocation (T::*v)() const) {
 200     return static_cast<const E*>(expr)->getExprLoc();
 201   }
 202
 203   /// This implementation is used when a class doesn't provide
 204   /// a custom implementation of getExprLoc.  Overload resolution
 205   /// should pick it over the implementation above because it's
 206   /// more specialized according to function template partial ordering.
 207   template <class E>
 208   SourceLocation getExprLocImpl(const Expr *expr,
 209                                 SourceLocation (Expr::*v)() const) {
 210     return static_cast<const E*>(expr)->getLocStart();
 211   }
 212 }
 213
 214 SourceLocation Expr::getExprLoc() const {
 215   switch (getStmtClass()) {
 216   case Stmt::NoStmtClass: llvm_unreachable("statement without class");
 217 #define ABSTRACT_STMT(type)
 218 #define STMT(type, base) \
 219   case Stmt::type##Class: llvm_unreachable(#type " is not an Expr"); break;
 220 #define EXPR(type, base) \
 221   case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
 222 #include "clang/AST/StmtNodes.inc"
 223   }
 224   llvm_unreachable("unknown statement kind");
 225 }
 226
 227 //===----------------------------------------------------------------------===//
 228 // Primary Expressions.
 229 //===----------------------------------------------------------------------===//
 230
 231 /// \brief Compute the type-, value-, and instantiation-dependence of a
 232 /// declaration reference
 233 /// based on the declaration being referenced.
 234 static void computeDeclRefDependence(ASTContext &Ctx, NamedDecl *D, QualType T,
 235                                      bool &TypeDependent,
 236                                      bool &ValueDependent,
 237                                      bool &InstantiationDependent) {
 238   TypeDependent = false;
 239   ValueDependent = false;
 240   InstantiationDependent = false;
 241
 242   // (TD) C++ [temp.dep.expr]p3:
 243   //   An id-expression is type-dependent if it contains:
 244   //
 245   // and
 246   //
 247   // (VD) C++ [temp.dep.constexpr]p2:
 248   //  An identifier is value-dependent if it is:
 249
 250   //  (TD)  - an identifier that was declared with dependent type
 251   //  (VD)  - a name declared with a dependent type,
 252   if (T->isDependentType()) {
 253     TypeDependent = true;
 254     ValueDependent = true;
 255     InstantiationDependent = true;
 256     return;
 257   } else if (T->isInstantiationDependentType()) {
 258     InstantiationDependent = true;
 259   }
 260
 261   //  (TD)  - a conversion-function-id that specifies a dependent type
 262   if (D->getDeclName().getNameKind()
 263                                 == DeclarationName::CXXConversionFunctionName) {
 264     QualType T = D->getDeclName().getCXXNameType();
 265     if (T->isDependentType()) {
 266       TypeDependent = true;
 267       ValueDependent = true;
 268       InstantiationDependent = true;
 269       return;
 270     }
 271
 272     if (T->isInstantiationDependentType())
 273       InstantiationDependent = true;
 274   }
 275
 276   //  (VD)  - the name of a non-type template parameter,
 277   if (isa<NonTypeTemplateParmDecl>(D)) {
 278     ValueDependent = true;
 279     InstantiationDependent = true;
 280     return;
 281   }
 282
 283   //  (VD) - a constant with integral or enumeration type and is
 284   //         initialized with an expression that is value-dependent.
 285   //  (VD) - a constant with literal type and is initialized with an
 286   //         expression that is value-dependent [C++11].
 287   //  (VD) - FIXME: Missing from the standard:
 288   //       -  an entity with reference type and is initialized with an
 289   //          expression that is value-dependent [C++11]
 290   if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
 291     if ((Ctx.getLangOpts().CPlusPlus11 ?
 292            Var->getType()->isLiteralType(Ctx) :
 293            Var->getType()->isIntegralOrEnumerationType()) &&
 294         (Var->getType().isConstQualified() ||
 295          Var->getType()->isReferenceType())) {
 296       if (const Expr *Init = Var->getAnyInitializer())
 297         if (Init->isValueDependent()) {
 298           ValueDependent = true;
 299           InstantiationDependent = true;
 300         }
 301     }
 302
 303     // (VD) - FIXME: Missing from the standard:
 304     //      -  a member function or a static data member of the current
 305     //         instantiation
 306     if (Var->isStaticDataMember() &&
 307         Var->getDeclContext()->isDependentContext()) {
 308       ValueDependent = true;
 309       InstantiationDependent = true;
 310     }
 311
 312     return;
 313   }
 314
 315   // (VD) - FIXME: Missing from the standard:
 316   //      -  a member function or a static data member of the current
 317   //         instantiation
 318   if (isa<CXXMethodDecl>(D) && D->getDeclContext()->isDependentContext()) {
 319     ValueDependent = true;
 320     InstantiationDependent = true;
 321   }
 322 }
 323
 324 void DeclRefExpr::computeDependence(ASTContext &Ctx) {
 325   bool TypeDependent = false;
 326   bool ValueDependent = false;
 327   bool InstantiationDependent = false;
 328   computeDeclRefDependence(Ctx, getDecl(), getType(), TypeDependent,
 329                            ValueDependent, InstantiationDependent);
 330
 331   // (TD) C++ [temp.dep.expr]p3:
 332   //   An id-expression is type-dependent if it contains:
 333   //
 334   // and
 335   //
 336   // (VD) C++ [temp.dep.constexpr]p2:
 337   //  An identifier is value-dependent if it is:
 338   if (!TypeDependent && !ValueDependent &&
 339       hasExplicitTemplateArgs() &&
 340       TemplateSpecializationType::anyDependentTemplateArguments(
 341                                                             getTemplateArgs(),
 342                                                        getNumTemplateArgs(),
 343                                                       InstantiationDependent)) {
 344     TypeDependent = true;
 345     ValueDependent = true;
 346     InstantiationDependent = true;
 347   }
 348
 349   ExprBits.TypeDependent = TypeDependent;
 350   ExprBits.ValueDependent = ValueDependent;
 351   ExprBits.InstantiationDependent = InstantiationDependent;
 352
 353   // Is the declaration a parameter pack?
 354   if (getDecl()->isParameterPack())
 355     ExprBits.ContainsUnexpandedParameterPack = true;
 356 }
 357
 358 DeclRefExpr::DeclRefExpr(ASTContext &Ctx,
 359                          NestedNameSpecifierLoc QualifierLoc,
 360                          SourceLocation TemplateKWLoc,
 361                          ValueDecl *D, bool RefersToEnclosingLocal,
 362                          const DeclarationNameInfo &NameInfo,
 363                          NamedDecl *FoundD,
 364                          const TemplateArgumentListInfo *TemplateArgs,
 365                          QualType T, ExprValueKind VK)
 366   : Expr(DeclRefExprClass, T, VK, OK_Ordinary, false, false, false, false),
 367     D(D), Loc(NameInfo.getLoc()), DNLoc(NameInfo.getInfo()) {
 368   DeclRefExprBits.HasQualifier = QualifierLoc ? 1 : 0;
 369   if (QualifierLoc)
 370     getInternalQualifierLoc() = QualifierLoc;
 371   DeclRefExprBits.HasFoundDecl = FoundD ? 1 : 0;
 372   if (FoundD)
 373     getInternalFoundDecl() = FoundD;
 374   DeclRefExprBits.HasTemplateKWAndArgsInfo
 375     = (TemplateArgs || TemplateKWLoc.isValid()) ? 1 : 0;
 376   DeclRefExprBits.RefersToEnclosingLocal = RefersToEnclosingLocal;
 377   if (TemplateArgs) {
 378     bool Dependent = false;
 379     bool InstantiationDependent = false;
 380     bool ContainsUnexpandedParameterPack = false;
 381     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *TemplateArgs,
 382                                                Dependent,
 383                                                InstantiationDependent,
 384                                                ContainsUnexpandedParameterPack);
 385     if (InstantiationDependent)
 386       setInstantiationDependent(true);
 387   } else if (TemplateKWLoc.isValid()) {
 388     getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
 389   }
 390   DeclRefExprBits.HadMultipleCandidates = 0;
 391
 392   computeDependence(Ctx);
 393 }
 394
 395 DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
 396                                  NestedNameSpecifierLoc QualifierLoc,
 397                                  SourceLocation TemplateKWLoc,
 398                                  ValueDecl *D,
 399                                  bool RefersToEnclosingLocal,
 400                                  SourceLocation NameLoc,
 401                                  QualType T,
 402                                  ExprValueKind VK,
 403                                  NamedDecl *FoundD,
 404                                  const TemplateArgumentListInfo *TemplateArgs) {
 405   return Create(Context, QualifierLoc, TemplateKWLoc, D,
 406                 RefersToEnclosingLocal,
 407                 DeclarationNameInfo(D->getDeclName(), NameLoc),
 408                 T, VK, FoundD, TemplateArgs);
 409 }
 410
 411 DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
 412                                  NestedNameSpecifierLoc QualifierLoc,
 413                                  SourceLocation TemplateKWLoc,
 414                                  ValueDecl *D,
 415                                  bool RefersToEnclosingLocal,
 416                                  const DeclarationNameInfo &NameInfo,
 417                                  QualType T,
 418                                  ExprValueKind VK,
 419                                  NamedDecl *FoundD,
 420                                  const TemplateArgumentListInfo *TemplateArgs) {
 421   // Filter out cases where the found Decl is the same as the value refenenced.
 422   if (D == FoundD)
 423     FoundD = 0;
 424
 425   std::size_t Size = sizeof(DeclRefExpr);
 426   if (QualifierLoc != 0)
 427     Size += sizeof(NestedNameSpecifierLoc);
 428   if (FoundD)
 429     Size += sizeof(NamedDecl *);
 430   if (TemplateArgs)
 431     Size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size());
 432   else if (TemplateKWLoc.isValid())
 433     Size += ASTTemplateKWAndArgsInfo::sizeFor(0);
 434
 435   void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
 436   return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,
 437                                RefersToEnclosingLocal,
 438                                NameInfo, FoundD, TemplateArgs, T, VK);
 439 }
 440
 441 DeclRefExpr *DeclRefExpr::CreateEmpty(ASTContext &Context,
 442                                       bool HasQualifier,
 443                                       bool HasFoundDecl,
 444                                       bool HasTemplateKWAndArgsInfo,
 445                                       unsigned NumTemplateArgs) {
 446   std::size_t Size = sizeof(DeclRefExpr);
 447   if (HasQualifier)
 448     Size += sizeof(NestedNameSpecifierLoc);
 449   if (HasFoundDecl)
 450     Size += sizeof(NamedDecl *);
 451   if (HasTemplateKWAndArgsInfo)
 452     Size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
 453
 454   void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
 455   return new (Mem) DeclRefExpr(EmptyShell());
 456 }
 457
 458 SourceLocation DeclRefExpr::getLocStart() const {
 459   if (hasQualifier())
 460     return getQualifierLoc().getBeginLoc();
 461   return getNameInfo().getLocStart();
 462 }
 463 SourceLocation DeclRefExpr::getLocEnd() const {
 464   if (hasExplicitTemplateArgs())
 465     return getRAngleLoc();
 466   return getNameInfo().getLocEnd();
 467 }
 468
 469 // FIXME: Maybe this should use DeclPrinter with a special "print predefined
 470 // expr" policy instead.
 471 std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
 472   ASTContext &Context = CurrentDecl->getASTContext();
 473
 474   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
 475     if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual)
 476       return FD->getNameAsString();
 477
 478     SmallString<256> Name;
 479     llvm::raw_svector_ostream Out(Name);
 480
 481     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
 482       if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
 483         Out << "virtual ";
 484       if (MD->isStatic())
 485         Out << "static ";
 486     }
 487
 488     PrintingPolicy Policy(Context.getLangOpts());
 489     std::string Proto;
 490     llvm::raw_string_ostream POut(Proto);
 491     FD->printQualifiedName(POut, Policy);
 492
 493     const FunctionDecl *Decl = FD;
 494     if (const FunctionDecl* Pattern = FD->getTemplateInstantiationPattern())
 495       Decl = Pattern;
 496     const FunctionType *AFT = Decl->getType()->getAs<FunctionType>();
 497     const FunctionProtoType *FT = 0;
 498     if (FD->hasWrittenPrototype())
 499       FT = dyn_cast<FunctionProtoType>(AFT);
 500
 501     POut << "(";
 502     if (FT) {
 503       for (unsigned i = 0, e = Decl->getNumParams(); i != e; ++i) {
 504         if (i) POut << ", ";
 505         POut << Decl->getParamDecl(i)->getType().stream(Policy);
 506       }
 507
 508       if (FT->isVariadic()) {
 509         if (FD->getNumParams()) POut << ", ";
 510         POut << "...";
 511       }
 512     }
 513     POut << ")";
 514
 515     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
 516       const FunctionType *FT = MD->getType()->castAs<FunctionType>();
 517       if (FT->isConst())
 518         POut << " const";
 519       if (FT->isVolatile())
 520         POut << " volatile";
 521       RefQualifierKind Ref = MD->getRefQualifier();
 522       if (Ref == RQ_LValue)
 523         POut << " &";
 524       else if (Ref == RQ_RValue)
 525         POut << " &&";
 526     }
 527
 528     typedef SmallVector<const ClassTemplateSpecializationDecl *, 8> SpecsTy;
 529     SpecsTy Specs;
 530     const DeclContext *Ctx = FD->getDeclContext();
 531     while (Ctx && isa<NamedDecl>(Ctx)) {
 532       const ClassTemplateSpecializationDecl *Spec
 533                                = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
 534       if (Spec && !Spec->isExplicitSpecialization())
 535         Specs.push_back(Spec);
 536       Ctx = Ctx->getParent();
 537     }
 538
 539     std::string TemplateParams;
 540     llvm::raw_string_ostream TOut(TemplateParams);
 541     for (SpecsTy::reverse_iterator I = Specs.rbegin(), E = Specs.rend();
 542          I != E; ++I) {
 543       const TemplateParameterList *Params
 544                   = (*I)->getSpecializedTemplate()->getTemplateParameters();
 545       const TemplateArgumentList &Args = (*I)->getTemplateArgs();
 546       assert(Params->size() == Args.size());
 547       for (unsigned i = 0, numParams = Params->size(); i != numParams; ++i) {
 548         StringRef Param = Params->getParam(i)->getName();
 549         if (Param.empty()) continue;
 550         TOut << Param << " = ";
 551         Args.get(i).print(Policy, TOut);
 552         TOut << ", ";
 553       }
 554     }
 555
 556     FunctionTemplateSpecializationInfo *FSI
 557                                           = FD->getTemplateSpecializationInfo();
 558     if (FSI && !FSI->isExplicitSpecialization()) {
 559       const TemplateParameterList* Params
 560                                   = FSI->getTemplate()->getTemplateParameters();
 561       const TemplateArgumentList* Args = FSI->TemplateArguments;
 562       assert(Params->size() == Args->size());
 563       for (unsigned i = 0, e = Params->size(); i != e; ++i) {
 564         StringRef Param = Params->getParam(i)->getName();
 565         if (Param.empty()) continue;
 566         TOut << Param << " = ";
 567         Args->get(i).print(Policy, TOut);
 568         TOut << ", ";
 569       }
 570     }
 571
 572     TOut.flush();
 573     if (!TemplateParams.empty()) {
 574       // remove the trailing comma and space
 575       TemplateParams.resize(TemplateParams.size() - 2);
 576       POut << " [" << TemplateParams << "]";
 577     }
 578
 579     POut.flush();
 580
 581     if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
 582       AFT->getResultType().getAsStringInternal(Proto, Policy);
 583
 584     Out << Proto;
 585
 586     Out.flush();
 587     return Name.str().str();
 588   }
 589   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
 590     SmallString<256> Name;
 591     llvm::raw_svector_ostream Out(Name);
 592     Out << (MD->isInstanceMethod() ? '-' : '+');
 593     Out << '[';
 594
 595     // For incorrect code, there might not be an ObjCInterfaceDecl.  Do
 596     // a null check to avoid a crash.
 597     if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
 598       Out << *ID;
 599
 600     if (const ObjCCategoryImplDecl *CID =
 601         dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
 602       Out << '(' << *CID << ')';
 603
 604     Out <<  ' ';
 605     Out << MD->getSelector().getAsString();
 606     Out <<  ']';
 607
 608     Out.flush();
 609     return Name.str().str();
 610   }
 611   if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
 612     // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
 613     return "top level";
 614   }
 615   return "";
 616 }
 617
 618 void APNumericStorage::setIntValue(ASTContext &C, const llvm::APInt &Val) {
 619   if (hasAllocation())
 620     C.Deallocate(pVal);
 621
 622   BitWidth = Val.getBitWidth();
 623   unsigned NumWords = Val.getNumWords();
 624   const uint64_t* Words = Val.getRawData();
 625   if (NumWords > 1) {
 626     pVal = new (C) uint64_t[NumWords];
 627     std::copy(Words, Words + NumWords, pVal);
 628   } else if (NumWords == 1)
 629     VAL = Words[0];
 630   else
 631     VAL = 0;
 632 }
 633
 634 IntegerLiteral::IntegerLiteral(ASTContext &C, const llvm::APInt &V,
 635                                QualType type, SourceLocation l)
 636   : Expr(IntegerLiteralClass, type, VK_RValue, OK_Ordinary, false, false,
 637          false, false),
 638     Loc(l) {
 639   assert(type->isIntegerType() && "Illegal type in IntegerLiteral");
 640   assert(V.getBitWidth() == C.getIntWidth(type) &&
 641          "Integer type is not the correct size for constant.");
 642   setValue(C, V);
 643 }
 644
 645 IntegerLiteral *
 646 IntegerLiteral::Create(ASTContext &C, const llvm::APInt &V,
 647                        QualType type, SourceLocation l) {
 648   return new (C) IntegerLiteral(C, V, type, l);
 649 }
 650
 651 IntegerLiteral *
 652 IntegerLiteral::Create(ASTContext &C, EmptyShell Empty) {
 653   return new (C) IntegerLiteral(Empty);
 654 }
 655
 656 FloatingLiteral::FloatingLiteral(ASTContext &C, const llvm::APFloat &V,
 657                                  bool isexact, QualType Type, SourceLocation L)
 658   : Expr(FloatingLiteralClass, Type, VK_RValue, OK_Ordinary, false, false,
 659          false, false), Loc(L) {
 660   setSemantics(V.getSemantics());
 661   FloatingLiteralBits.IsExact = isexact;
 662   setValue(C, V);
 663 }
 664
 665 FloatingLiteral::FloatingLiteral(ASTContext &C, EmptyShell Empty)
 666   : Expr(FloatingLiteralClass, Empty) {
 667   setRawSemantics(IEEEhalf);
 668   FloatingLiteralBits.IsExact = false;
 669 }
 670
 671 FloatingLiteral *
 672 FloatingLiteral::Create(ASTContext &C, const llvm::APFloat &V,
 673                         bool isexact, QualType Type, SourceLocation L) {
 674   return new (C) FloatingLiteral(C, V, isexact, Type, L);
 675 }
 676
 677 FloatingLiteral *
 678 FloatingLiteral::Create(ASTContext &C, EmptyShell Empty) {
 679   return new (C) FloatingLiteral(C, Empty);
 680 }
 681
 682 const llvm::fltSemantics &FloatingLiteral::getSemantics() const {
 683   switch(FloatingLiteralBits.Semantics) {
 684   case IEEEhalf:
 685     return llvm::APFloat::IEEEhalf;
 686   case IEEEsingle:
 687     return llvm::APFloat::IEEEsingle;
 688   case IEEEdouble:
 689     return llvm::APFloat::IEEEdouble;
 690   case x87DoubleExtended:
 691     return llvm::APFloat::x87DoubleExtended;
 692   case IEEEquad:
 693     return llvm::APFloat::IEEEquad;
 694   case PPCDoubleDouble:
 695     return llvm::APFloat::PPCDoubleDouble;
 696   }
 697   llvm_unreachable("Unrecognised floating semantics");
 698 }
 699
 700 void FloatingLiteral::setSemantics(const llvm::fltSemantics &Sem) {
 701   if (&Sem == &llvm::APFloat::IEEEhalf)
 702     FloatingLiteralBits.Semantics = IEEEhalf;
 703   else if (&Sem == &llvm::APFloat::IEEEsingle)
 704     FloatingLiteralBits.Semantics = IEEEsingle;
 705   else if (&Sem == &llvm::APFloat::IEEEdouble)
 706     FloatingLiteralBits.Semantics = IEEEdouble;
 707   else if (&Sem == &llvm::APFloat::x87DoubleExtended)
 708     FloatingLiteralBits.Semantics = x87DoubleExtended;
 709   else if (&Sem == &llvm::APFloat::IEEEquad)
 710     FloatingLiteralBits.Semantics = IEEEquad;
 711   else if (&Sem == &llvm::APFloat::PPCDoubleDouble)
 712     FloatingLiteralBits.Semantics = PPCDoubleDouble;
 713   else
 714     llvm_unreachable("Unknown floating semantics");
 715 }
 716
 717 /// getValueAsApproximateDouble - This returns the value as an inaccurate
 718 /// double.  Note that this may cause loss of precision, but is useful for
 719 /// debugging dumps, etc.
 720 double FloatingLiteral::getValueAsApproximateDouble() const {
 721   llvm::APFloat V = getValue();
 722   bool ignored;
 723   V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
 724             &ignored);
 725   return V.convertToDouble();
 726 }
 727
 728 int StringLiteral::mapCharByteWidth(TargetInfo const &target,StringKind k) {
 729   int CharByteWidth = 0;
 730   switch(k) {
 731     case Ascii:
 732     case UTF8:
 733       CharByteWidth = target.getCharWidth();
 734       break;
 735     case Wide:
 736       CharByteWidth = target.getWCharWidth();
 737       break;
 738     case UTF16:
 739       CharByteWidth = target.getChar16Width();
 740       break;
 741     case UTF32:
 742       CharByteWidth = target.getChar32Width();
 743       break;
 744   }
 745   assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple");
 746   CharByteWidth /= 8;
 747   assert((CharByteWidth==1 || CharByteWidth==2 || CharByteWidth==4)
 748          && "character byte widths supported are 1, 2, and 4 only");
 749   return CharByteWidth;
 750 }
 751
 752 StringLiteral *StringLiteral::Create(ASTContext &C, StringRef Str,
 753                                      StringKind Kind, bool Pascal, QualType Ty,
 754                                      const SourceLocation *Loc,
 755                                      unsigned NumStrs) {
 756   // Allocate enough space for the StringLiteral plus an array of locations for
 757   // any concatenated string tokens.
 758   void *Mem = C.Allocate(sizeof(StringLiteral)+
 759                          sizeof(SourceLocation)*(NumStrs-1),
 760                          llvm::alignOf<StringLiteral>());
 761   StringLiteral *SL = new (Mem) StringLiteral(Ty);
 762
 763   // OPTIMIZE: could allocate this appended to the StringLiteral.
 764   SL->setString(C,Str,Kind,Pascal);
 765
 766   SL->TokLocs[0] = Loc[0];
 767   SL->NumConcatenated = NumStrs;
 768
 769   if (NumStrs != 1)
 770     memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
 771   return SL;
 772 }
 773
 774 StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
 775   void *Mem = C.Allocate(sizeof(StringLiteral)+
 776                          sizeof(SourceLocation)*(NumStrs-1),
 777                          llvm::alignOf<StringLiteral>());
 778   StringLiteral *SL = new (Mem) StringLiteral(QualType());
 779   SL->CharByteWidth = 0;
 780   SL->Length = 0;
 781   SL->NumConcatenated = NumStrs;
 782   return SL;
 783 }
 784
 785 void StringLiteral::outputString(raw_ostream &OS) const {
 786   switch (getKind()) {
 787   case Ascii: break; // no prefix.
 788   case Wide:  OS << 'L'; break;
 789   case UTF8:  OS << "u8"; break;
 790   case UTF16: OS << 'u'; break;
 791   case UTF32: OS << 'U'; break;
 792   }
 793   OS << '"';
 794   static const char Hex[] = "0123456789ABCDEF";
 795
 796   unsigned LastSlashX = getLength();
 797   for (unsigned I = 0, N = getLength(); I != N; ++I) {
 798     switch (uint32_t Char = getCodeUnit(I)) {
 799     default:
 800       // FIXME: Convert UTF-8 back to codepoints before rendering.
 801
 802       // Convert UTF-16 surrogate pairs back to codepoints before rendering.
 803       // Leave invalid surrogates alone; we'll use \x for those.
 804       if (getKind() == UTF16 && I != N - 1 && Char >= 0xd800 &&
 805           Char <= 0xdbff) {
 806         uint32_t Trail = getCodeUnit(I + 1);
 807         if (Trail >= 0xdc00 && Trail <= 0xdfff) {
 808           Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);
 809           ++I;
 810         }
 811       }
 812
 813       if (Char > 0xff) {
 814         // If this is a wide string, output characters over 0xff using \x
 815         // escapes. Otherwise, this is a UTF-16 or UTF-32 string, and Char is a
 816         // codepoint: use \x escapes for invalid codepoints.
 817         if (getKind() == Wide ||
 818             (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
 819           // FIXME: Is this the best way to print wchar_t?
 820           OS << "\\x";
 821           int Shift = 28;
 822           while ((Char >> Shift) == 0)
 823             Shift -= 4;
 824           for (/**/; Shift >= 0; Shift -= 4)
 825             OS << Hex[(Char >> Shift) & 15];
 826           LastSlashX = I;
 827           break;
 828         }
 829
 830         if (Char > 0xffff)
 831           OS << "\\U00"
 832              << Hex[(Char >> 20) & 15]
 833              << Hex[(Char >> 16) & 15];
 834         else
 835           OS << "\\u";
 836         OS << Hex[(Char >> 12) & 15]
 837            << Hex[(Char >>  8) & 15]
 838            << Hex[(Char >>  4) & 15]
 839            << Hex[(Char >>  0) & 15];
 840         break;
 841       }
 842
 843       // If we used \x... for the previous character, and this character is a
 844       // hexadecimal digit, prevent it being slurped as part of the \x.
 845       if (LastSlashX + 1 == I) {
 846         switch (Char) {
 847           case '0': case '1': case '2': case '3': case '4':
 848           case '5': case '6': case '7': case '8': case '9':
 849           case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
 850           case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
 851             OS << "\"\"";
 852         }
 853       }
 854
 855       assert(Char <= 0xff &&
 856              "Characters above 0xff should already have been handled.");
 857
 858       if (isPrintable(Char))
 859         OS << (char)Char;
 860       else  // Output anything hard as an octal escape.
 861         OS << '\\'
 862            << (char)('0' + ((Char >> 6) & 7))
 863            << (char)('0' + ((Char >> 3) & 7))
 864            << (char)('0' + ((Char >> 0) & 7));
 865       break;
 866     // Handle some common non-printable cases to make dumps prettier.
 867     case '\\': OS << "\\\\"; break;
 868     case '"': OS << "\\\""; break;
 869     case '\n': OS << "\\n"; break;
 870     case '\t': OS << "\\t"; break;
 871     case '\a': OS << "\\a"; break;
 872     case '\b': OS << "\\b"; break;
 873     }
 874   }
 875   OS << '"';
 876 }
 877
 878 void StringLiteral::setString(ASTContext &C, StringRef Str,
 879                               StringKind Kind, bool IsPascal) {
 880   //FIXME: we assume that the string data comes from a target that uses the same
 881   // code unit size and endianess for the type of string.
 882   this->Kind = Kind;
 883   this->IsPascal = IsPascal;
 884
 885   CharByteWidth = mapCharByteWidth(C.getTargetInfo(),Kind);
 886   assert((Str.size()%CharByteWidth == 0)
 887          && "size of data must be multiple of CharByteWidth");
 888   Length = Str.size()/CharByteWidth;
 889
 890   switch(CharByteWidth) {
 891     case 1: {
 892       char *AStrData = new (C) char[Length];
 893       std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
 894       StrData.asChar = AStrData;
 895       break;
 896     }
 897     case 2: {
 898       uint16_t *AStrData = new (C) uint16_t[Length];
 899       std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
 900       StrData.asUInt16 = AStrData;
 901       break;
 902     }
 903     case 4: {
 904       uint32_t *AStrData = new (C) uint32_t[Length];
 905       std::memcpy(AStrData,Str.data(),Length*sizeof(*AStrData));
 906       StrData.asUInt32 = AStrData;
 907       break;
 908     }
 909     default:
 910       assert(false && "unsupported CharByteWidth");
 911   }
 912 }
 913
 914 /// getLocationOfByte - Return a source location that points to the specified
 915 /// byte of this string literal.
 916 ///
 917 /// Strings are amazingly complex.  They can be formed from multiple tokens and
 918 /// can have escape sequences in them in addition to the usual trigraph and
 919 /// escaped newline business.  This routine handles this complexity.
 920 ///
 921 SourceLocation StringLiteral::
 922 getLocationOfByte(unsigned ByteNo, const SourceManager &SM,
 923                   const LangOptions &Features, const TargetInfo &Target) const {
 924   assert((Kind == StringLiteral::Ascii || Kind == StringLiteral::UTF8) &&
 925          "Only narrow string literals are currently supported");
 926
 927   // Loop over all of the tokens in this string until we find the one that
 928   // contains the byte we're looking for.
 929   unsigned TokNo = 0;
 930   while (1) {
 931     assert(TokNo < getNumConcatenated() && "Invalid byte number!");
 932     SourceLocation StrTokLoc = getStrTokenLoc(TokNo);
 933
 934     // Get the spelling of the string so that we can get the data that makes up
 935     // the string literal, not the identifier for the macro it is potentially
 936     // expanded through.
 937     SourceLocation StrTokSpellingLoc = SM.getSpellingLoc(StrTokLoc);
 938
 939     // Re-lex the token to get its length and original spelling.
 940     std::pair<FileID, unsigned> LocInfo =SM.getDecomposedLoc(StrTokSpellingLoc);
 941     bool Invalid = false;
 942     StringRef Buffer = SM.getBufferData(LocInfo.first, &Invalid);
 943     if (Invalid)
 944       return StrTokSpellingLoc;
 945
 946     const char *StrData = Buffer.data()+LocInfo.second;
 947
 948     // Create a lexer starting at the beginning of this token.
 949     Lexer TheLexer(SM.getLocForStartOfFile(LocInfo.first), Features,
 950                    Buffer.begin(), StrData, Buffer.end());
 951     Token TheTok;
 952     TheLexer.LexFromRawLexer(TheTok);
 953
 954     // Use the StringLiteralParser to compute the length of the string in bytes.
 955     StringLiteralParser SLP(&TheTok, 1, SM, Features, Target);
 956     unsigned TokNumBytes = SLP.GetStringLength();
 957
 958     // If the byte is in this token, return the location of the byte.
 959     if (ByteNo < TokNumBytes ||
 960         (ByteNo == TokNumBytes && TokNo == getNumConcatenated() - 1)) {
 961       unsigned Offset = SLP.getOffsetOfStringByte(TheTok, ByteNo);
 962
 963       // Now that we know the offset of the token in the spelling, use the
 964       // preprocessor to get the offset in the original source.
 965       return Lexer::AdvanceToTokenCharacter(StrTokLoc, Offset, SM, Features);
 966     }
 967
 968     // Move to the next string token.
 969     ++TokNo;
 970     ByteNo -= TokNumBytes;
 971   }
 972 }
 973
 974
 975
 976 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
 977 /// corresponds to, e.g. "sizeof" or "[pre]++".
 978 StringRef UnaryOperator::getOpcodeStr(Opcode Op) {
 979   switch (Op) {
 980   case UO_PostInc: return "++";
 981   case UO_PostDec: return "--";
 982   case UO_PreInc:  return "++";
 983   case UO_PreDec:  return "--";
 984   case UO_AddrOf:  return "&";
 985   case UO_Deref:   return "*";
 986   case UO_Plus:    return "+";
 987   case UO_Minus:   return "-";
 988   case UO_Not:     return "~";
 989   case UO_LNot:    return "!";
 990   case UO_Real:    return "__real";
 991   case UO_Imag:    return "__imag";
 992   case UO_Extension: return "__extension__";
 993   }
 994   llvm_unreachable("Unknown unary operator");
 995 }
 996
 997 UnaryOperatorKind
 998 UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
 999   switch (OO) {
1000   default: llvm_unreachable("No unary operator for overloaded function");
1001   case OO_PlusPlus:   return Postfix ? UO_PostInc : UO_PreInc;
1002   case OO_MinusMinus: return Postfix ? UO_PostDec : UO_PreDec;
1003   case OO_Amp:        return UO_AddrOf;
1004   case OO_Star:       return UO_Deref;
1005   case OO_Plus:       return UO_Plus;
1006   case OO_Minus:      return UO_Minus;
1007   case OO_Tilde:      return UO_Not;
1008   case OO_Exclaim:    return UO_LNot;
1009   }
1010 }
1011
1012 OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
1013   switch (Opc) {
1014   case UO_PostInc: case UO_PreInc: return OO_PlusPlus;
1015   case UO_PostDec: case UO_PreDec: return OO_MinusMinus;
1016   case UO_AddrOf: return OO_Amp;
1017   case UO_Deref: return OO_Star;
1018   case UO_Plus: return OO_Plus;
1019   case UO_Minus: return OO_Minus;
1020   case UO_Not: return OO_Tilde;
1021   case UO_LNot: return OO_Exclaim;
1022   default: return OO_None;
1023   }
1024 }
1025
1026
1027 //===----------------------------------------------------------------------===//
1028 // Postfix Operators.
1029 //===----------------------------------------------------------------------===//
1030
1031 CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, unsigned NumPreArgs,
1032                    ArrayRef<Expr*> args, QualType t, ExprValueKind VK,
1033                    SourceLocation rparenloc)
1034   : Expr(SC, t, VK, OK_Ordinary,
1035          fn->isTypeDependent(),
1036          fn->isValueDependent(),
1037          fn->isInstantiationDependent(),
1038          fn->containsUnexpandedParameterPack()),
1039     NumArgs(args.size()) {
1040
1041   SubExprs = new (C) Stmt*[args.size()+PREARGS_START+NumPreArgs];
1042   SubExprs[FN] = fn;
1043   for (unsigned i = 0; i != args.size(); ++i) {
1044     if (args[i]->isTypeDependent())
1045       ExprBits.TypeDependent = true;
1046     if (args[i]->isValueDependent())
1047       ExprBits.ValueDependent = true;
1048     if (args[i]->isInstantiationDependent())
1049       ExprBits.InstantiationDependent = true;
1050     if (args[i]->containsUnexpandedParameterPack())
1051       ExprBits.ContainsUnexpandedParameterPack = true;
1052
1053     SubExprs[i+PREARGS_START+NumPreArgs] = args[i];
1054   }
1055
1056   CallExprBits.NumPreArgs = NumPreArgs;
1057   RParenLoc = rparenloc;
1058 }
1059
1060 CallExpr::CallExpr(ASTContext& C, Expr *fn, ArrayRef<Expr*> args,
1061                    QualType t, ExprValueKind VK, SourceLocation rparenloc)
1062   : Expr(CallExprClass, t, VK, OK_Ordinary,
1063          fn->isTypeDependent(),
1064          fn->isValueDependent(),
1065          fn->isInstantiationDependent(),
1066          fn->containsUnexpandedParameterPack()),
1067     NumArgs(args.size()) {
1068
1069   SubExprs = new (C) Stmt*[args.size()+PREARGS_START];
1070   SubExprs[FN] = fn;
1071   for (unsigned i = 0; i != args.size(); ++i) {
1072     if (args[i]->isTypeDependent())
1073       ExprBits.TypeDependent = true;
1074     if (args[i]->isValueDependent())
1075       ExprBits.ValueDependent = true;
1076     if (args[i]->isInstantiationDependent())
1077       ExprBits.InstantiationDependent = true;
1078     if (args[i]->containsUnexpandedParameterPack())
1079       ExprBits.ContainsUnexpandedParameterPack = true;
1080
1081     SubExprs[i+PREARGS_START] = args[i];
1082   }
1083
1084   CallExprBits.NumPreArgs = 0;
1085   RParenLoc = rparenloc;
1086 }
1087
1088 CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
1089   : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
1090   // FIXME: Why do we allocate this?
1091   SubExprs = new (C) Stmt*[PREARGS_START];
1092   CallExprBits.NumPreArgs = 0;
1093 }
1094
1095 CallExpr::CallExpr(ASTContext &C, StmtClass SC, unsigned NumPreArgs,
1096                    EmptyShell Empty)
1097   : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
1098   // FIXME: Why do we allocate this?
1099   SubExprs = new (C) Stmt*[PREARGS_START+NumPreArgs];
1100   CallExprBits.NumPreArgs = NumPreArgs;
1101 }
1102
1103 Decl *CallExpr::getCalleeDecl() {
1104   Expr *CEE = getCallee()->IgnoreParenImpCasts();
1105
1106   while (SubstNonTypeTemplateParmExpr *NTTP
1107                                 = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
1108     CEE = NTTP->getReplacement()->IgnoreParenCasts();
1109   }
1110
1111   // If we're calling a dereference, look at the pointer instead.
1112   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(CEE)) {
1113     if (BO->isPtrMemOp())
1114       CEE = BO->getRHS()->IgnoreParenCasts();
1115   } else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
1116     if (UO->getOpcode() == UO_Deref)
1117       CEE = UO->getSubExpr()->IgnoreParenCasts();
1118   }
1119   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
1120     return DRE->getDecl();
1121   if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
1122     return ME->getMemberDecl();
1123
1124   return 0;
1125 }
1126
1127 FunctionDecl *CallExpr::getDirectCallee() {
1128   return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
1129 }
1130
1131 /// setNumArgs - This changes the number of arguments present in this call.
1132 /// Any orphaned expressions are deleted by this, and any new operands are set
1133 /// to null.
1134 void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
1135   // No change, just return.
1136   if (NumArgs == getNumArgs()) return;
1137
1138   // If shrinking # arguments, just delete the extras and forgot them.
1139   if (NumArgs < getNumArgs()) {
1140     this->NumArgs = NumArgs;
1141     return;
1142   }
1143
1144   // Otherwise, we are growing the # arguments.  New an bigger argument array.
1145   unsigned NumPreArgs = getNumPreArgs();
1146   Stmt **NewSubExprs = new (C) Stmt*[NumArgs+PREARGS_START+NumPreArgs];
1147   // Copy over args.
1148   for (unsigned i = 0; i != getNumArgs()+PREARGS_START+NumPreArgs; ++i)
1149     NewSubExprs[i] = SubExprs[i];
1150   // Null out new args.
1151   for (unsigned i = getNumArgs()+PREARGS_START+NumPreArgs;
1152        i != NumArgs+PREARGS_START+NumPreArgs; ++i)
1153     NewSubExprs[i] = 0;
1154
1155   if (SubExprs) C.Deallocate(SubExprs);
1156   SubExprs = NewSubExprs;
1157   this->NumArgs = NumArgs;
1158 }
1159
1160 /// isBuiltinCall - If this is a call to a builtin, return the builtin ID.  If
1161 /// not, return 0.
1162 unsigned CallExpr::isBuiltinCall() const {
1163   // All simple function calls (e.g. func()) are implicitly cast to pointer to
1164   // function. As a result, we try and obtain the DeclRefExpr from the
1165   // ImplicitCastExpr.
1166   const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
1167   if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
1168     return 0;
1169
1170   const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
1171   if (!DRE)
1172     return 0;
1173
1174   const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
1175   if (!FDecl)
1176     return 0;
1177
1178   if (!FDecl->getIdentifier())
1179     return 0;
1180
1181   return FDecl->getBuiltinID();
1182 }
1183
1184 bool CallExpr::isUnevaluatedBuiltinCall(ASTContext &Ctx) const {
1185   if (unsigned BI = isBuiltinCall())
1186     return Ctx.BuiltinInfo.isUnevaluated(BI);
1187   return false;
1188 }
1189
1190 QualType CallExpr::getCallReturnType() const {
1191   QualType CalleeType = getCallee()->getType();
1192   if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
1193     CalleeType = FnTypePtr->getPointeeType();
1194   else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
1195     CalleeType = BPT->getPointeeType();
1196   else if (CalleeType->isSpecificPlaceholderType(BuiltinType::BoundMember))
1197     // This should never be overloaded and so should never return null.
1198     CalleeType = Expr::findBoundMemberType(getCallee());
1199
1200   const FunctionType *FnType = CalleeType->castAs<FunctionType>();
1201   return FnType->getResultType();
1202 }
1203
1204 SourceLocation CallExpr::getLocStart() const {
1205   if (isa<CXXOperatorCallExpr>(this))
1206     return cast<CXXOperatorCallExpr>(this)->getLocStart();
1207
1208   SourceLocation begin = getCallee()->getLocStart();
1209   if (begin.isInvalid() && getNumArgs() > 0)
1210     begin = getArg(0)->getLocStart();
1211   return begin;
1212 }
1213 SourceLocation CallExpr::getLocEnd() const {
1214   if (isa<CXXOperatorCallExpr>(this))
1215     return cast<CXXOperatorCallExpr>(this)->getLocEnd();
1216
1217   SourceLocation end = getRParenLoc();
1218   if (end.isInvalid() && getNumArgs() > 0)
1219     end = getArg(getNumArgs() - 1)->getLocEnd();
1220   return end;
1221 }
1222
1223 OffsetOfExpr *OffsetOfExpr::Create(ASTContext &C, QualType type,
1224                                    SourceLocation OperatorLoc,
1225                                    TypeSourceInfo *tsi,
1226                                    ArrayRef<OffsetOfNode> comps,
1227                                    ArrayRef<Expr*> exprs,
1228                                    SourceLocation RParenLoc) {
1229   void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
1230                          sizeof(OffsetOfNode) * comps.size() +
1231                          sizeof(Expr*) * exprs.size());
1232
1233   return new (Mem) OffsetOfExpr(C, type, OperatorLoc, tsi, comps, exprs,
1234                                 RParenLoc);
1235 }
1236
1237 OffsetOfExpr *OffsetOfExpr::CreateEmpty(ASTContext &C,
1238                                         unsigned numComps, unsigned numExprs) {
1239   void *Mem = C.Allocate(sizeof(OffsetOfExpr) +
1240                          sizeof(OffsetOfNode) * numComps +
1241                          sizeof(Expr*) * numExprs);
1242   return new (Mem) OffsetOfExpr(numComps, numExprs);
1243 }
1244
1245 OffsetOfExpr::OffsetOfExpr(ASTContext &C, QualType type,
1246                            SourceLocation OperatorLoc, TypeSourceInfo *tsi,
1247                            ArrayRef<OffsetOfNode> comps, ArrayRef<Expr*> exprs,
1248                            SourceLocation RParenLoc)
1249   : Expr(OffsetOfExprClass, type, VK_RValue, OK_Ordinary,
1250          /*TypeDependent=*/false,
1251          /*ValueDependent=*/tsi->getType()->isDependentType(),
1252          tsi->getType()->isInstantiationDependentType(),
1253          tsi->getType()->containsUnexpandedParameterPack()),
1254     OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
1255     NumComps(comps.size()), NumExprs(exprs.size())
1256 {
1257   for (unsigned i = 0; i != comps.size(); ++i) {
1258     setComponent(i, comps[i]);
1259   }
1260
1261   for (unsigned i = 0; i != exprs.size(); ++i) {
1262     if (exprs[i]->isTypeDependent() || exprs[i]->isValueDependent())
1263       ExprBits.ValueDependent = true;
1264     if (exprs[i]->containsUnexpandedParameterPack())
1265       ExprBits.ContainsUnexpandedParameterPack = true;
1266
1267     setIndexExpr(i, exprs[i]);
1268   }
1269 }
1270
1271 IdentifierInfo *OffsetOfExpr::OffsetOfNode::getFieldName() const {
1272   assert(getKind() == Field || getKind() == Identifier);
1273   if (getKind() == Field)
1274     return getField()->getIdentifier();
1275
1276   return reinterpret_cast<IdentifierInfo *> (Data & ~(uintptr_t)Mask);
1277 }
1278
1279 MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
1280                                NestedNameSpecifierLoc QualifierLoc,
1281                                SourceLocation TemplateKWLoc,
1282                                ValueDecl *memberdecl,
1283                                DeclAccessPair founddecl,
1284                                DeclarationNameInfo nameinfo,
1285                                const TemplateArgumentListInfo *targs,
1286                                QualType ty,
1287                                ExprValueKind vk,
1288                                ExprObjectKind ok) {
1289   std::size_t Size = sizeof(MemberExpr);
1290
1291   bool hasQualOrFound = (QualifierLoc ||
1292                          founddecl.getDecl() != memberdecl ||
1293                          founddecl.getAccess() != memberdecl->getAccess());
1294   if (hasQualOrFound)
1295     Size += sizeof(MemberNameQualifier);
1296
1297   if (targs)
1298     Size += ASTTemplateKWAndArgsInfo::sizeFor(targs->size());
1299   else if (TemplateKWLoc.isValid())
1300     Size += ASTTemplateKWAndArgsInfo::sizeFor(0);
1301
1302   void *Mem = C.Allocate(Size, llvm::alignOf<MemberExpr>());
1303   MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, nameinfo,
1304                                        ty, vk, ok);
1305
1306   if (hasQualOrFound) {
1307     // FIXME: Wrong. We should be looking at the member declaration we found.
1308     if (QualifierLoc && QualifierLoc.getNestedNameSpecifier()->isDependent()) {
1309       E->setValueDependent(true);
1310       E->setTypeDependent(true);
1311       E->setInstantiationDependent(true);
1312     }
1313     else if (QualifierLoc &&
1314              QualifierLoc.getNestedNameSpecifier()->isInstantiationDependent())
1315       E->setInstantiationDependent(true);
1316
1317     E->HasQualifierOrFoundDecl = true;
1318
1319     MemberNameQualifier *NQ = E->getMemberQualifier();
1320     NQ->QualifierLoc = QualifierLoc;
1321     NQ->FoundDecl = founddecl;
1322   }
1323
1324   E->HasTemplateKWAndArgsInfo = (targs || TemplateKWLoc.isValid());
1325
1326   if (targs) {
1327     bool Dependent = false;
1328     bool InstantiationDependent = false;
1329     bool ContainsUnexpandedParameterPack = false;
1330     E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc, *targs,
1331                                                   Dependent,
1332                                                   InstantiationDependent,
1333                                              ContainsUnexpandedParameterPack);
1334     if (InstantiationDependent)
1335       E->setInstantiationDependent(true);
1336   } else if (TemplateKWLoc.isValid()) {
1337     E->getTemplateKWAndArgsInfo()->initializeFrom(TemplateKWLoc);
1338   }
1339
1340   return E;
1341 }
1342
1343 SourceLocation MemberExpr::getLocStart() const {
1344   if (isImplicitAccess()) {
1345     if (hasQualifier())
1346       return getQualifierLoc().getBeginLoc();
1347     return MemberLoc;
1348   }
1349
1350   // FIXME: We don't want this to happen. Rather, we should be able to
1351   // detect all kinds of implicit accesses more cleanly.
1352   SourceLocation BaseStartLoc = getBase()->getLocStart();
1353   if (BaseStartLoc.isValid())
1354     return BaseStartLoc;
1355   return MemberLoc;
1356 }
1357 SourceLocation MemberExpr::getLocEnd() const {
1358   SourceLocation EndLoc = getMemberNameInfo().getEndLoc();
1359   if (hasExplicitTemplateArgs())
1360     EndLoc = getRAngleLoc();
1361   else if (EndLoc.isInvalid())
1362     EndLoc = getBase()->getLocEnd();
1363   return EndLoc;
1364 }
1365
1366 void CastExpr::CheckCastConsistency() const {
1367   switch (getCastKind()) {
1368   case CK_DerivedToBase:
1369   case CK_UncheckedDerivedToBase:
1370   case CK_DerivedToBaseMemberPointer:
1371   case CK_BaseToDerived:
1372   case CK_BaseToDerivedMemberPointer:
1373     assert(!path_empty() && "Cast kind should have a base path!");
1374     break;
1375
1376   case CK_CPointerToObjCPointerCast:
1377     assert(getType()->isObjCObjectPointerType());
1378     assert(getSubExpr()->getType()->isPointerType());
1379     goto CheckNoBasePath;
1380
1381   case CK_BlockPointerToObjCPointerCast:
1382     assert(getType()->isObjCObjectPointerType());
1383     assert(getSubExpr()->getType()->isBlockPointerType());
1384     goto CheckNoBasePath;
1385
1386   case CK_ReinterpretMemberPointer:
1387     assert(getType()->isMemberPointerType());
1388     assert(getSubExpr()->getType()->isMemberPointerType());
1389     goto CheckNoBasePath;
1390
1391   case CK_BitCast:
1392     // Arbitrary casts to C pointer types count as bitcasts.
1393     // Otherwise, we should only have block and ObjC pointer casts
1394     // here if they stay within the type kind.
1395     if (!getType()->isPointerType()) {
1396       assert(getType()->isObjCObjectPointerType() ==
1397              getSubExpr()->getType()->isObjCObjectPointerType());
1398       assert(getType()->isBlockPointerType() ==
1399              getSubExpr()->getType()->isBlockPointerType());
1400     }
1401     goto CheckNoBasePath;
1402
1403   case CK_AnyPointerToBlockPointerCast:
1404     assert(getType()->isBlockPointerType());
1405     assert(getSubExpr()->getType()->isAnyPointerType() &&
1406            !getSubExpr()->getType()->isBlockPointerType());
1407     goto CheckNoBasePath;
1408
1409   case CK_CopyAndAutoreleaseBlockObject:
1410     assert(getType()->isBlockPointerType());
1411     assert(getSubExpr()->getType()->isBlockPointerType());
1412     goto CheckNoBasePath;
1413
1414   case CK_FunctionToPointerDecay:
1415     assert(getType()->isPointerType());
1416     assert(getSubExpr()->getType()->isFunctionType());
1417     goto CheckNoBasePath;
1418
1419   // These should not have an inheritance path.
1420   case CK_Dynamic:
1421   case CK_ToUnion:
1422   case CK_ArrayToPointerDecay:
1423   case CK_NullToMemberPointer:
1424   case CK_NullToPointer:
1425   case CK_ConstructorConversion:
1426   case CK_IntegralToPointer:
1427   case CK_PointerToIntegral:
1428   case CK_ToVoid:
1429   case CK_VectorSplat:
1430   case CK_IntegralCast:
1431   case CK_IntegralToFloating:
1432   case CK_FloatingToIntegral:
1433   case CK_FloatingCast:
1434   case CK_ObjCObjectLValueCast:
1435   case CK_FloatingRealToComplex:
1436   case CK_FloatingComplexToReal:
1437   case CK_FloatingComplexCast:
1438   case CK_FloatingComplexToIntegralComplex:
1439   case CK_IntegralRealToComplex:
1440   case CK_IntegralComplexToReal:
1441   case CK_IntegralComplexCast:
1442   case CK_IntegralComplexToFloatingComplex:
1443   case CK_ARCProduceObject:
1444   case CK_ARCConsumeObject:
1445   case CK_ARCReclaimReturnedObject:
1446   case CK_ARCExtendBlockObject:
1447   case CK_ZeroToOCLEvent:
1448     assert(!getType()->isBooleanType() && "unheralded conversion to bool");
1449     goto CheckNoBasePath;
1450
1451   case CK_Dependent:
1452   case CK_LValueToRValue:
1453   case CK_NoOp:
1454   case CK_AtomicToNonAtomic:
1455   case CK_NonAtomicToAtomic:
1456   case CK_PointerToBoolean:
1457   case CK_IntegralToBoolean:
1458   case CK_FloatingToBoolean:
1459   case CK_MemberPointerToBoolean:
1460   case CK_FloatingComplexToBoolean:
1461   case CK_IntegralComplexToBoolean:
1462   case CK_LValueBitCast:            // -> bool&
1463   case CK_UserDefinedConversion:    // operator bool()
1464   case CK_BuiltinFnToFnPtr:
1465   CheckNoBasePath:
1466     assert(path_empty() && "Cast kind should not have a base path!");
1467     break;
1468   }
1469 }
1470
1471 const char *CastExpr::getCastKindName() const {
1472   switch (getCastKind()) {
1473   case CK_Dependent:
1474     return "Dependent";
1475   case CK_BitCast:
1476     return "BitCast";
1477   case CK_LValueBitCast:
1478     return "LValueBitCast";
1479   case CK_LValueToRValue:
1480     return "LValueToRValue";
1481   case CK_NoOp:
1482     return "NoOp";
1483   case CK_BaseToDerived:
1484     return "BaseToDerived";
1485   case CK_DerivedToBase:
1486     return "DerivedToBase";
1487   case CK_UncheckedDerivedToBase:
1488     return "UncheckedDerivedToBase";
1489   case CK_Dynamic:
1490     return "Dynamic";
1491   case CK_ToUnion:
1492     return "ToUnion";
1493   case CK_ArrayToPointerDecay:
1494     return "ArrayToPointerDecay";
1495   case CK_FunctionToPointerDecay:
1496     return "FunctionToPointerDecay";
1497   case CK_NullToMemberPointer:
1498     return "NullToMemberPointer";
1499   case CK_NullToPointer:
1500     return "NullToPointer";
1501   case CK_BaseToDerivedMemberPointer:
1502     return "BaseToDerivedMemberPointer";
1503   case CK_DerivedToBaseMemberPointer:
1504     return "DerivedToBaseMemberPointer";
1505   case CK_ReinterpretMemberPointer:
1506     return "ReinterpretMemberPointer";
1507   case CK_UserDefinedConversion:
1508     return "UserDefinedConversion";
1509   case CK_ConstructorConversion:
1510     return "ConstructorConversion";
1511   case CK_IntegralToPointer:
1512     return "IntegralToPointer";
1513   case CK_PointerToIntegral:
1514     return "PointerToIntegral";
1515   case CK_PointerToBoolean:
1516     return "PointerToBoolean";
1517   case CK_ToVoid:
1518     return "ToVoid";
1519   case CK_VectorSplat:
1520     return "VectorSplat";
1521   case CK_IntegralCast:
1522     return "IntegralCast";
1523   case CK_IntegralToBoolean:
1524     return "IntegralToBoolean";
1525   case CK_IntegralToFloating:
1526     return "IntegralToFloating";
1527   case CK_FloatingToIntegral:
1528     return "FloatingToIntegral";
1529   case CK_FloatingCast:
1530     return "FloatingCast";
1531   case CK_FloatingToBoolean:
1532     return "FloatingToBoolean";
1533   case CK_MemberPointerToBoolean:
1534     return "MemberPointerToBoolean";
1535   case CK_CPointerToObjCPointerCast:
1536     return "CPointerToObjCPointerCast";
1537   case CK_BlockPointerToObjCPointerCast:
1538     return "BlockPointerToObjCPointerCast";
1539   case CK_AnyPointerToBlockPointerCast:
1540     return "AnyPointerToBlockPointerCast";
1541   case CK_ObjCObjectLValueCast:
1542     return "ObjCObjectLValueCast";
1543   case CK_FloatingRealToComplex:
1544     return "FloatingRealToComplex";
1545   case CK_FloatingComplexToReal:
1546     return "FloatingComplexToReal";
1547   case CK_FloatingComplexToBoolean:
1548     return "FloatingComplexToBoolean";
1549   case CK_FloatingComplexCast:
1550     return "FloatingComplexCast";
1551   case CK_FloatingComplexToIntegralComplex:
1552     return "FloatingComplexToIntegralComplex";
1553   case CK_IntegralRealToComplex:
1554     return "IntegralRealToComplex";
1555   case CK_IntegralComplexToReal:
1556     return "IntegralComplexToReal";
1557   case CK_IntegralComplexToBoolean:
1558     return "IntegralComplexToBoolean";
1559   case CK_IntegralComplexCast:
1560     return "IntegralComplexCast";
1561   case CK_IntegralComplexToFloatingComplex:
1562     return "IntegralComplexToFloatingComplex";
1563   case CK_ARCConsumeObject:
1564     return "ARCConsumeObject";
1565   case CK_ARCProduceObject:
1566     return "ARCProduceObject";
1567   case CK_ARCReclaimReturnedObject:
1568     return "ARCReclaimReturnedObject";
1569   case CK_ARCExtendBlockObject:
1570     return "ARCCExtendBlockObject";
1571   case CK_AtomicToNonAtomic:
1572     return "AtomicToNonAtomic";
1573   case CK_NonAtomicToAtomic:
1574     return "NonAtomicToAtomic";
1575   case CK_CopyAndAutoreleaseBlockObject:
1576     return "CopyAndAutoreleaseBlockObject";
1577   case CK_BuiltinFnToFnPtr:
1578     return "BuiltinFnToFnPtr";
1579   case CK_ZeroToOCLEvent:
1580     return "ZeroToOCLEvent";
1581   }
1582
1583   llvm_unreachable("Unhandled cast kind!");
1584 }
1585
1586 Expr *CastExpr::getSubExprAsWritten() {
1587   Expr *SubExpr = 0;
1588   CastExpr *E = this;
1589   do {
1590     SubExpr = E->getSubExpr();
1591
1592     // Skip through reference binding to temporary.
1593     if (MaterializeTemporaryExpr *Materialize
1594                                   = dyn_cast<MaterializeTemporaryExpr>(SubExpr))
1595       SubExpr = Materialize->GetTemporaryExpr();
1596
1597     // Skip any temporary bindings; they're implicit.
1598     if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
1599       SubExpr = Binder->getSubExpr();
1600
1601     // Conversions by constructor and conversion functions have a
1602     // subexpression describing the call; strip it off.
1603     if (E->getCastKind() == CK_ConstructorConversion)
1604       SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
1605     else if (E->getCastKind() == CK_UserDefinedConversion)
1606       SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
1607
1608     // If the subexpression we're left with is an implicit cast, look
1609     // through that, too.
1610   } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
1611
1612   return SubExpr;
1613 }
1614
1615 CXXBaseSpecifier **CastExpr::path_buffer() {
1616   switch (getStmtClass()) {
1617 #define ABSTRACT_STMT(x)
1618 #define CASTEXPR(Type, Base) \
1619   case Stmt::Type##Class: \
1620     return reinterpret_cast<CXXBaseSpecifier**>(static_cast<Type*>(this)+1);
1621 #define STMT(Type, Base)
1622 #include "clang/AST/StmtNodes.inc"
1623   default:
1624     llvm_unreachable("non-cast expressions not possible here");
1625   }
1626 }
1627
1628 void CastExpr::setCastPath(const CXXCastPath &Path) {
1629   assert(Path.size() == path_size());
1630   memcpy(path_buffer(), Path.data(), Path.size() * sizeof(CXXBaseSpecifier*));
1631 }
1632
1633 ImplicitCastExpr *ImplicitCastExpr::Create(ASTContext &C, QualType T,
1634                                            CastKind Kind, Expr *Operand,
1635                                            const CXXCastPath *BasePath,
1636                                            ExprValueKind VK) {
1637   unsigned PathSize = (BasePath ? BasePath->size() : 0);
1638   void *Buffer =
1639     C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1640   ImplicitCastExpr *E =
1641     new (Buffer) ImplicitCastExpr(T, Kind, Operand, PathSize, VK);
1642   if (PathSize) E->setCastPath(*BasePath);
1643   return E;
1644 }
1645
1646 ImplicitCastExpr *ImplicitCastExpr::CreateEmpty(ASTContext &C,
1647                                                 unsigned PathSize) {
1648   void *Buffer =
1649     C.Allocate(sizeof(ImplicitCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1650   return new (Buffer) ImplicitCastExpr(EmptyShell(), PathSize);
1651 }
1652
1653
1654 CStyleCastExpr *CStyleCastExpr::Create(ASTContext &C, QualType T,
1655                                        ExprValueKind VK, CastKind K, Expr *Op,
1656                                        const CXXCastPath *BasePath,
1657                                        TypeSourceInfo *WrittenTy,
1658                                        SourceLocation L, SourceLocation R) {
1659   unsigned PathSize = (BasePath ? BasePath->size() : 0);
1660   void *Buffer =
1661     C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1662   CStyleCastExpr *E =
1663     new (Buffer) CStyleCastExpr(T, VK, K, Op, PathSize, WrittenTy, L, R);
1664   if (PathSize) E->setCastPath(*BasePath);
1665   return E;
1666 }
1667
1668 CStyleCastExpr *CStyleCastExpr::CreateEmpty(ASTContext &C, unsigned PathSize) {
1669   void *Buffer =
1670     C.Allocate(sizeof(CStyleCastExpr) + PathSize * sizeof(CXXBaseSpecifier*));
1671   return new (Buffer) CStyleCastExpr(EmptyShell(), PathSize);
1672 }
1673
1674 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
1675 /// corresponds to, e.g. "<<=".
1676 StringRef BinaryOperator::getOpcodeStr(Opcode Op) {
1677   switch (Op) {
1678   case BO_PtrMemD:   return ".*";
1679   case BO_PtrMemI:   return "->*";
1680   case BO_Mul:       return "*";
1681   case BO_Div:       return "/";
1682   case BO_Rem:       return "%";
1683   case BO_Add:       return "+";
1684   case BO_Sub:       return "-";
1685   case BO_Shl:       return "<<";
1686   case BO_Shr:       return ">>";
1687   case BO_LT:        return "<";
1688   case BO_GT:        return ">";
1689   case BO_LE:        return "<=";
1690   case BO_GE:        return ">=";
1691   case BO_EQ:        return "==";
1692   case BO_NE:        return "!=";
1693   case BO_And:       return "&";
1694   case BO_Xor:       return "^";
1695   case BO_Or:        return "|";
1696   case BO_LAnd:      return "&&";
1697   case BO_LOr:       return "||";
1698   case BO_Assign:    return "=";
1699   case BO_MulAssign: return "*=";
1700   case BO_DivAssign: return "/=";
1701   case BO_RemAssign: return "%=";
1702   case BO_AddAssign: return "+=";
1703   case BO_SubAssign: return "-=";
1704   case BO_ShlAssign: return "<<=";
1705   case BO_ShrAssign: return ">>=";
1706   case BO_AndAssign: return "&=";
1707   case BO_XorAssign: return "^=";
1708   case BO_OrAssign:  return "|=";
1709   case BO_Comma:     return ",";
1710   }
1711
1712   llvm_unreachable("Invalid OpCode!");
1713 }
1714
1715 BinaryOperatorKind
1716 BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
1717   switch (OO) {
1718   default: llvm_unreachable("Not an overloadable binary operator");
1719   case OO_Plus: return BO_Add;
1720   case OO_Minus: return BO_Sub;
1721   case OO_Star: return BO_Mul;
1722   case OO_Slash: return BO_Div;
1723   case OO_Percent: return BO_Rem;
1724   case OO_Caret: return BO_Xor;
1725   case OO_Amp: return BO_And;
1726   case OO_Pipe: return BO_Or;
1727   case OO_Equal: return BO_Assign;
1728   case OO_Less: return BO_LT;
1729   case OO_Greater: return BO_GT;
1730   case OO_PlusEqual: return BO_AddAssign;
1731   case OO_MinusEqual: return BO_SubAssign;
1732   case OO_StarEqual: return BO_MulAssign;
1733   case OO_SlashEqual: return BO_DivAssign;
1734   case OO_PercentEqual: return BO_RemAssign;
1735   case OO_CaretEqual: return BO_XorAssign;
1736   case OO_AmpEqual: return BO_AndAssign;
1737   case OO_PipeEqual: return BO_OrAssign;
1738   case OO_LessLess: return BO_Shl;
1739   case OO_GreaterGreater: return BO_Shr;
1740   case OO_LessLessEqual: return BO_ShlAssign;
1741   case OO_GreaterGreaterEqual: return BO_ShrAssign;
1742   case OO_EqualEqual: return BO_EQ;
1743   case OO_ExclaimEqual: return BO_NE;
1744   case OO_LessEqual: return BO_LE;
1745   case OO_GreaterEqual: return BO_GE;
1746   case OO_AmpAmp: return BO_LAnd;
1747   case OO_PipePipe: return BO_LOr;
1748   case OO_Comma: return BO_Comma;
1749   case OO_ArrowStar: return BO_PtrMemI;
1750   }
1751 }
1752
1753 OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
1754   static const OverloadedOperatorKind OverOps[] = {
1755     /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
1756     OO_Star, OO_Slash, OO_Percent,
1757     OO_Plus, OO_Minus,
1758     OO_LessLess, OO_GreaterGreater,
1759     OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
1760     OO_EqualEqual, OO_ExclaimEqual,
1761     OO_Amp,
1762     OO_Caret,
1763     OO_Pipe,
1764     OO_AmpAmp,
1765     OO_PipePipe,
1766     OO_Equal, OO_StarEqual,
1767     OO_SlashEqual, OO_PercentEqual,
1768     OO_PlusEqual, OO_MinusEqual,
1769     OO_LessLessEqual, OO_GreaterGreaterEqual,
1770     OO_AmpEqual, OO_CaretEqual,
1771     OO_PipeEqual,
1772     OO_Comma
1773   };
1774   return OverOps[Opc];
1775 }
1776
1777 InitListExpr::InitListExpr(ASTContext &C, SourceLocation lbraceloc,
1778                            ArrayRef<Expr*> initExprs, SourceLocation rbraceloc)
1779   : Expr(InitListExprClass, QualType(), VK_RValue, OK_Ordinary, false, false,
1780          false, false),
1781     InitExprs(C, initExprs.size()),
1782     LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), AltForm(0, true)
1783 {
1784   sawArrayRangeDesignator(false);
1785   setInitializesStdInitializerList(false);
1786   for (unsigned I = 0; I != initExprs.size(); ++I) {
1787     if (initExprs[I]->isTypeDependent())
1788       ExprBits.TypeDependent = true;
1789     if (initExprs[I]->isValueDependent())
1790       ExprBits.ValueDependent = true;
1791     if (initExprs[I]->isInstantiationDependent())
1792       ExprBits.InstantiationDependent = true;
1793     if (initExprs[I]->containsUnexpandedParameterPack())
1794       ExprBits.ContainsUnexpandedParameterPack = true;
1795   }
1796
1797   InitExprs.insert(C, InitExprs.end(), initExprs.begin(), initExprs.end());
1798 }
1799
1800 void InitListExpr::reserveInits(ASTContext &C, unsigned NumInits) {
1801   if (NumInits > InitExprs.size())
1802     InitExprs.reserve(C, NumInits);
1803 }
1804
1805 void InitListExpr::resizeInits(ASTContext &C, unsigned NumInits) {
1806   InitExprs.resize(C, NumInits, 0);
1807 }
1808
1809 Expr *InitListExpr::updateInit(ASTContext &C, unsigned Init, Expr *expr) {
1810   if (Init >= InitExprs.size()) {
1811     InitExprs.insert(C, InitExprs.end(), Init - InitExprs.size() + 1, 0);
1812     InitExprs.back() = expr;
1813     return 0;
1814   }
1815
1816   Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
1817   InitExprs[Init] = expr;
1818   return Result;
1819 }
1820
1821 void InitListExpr::setArrayFiller(Expr *filler) {
1822   assert(!hasArrayFiller() && "Filler already set!");
1823   ArrayFillerOrUnionFieldInit = filler;
1824   // Fill out any "holes" in the array due to designated initializers.
1825   Expr **inits = getInits();
1826   for (unsigned i = 0, e = getNumInits(); i != e; ++i)
1827     if (inits[i] == 0)
1828       inits[i] = filler;
1829 }
1830
1831 bool InitListExpr::isStringLiteralInit() const {
1832   if (getNumInits() != 1)
1833     return false;
1834   const ArrayType *AT = getType()->getAsArrayTypeUnsafe();
1835   if (!AT || !AT->getElementType()->isIntegerType())
1836     return false;
1837   const Expr *Init = getInit(0)->IgnoreParens();
1838   return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init);
1839 }
1840
1841 SourceLocation InitListExpr::getLocStart() const {
1842   if (InitListExpr *SyntacticForm = getSyntacticForm())
1843     return SyntacticForm->getLocStart();
1844   SourceLocation Beg = LBraceLoc;
1845   if (Beg.isInvalid()) {
1846     // Find the first non-null initializer.
1847     for (InitExprsTy::const_iterator I = InitExprs.begin(),
1848                                      E = InitExprs.end();
1849       I != E; ++I) {
1850       if (Stmt *S = *I) {
1851         Beg = S->getLocStart();
1852         break;
1853       }
1854     }
1855   }
1856   return Beg;
1857 }
1858
1859 SourceLocation InitListExpr::getLocEnd() const {
1860   if (InitListExpr *SyntacticForm = getSyntacticForm())
1861     return SyntacticForm->getLocEnd();
1862   SourceLocation End = RBraceLoc;
1863   if (End.isInvalid()) {
1864     // Find the first non-null initializer from the end.
1865     for (InitExprsTy::const_reverse_iterator I = InitExprs.rbegin(),
1866          E = InitExprs.rend();
1867          I != E; ++I) {
1868       if (Stmt *S = *I) {
1869         End = S->getLocEnd();
1870         break;
1871       }
1872     }
1873   }
1874   return End;
1875 }
1876
1877 /// getFunctionType - Return the underlying function type for this block.
1878 ///
1879 const FunctionProtoType *BlockExpr::getFunctionType() const {
1880   // The block pointer is never sugared, but the function type might be.
1881   return cast<BlockPointerType>(getType())
1882            ->getPointeeType()->castAs<FunctionProtoType>();
1883 }
1884
1885 SourceLocation BlockExpr::getCaretLocation() const {
1886   return TheBlock->getCaretLocation();
1887 }
1888 const Stmt *BlockExpr::getBody() const {
1889   return TheBlock->getBody();
1890 }
1891 Stmt *BlockExpr::getBody() {
1892   return TheBlock->getBody();
1893 }
1894
1895
1896 //===----------------------------------------------------------------------===//
1897 // Generic Expression Routines
1898 //===----------------------------------------------------------------------===//
1899
1900 /// isUnusedResultAWarning - Return true if this immediate expression should
1901 /// be warned about if the result is unused.  If so, fill in Loc and Ranges
1902 /// with location to warn on and the source range[s] to report with the
1903 /// warning.
1904 bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc,
1905                                   SourceRange &R1, SourceRange &R2,
1906                                   ASTContext &Ctx) const {
1907   // Don't warn if the expr is type dependent. The type could end up
1908   // instantiating to void.
1909   if (isTypeDependent())
1910     return false;
1911
1912   switch (getStmtClass()) {
1913   default:
1914     if (getType()->isVoidType())
1915       return false;
1916     WarnE = this;
1917     Loc = getExprLoc();
1918     R1 = getSourceRange();
1919     return true;
1920   case ParenExprClass:
1921     return cast<ParenExpr>(this)->getSubExpr()->
1922       isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1923   case GenericSelectionExprClass:
1924     return cast<GenericSelectionExpr>(this)->getResultExpr()->
1925       isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1926   case UnaryOperatorClass: {
1927     const UnaryOperator *UO = cast<UnaryOperator>(this);
1928
1929     switch (UO->getOpcode()) {
1930     case UO_Plus:
1931     case UO_Minus:
1932     case UO_AddrOf:
1933     case UO_Not:
1934     case UO_LNot:
1935     case UO_Deref:
1936       break;
1937     case UO_PostInc:
1938     case UO_PostDec:
1939     case UO_PreInc:
1940     case UO_PreDec:                 // ++/--
1941       return false;  // Not a warning.
1942     case UO_Real:
1943     case UO_Imag:
1944       // accessing a piece of a volatile complex is a side-effect.
1945       if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
1946           .isVolatileQualified())
1947         return false;
1948       break;
1949     case UO_Extension:
1950       return UO->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1951     }
1952     WarnE = this;
1953     Loc = UO->getOperatorLoc();
1954     R1 = UO->getSubExpr()->getSourceRange();
1955     return true;
1956   }
1957   case BinaryOperatorClass: {
1958     const BinaryOperator *BO = cast<BinaryOperator>(this);
1959     switch (BO->getOpcode()) {
1960       default:
1961         break;
1962       // Consider the RHS of comma for side effects. LHS was checked by
1963       // Sema::CheckCommaOperands.
1964       case BO_Comma:
1965         // ((foo = <blah>), 0) is an idiom for hiding the result (and
1966         // lvalue-ness) of an assignment written in a macro.
1967         if (IntegerLiteral *IE =
1968               dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
1969           if (IE->getValue() == 0)
1970             return false;
1971         return BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
1972       // Consider '||', '&&' to have side effects if the LHS or RHS does.
1973       case BO_LAnd:
1974       case BO_LOr:
1975         if (!BO->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) ||
1976             !BO->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
1977           return false;
1978         break;
1979     }
1980     if (BO->isAssignmentOp())
1981       return false;
1982     WarnE = this;
1983     Loc = BO->getOperatorLoc();
1984     R1 = BO->getLHS()->getSourceRange();
1985     R2 = BO->getRHS()->getSourceRange();
1986     return true;
1987   }
1988   case CompoundAssignOperatorClass:
1989   case VAArgExprClass:
1990   case AtomicExprClass:
1991     return false;
1992
1993   case ConditionalOperatorClass: {
1994     // If only one of the LHS or RHS is a warning, the operator might
1995     // be being used for control flow. Only warn if both the LHS and
1996     // RHS are warnings.
1997     const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
1998     if (!Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx))
1999       return false;
2000     if (!Exp->getLHS())
2001       return true;
2002     return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2003   }
2004
2005   case MemberExprClass:
2006     WarnE = this;
2007     Loc = cast<MemberExpr>(this)->getMemberLoc();
2008     R1 = SourceRange(Loc, Loc);
2009     R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
2010     return true;
2011
2012   case ArraySubscriptExprClass:
2013     WarnE = this;
2014     Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
2015     R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
2016     R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
2017     return true;
2018
2019   case CXXOperatorCallExprClass: {
2020     // We warn about operator== and operator!= even when user-defined operator
2021     // overloads as there is no reasonable way to define these such that they
2022     // have non-trivial, desirable side-effects. See the -Wunused-comparison
2023     // warning: these operators are commonly typo'ed, and so warning on them
2024     // provides additional value as well. If this list is updated,
2025     // DiagnoseUnusedComparison should be as well.
2026     const CXXOperatorCallExpr *Op = cast<CXXOperatorCallExpr>(this);
2027     if (Op->getOperator() == OO_EqualEqual ||
2028         Op->getOperator() == OO_ExclaimEqual) {
2029       WarnE = this;
2030       Loc = Op->getOperatorLoc();
2031       R1 = Op->getSourceRange();
2032       return true;
2033     }
2034
2035     // Fallthrough for generic call handling.
2036   }
2037   case CallExprClass:
2038   case CXXMemberCallExprClass:
2039   case UserDefinedLiteralClass: {
2040     // If this is a direct call, get the callee.
2041     const CallExpr *CE = cast<CallExpr>(this);
2042     if (const Decl *FD = CE->getCalleeDecl()) {
2043       // If the callee has attribute pure, const, or warn_unused_result, warn
2044       // about it. void foo() { strlen("bar"); } should warn.
2045       //
2046       // Note: If new cases are added here, DiagnoseUnusedExprResult should be
2047       // updated to match for QoI.
2048       if (FD->getAttr<WarnUnusedResultAttr>() ||
2049           FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
2050         WarnE = this;
2051         Loc = CE->getCallee()->getLocStart();
2052         R1 = CE->getCallee()->getSourceRange();
2053
2054         if (unsigned NumArgs = CE->getNumArgs())
2055           R2 = SourceRange(CE->getArg(0)->getLocStart(),
2056                            CE->getArg(NumArgs-1)->getLocEnd());
2057         return true;
2058       }
2059     }
2060     return false;
2061   }
2062
2063   // If we don't know precisely what we're looking at, let's not warn.
2064   case UnresolvedLookupExprClass:
2065   case CXXUnresolvedConstructExprClass:
2066     return false;
2067
2068   case CXXTemporaryObjectExprClass:
2069   case CXXConstructExprClass:
2070     return false;
2071
2072   case ObjCMessageExprClass: {
2073     const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
2074     if (Ctx.getLangOpts().ObjCAutoRefCount &&
2075         ME->isInstanceMessage() &&
2076         !ME->getType()->isVoidType() &&
2077         ME->getSelector().getIdentifierInfoForSlot(0) &&
2078         ME->getSelector().getIdentifierInfoForSlot(0)
2079                                                ->getName().startswith("init")) {
2080       WarnE = this;
2081       Loc = getExprLoc();
2082       R1 = ME->getSourceRange();
2083       return true;
2084     }
2085
2086     const ObjCMethodDecl *MD = ME->getMethodDecl();
2087     if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
2088       WarnE = this;
2089       Loc = getExprLoc();
2090       return true;
2091     }
2092     return false;
2093   }
2094
2095   case ObjCPropertyRefExprClass:
2096     WarnE = this;
2097     Loc = getExprLoc();
2098     R1 = getSourceRange();
2099     return true;
2100
2101   case PseudoObjectExprClass: {
2102     const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
2103
2104     // Only complain about things that have the form of a getter.
2105     if (isa<UnaryOperator>(PO->getSyntacticForm()) ||
2106         isa<BinaryOperator>(PO->getSyntacticForm()))
2107       return false;
2108
2109     WarnE = this;
2110     Loc = getExprLoc();
2111     R1 = getSourceRange();
2112     return true;
2113   }
2114
2115   case StmtExprClass: {
2116     // Statement exprs don't logically have side effects themselves, but are
2117     // sometimes used in macros in ways that give them a type that is unused.
2118     // For example ({ blah; foo(); }) will end up with a type if foo has a type.
2119     // however, if the result of the stmt expr is dead, we don't want to emit a
2120     // warning.
2121     const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
2122     if (!CS->body_empty()) {
2123       if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
2124         return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2125       if (const LabelStmt *Label = dyn_cast<LabelStmt>(CS->body_back()))
2126         if (const Expr *E = dyn_cast<Expr>(Label->getSubStmt()))
2127           return E->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2128     }
2129
2130     if (getType()->isVoidType())
2131       return false;
2132     WarnE = this;
2133     Loc = cast<StmtExpr>(this)->getLParenLoc();
2134     R1 = getSourceRange();
2135     return true;
2136   }
2137   case CXXFunctionalCastExprClass:
2138   case CStyleCastExprClass: {
2139     // Ignore an explicit cast to void unless the operand is a non-trivial
2140     // volatile lvalue.
2141     const CastExpr *CE = cast<CastExpr>(this);
2142     if (CE->getCastKind() == CK_ToVoid) {
2143       if (CE->getSubExpr()->isGLValue() &&
2144           CE->getSubExpr()->getType().isVolatileQualified()) {
2145         const DeclRefExpr *DRE =
2146             dyn_cast<DeclRefExpr>(CE->getSubExpr()->IgnoreParens());
2147         if (!(DRE && isa<VarDecl>(DRE->getDecl()) &&
2148               cast<VarDecl>(DRE->getDecl())->hasLocalStorage())) {
2149           return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc,
2150                                                           R1, R2, Ctx);
2151         }
2152       }
2153       return false;
2154     }
2155
2156     // If this is a cast to a constructor conversion, check the operand.
2157     // Otherwise, the result of the cast is unused.
2158     if (CE->getCastKind() == CK_ConstructorConversion)
2159       return CE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2160
2161     WarnE = this;
2162     if (const CXXFunctionalCastExpr *CXXCE =
2163             dyn_cast<CXXFunctionalCastExpr>(this)) {
2164       Loc = CXXCE->getTypeBeginLoc();
2165       R1 = CXXCE->getSubExpr()->getSourceRange();
2166     } else {
2167       const CStyleCastExpr *CStyleCE = cast<CStyleCastExpr>(this);
2168       Loc = CStyleCE->getLParenLoc();
2169       R1 = CStyleCE->getSubExpr()->getSourceRange();
2170     }
2171     return true;
2172   }
2173   case ImplicitCastExprClass: {
2174     const CastExpr *ICE = cast<ImplicitCastExpr>(this);
2175
2176     // lvalue-to-rvalue conversion on a volatile lvalue is a side-effect.
2177     if (ICE->getCastKind() == CK_LValueToRValue &&
2178         ICE->getSubExpr()->getType().isVolatileQualified())
2179       return false;
2180
2181     return ICE->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2182   }
2183   case CXXDefaultArgExprClass:
2184     return (cast<CXXDefaultArgExpr>(this)
2185             ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2186   case CXXDefaultInitExprClass:
2187     return (cast<CXXDefaultInitExpr>(this)
2188             ->getExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2189
2190   case CXXNewExprClass:
2191     // FIXME: In theory, there might be new expressions that don't have side
2192     // effects (e.g. a placement new with an uninitialized POD).
2193   case CXXDeleteExprClass:
2194     return false;
2195   case CXXBindTemporaryExprClass:
2196     return (cast<CXXBindTemporaryExpr>(this)
2197             ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2198   case ExprWithCleanupsClass:
2199     return (cast<ExprWithCleanups>(this)
2200             ->getSubExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx));
2201   }
2202 }
2203
2204 /// isOBJCGCCandidate - Check if an expression is objc gc'able.
2205 /// returns true, if it is; false otherwise.
2206 bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
2207   const Expr *E = IgnoreParens();
2208   switch (E->getStmtClass()) {
2209   default:
2210     return false;
2211   case ObjCIvarRefExprClass:
2212     return true;
2213   case Expr::UnaryOperatorClass:
2214     return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2215   case ImplicitCastExprClass:
2216     return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2217   case MaterializeTemporaryExprClass:
2218     return cast<MaterializeTemporaryExpr>(E)->GetTemporaryExpr()
2219                                                       ->isOBJCGCCandidate(Ctx);
2220   case CStyleCastExprClass:
2221     return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2222   case DeclRefExprClass: {
2223     const Decl *D = cast<DeclRefExpr>(E)->getDecl();
2224
2225     if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2226       if (VD->hasGlobalStorage())
2227         return true;
2228       QualType T = VD->getType();
2229       // dereferencing to a  pointer is always a gc'able candidate,
2230       // unless it is __weak.
2231       return T->isPointerType() &&
2232              (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
2233     }
2234     return false;
2235   }
2236   case MemberExprClass: {
2237     const MemberExpr *M = cast<MemberExpr>(E);
2238     return M->getBase()->isOBJCGCCandidate(Ctx);
2239   }
2240   case ArraySubscriptExprClass:
2241     return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
2242   }
2243 }
2244
2245 bool Expr::isBoundMemberFunction(ASTContext &Ctx) const {
2246   if (isTypeDependent())
2247     return false;
2248   return ClassifyLValue(Ctx) == Expr::LV_MemberFunction;
2249 }
2250
2251 QualType Expr::findBoundMemberType(const Expr *expr) {
2252   assert(expr->hasPlaceholderType(BuiltinType::BoundMember));
2253
2254   // Bound member expressions are always one of these possibilities:
2255   //   x->m      x.m      x->*y      x.*y
2256   // (possibly parenthesized)
2257
2258   expr = expr->IgnoreParens();
2259   if (const MemberExpr *mem = dyn_cast<MemberExpr>(expr)) {
2260     assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
2261     return mem->getMemberDecl()->getType();
2262   }
2263
2264   if (const BinaryOperator *op = dyn_cast<BinaryOperator>(expr)) {
2265     QualType type = op->getRHS()->getType()->castAs<MemberPointerType>()
2266                       ->getPointeeType();
2267     assert(type->isFunctionType());
2268     return type;
2269   }
2270
2271   assert(isa<UnresolvedMemberExpr>(expr));
2272   return QualType();
2273 }
2274
2275 Expr* Expr::IgnoreParens() {
2276   Expr* E = this;
2277   while (true) {
2278     if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
2279       E = P->getSubExpr();
2280       continue;
2281     }
2282     if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2283       if (P->getOpcode() == UO_Extension) {
2284         E = P->getSubExpr();
2285         continue;
2286       }
2287     }
2288     if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2289       if (!P->isResultDependent()) {
2290         E = P->getResultExpr();
2291         continue;
2292       }
2293     }
2294     return E;
2295   }
2296 }
2297
2298 /// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
2299 /// or CastExprs or ImplicitCastExprs, returning their operand.
2300 Expr *Expr::IgnoreParenCasts() {
2301   Expr *E = this;
2302   while (true) {
2303     if (ParenExpr* P = dyn_cast<ParenExpr>(E)) {
2304       E = P->getSubExpr();
2305       continue;
2306     }
2307     if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2308       E = P->getSubExpr();
2309       continue;
2310     }
2311     if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2312       if (P->getOpcode() == UO_Extension) {
2313         E = P->getSubExpr();
2314         continue;
2315       }
2316     }
2317     if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2318       if (!P->isResultDependent()) {
2319         E = P->getResultExpr();
2320         continue;
2321       }
2322     }
2323     if (MaterializeTemporaryExpr *Materialize
2324                                       = dyn_cast<MaterializeTemporaryExpr>(E)) {
2325       E = Materialize->GetTemporaryExpr();
2326       continue;
2327     }
2328     if (SubstNonTypeTemplateParmExpr *NTTP
2329                                   = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2330       E = NTTP->getReplacement();
2331       continue;
2332     }
2333     return E;
2334   }
2335 }
2336
2337 /// IgnoreParenLValueCasts - Ignore parentheses and lvalue-to-rvalue
2338 /// casts.  This is intended purely as a temporary workaround for code
2339 /// that hasn't yet been rewritten to do the right thing about those
2340 /// casts, and may disappear along with the last internal use.
2341 Expr *Expr::IgnoreParenLValueCasts() {
2342   Expr *E = this;
2343   while (true) {
2344     if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2345       E = P->getSubExpr();
2346       continue;
2347     } else if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2348       if (P->getCastKind() == CK_LValueToRValue) {
2349         E = P->getSubExpr();
2350         continue;
2351       }
2352     } else if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2353       if (P->getOpcode() == UO_Extension) {
2354         E = P->getSubExpr();
2355         continue;
2356       }
2357     } else if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2358       if (!P->isResultDependent()) {
2359         E = P->getResultExpr();
2360         continue;
2361       }
2362     } else if (MaterializeTemporaryExpr *Materialize
2363                                       = dyn_cast<MaterializeTemporaryExpr>(E)) {
2364       E = Materialize->GetTemporaryExpr();
2365       continue;
2366     } else if (SubstNonTypeTemplateParmExpr *NTTP
2367                                   = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2368       E = NTTP->getReplacement();
2369       continue;
2370     }
2371     break;
2372   }
2373   return E;
2374 }
2375
2376 Expr *Expr::ignoreParenBaseCasts() {
2377   Expr *E = this;
2378   while (true) {
2379     if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2380       E = P->getSubExpr();
2381       continue;
2382     }
2383     if (CastExpr *CE = dyn_cast<CastExpr>(E)) {
2384       if (CE->getCastKind() == CK_DerivedToBase ||
2385           CE->getCastKind() == CK_UncheckedDerivedToBase ||
2386           CE->getCastKind() == CK_NoOp) {
2387         E = CE->getSubExpr();
2388         continue;
2389       }
2390     }
2391
2392     return E;
2393   }
2394 }
2395
2396 Expr *Expr::IgnoreParenImpCasts() {
2397   Expr *E = this;
2398   while (true) {
2399     if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2400       E = P->getSubExpr();
2401       continue;
2402     }
2403     if (ImplicitCastExpr *P = dyn_cast<ImplicitCastExpr>(E)) {
2404       E = P->getSubExpr();
2405       continue;
2406     }
2407     if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2408       if (P->getOpcode() == UO_Extension) {
2409         E = P->getSubExpr();
2410         continue;
2411       }
2412     }
2413     if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2414       if (!P->isResultDependent()) {
2415         E = P->getResultExpr();
2416         continue;
2417       }
2418     }
2419     if (MaterializeTemporaryExpr *Materialize
2420                                       = dyn_cast<MaterializeTemporaryExpr>(E)) {
2421       E = Materialize->GetTemporaryExpr();
2422       continue;
2423     }
2424     if (SubstNonTypeTemplateParmExpr *NTTP
2425                                   = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2426       E = NTTP->getReplacement();
2427       continue;
2428     }
2429     return E;
2430   }
2431 }
2432
2433 Expr *Expr::IgnoreConversionOperator() {
2434   if (CXXMemberCallExpr *MCE = dyn_cast<CXXMemberCallExpr>(this)) {
2435     if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
2436       return MCE->getImplicitObjectArgument();
2437   }
2438   return this;
2439 }
2440
2441 /// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
2442 /// value (including ptr->int casts of the same size).  Strip off any
2443 /// ParenExpr or CastExprs, returning their operand.
2444 Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
2445   Expr *E = this;
2446   while (true) {
2447     if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
2448       E = P->getSubExpr();
2449       continue;
2450     }
2451
2452     if (CastExpr *P = dyn_cast<CastExpr>(E)) {
2453       // We ignore integer <-> casts that are of the same width, ptr<->ptr and
2454       // ptr<->int casts of the same width.  We also ignore all identity casts.
2455       Expr *SE = P->getSubExpr();
2456
2457       if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
2458         E = SE;
2459         continue;
2460       }
2461
2462       if ((E->getType()->isPointerType() ||
2463            E->getType()->isIntegralType(Ctx)) &&
2464           (SE->getType()->isPointerType() ||
2465            SE->getType()->isIntegralType(Ctx)) &&
2466           Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
2467         E = SE;
2468         continue;
2469       }
2470     }
2471
2472     if (UnaryOperator* P = dyn_cast<UnaryOperator>(E)) {
2473       if (P->getOpcode() == UO_Extension) {
2474         E = P->getSubExpr();
2475         continue;
2476       }
2477     }
2478
2479     if (GenericSelectionExpr* P = dyn_cast<GenericSelectionExpr>(E)) {
2480       if (!P->isResultDependent()) {
2481         E = P->getResultExpr();
2482         continue;
2483       }
2484     }
2485
2486     if (SubstNonTypeTemplateParmExpr *NTTP
2487                                   = dyn_cast<SubstNonTypeTemplateParmExpr>(E)) {
2488       E = NTTP->getReplacement();
2489       continue;
2490     }
2491
2492     return E;
2493   }
2494 }
2495
2496 bool Expr::isDefaultArgument() const {
2497   const Expr *E = this;
2498   if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2499     E = M->GetTemporaryExpr();
2500
2501   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
2502     E = ICE->getSubExprAsWritten();
2503
2504   return isa<CXXDefaultArgExpr>(E);
2505 }
2506
2507 /// \brief Skip over any no-op casts and any temporary-binding
2508 /// expressions.
2509 static const Expr *skipTemporaryBindingsNoOpCastsAndParens(const Expr *E) {
2510   if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
2511     E = M->GetTemporaryExpr();
2512
2513   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2514     if (ICE->getCastKind() == CK_NoOp)
2515       E = ICE->getSubExpr();
2516     else
2517       break;
2518   }
2519
2520   while (const CXXBindTemporaryExpr *BE = dyn_cast<CXXBindTemporaryExpr>(E))
2521     E = BE->getSubExpr();
2522
2523   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2524     if (ICE->getCastKind() == CK_NoOp)
2525       E = ICE->getSubExpr();
2526     else
2527       break;
2528   }
2529
2530   return E->IgnoreParens();
2531 }
2532
2533 /// isTemporaryObject - Determines if this expression produces a
2534 /// temporary of the given class type.
2535 bool Expr::isTemporaryObject(ASTContext &C, const CXXRecordDecl *TempTy) const {
2536   if (!C.hasSameUnqualifiedType(getType(), C.getTypeDeclType(TempTy)))
2537     return false;
2538
2539   const Expr *E = skipTemporaryBindingsNoOpCastsAndParens(this);
2540
2541   // Temporaries are by definition pr-values of class type.
2542   if (!E->Classify(C).isPRValue()) {
2543     // In this context, property reference is a message call and is pr-value.
2544     if (!isa<ObjCPropertyRefExpr>(E))
2545       return false;
2546   }
2547
2548   // Black-list a few cases which yield pr-values of class type that don't
2549   // refer to temporaries of that type:
2550
2551   // - implicit derived-to-base conversions
2552   if (isa<ImplicitCastExpr>(E)) {
2553     switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
2554     case CK_DerivedToBase:
2555     case CK_UncheckedDerivedToBase:
2556       return false;
2557     default:
2558       break;
2559     }
2560   }
2561
2562   // - member expressions (all)
2563   if (isa<MemberExpr>(E))
2564     return false;
2565
2566   if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E))
2567     if (BO->isPtrMemOp())
2568       return false;
2569
2570   // - opaque values (all)
2571   if (isa<OpaqueValueExpr>(E))
2572     return false;
2573
2574   return true;
2575 }
2576
2577 bool Expr::isImplicitCXXThis() const {
2578   const Expr *E = this;
2579
2580   // Strip away parentheses and casts we don't care about.
2581   while (true) {
2582     if (const ParenExpr *Paren = dyn_cast<ParenExpr>(E)) {
2583       E = Paren->getSubExpr();
2584       continue;
2585     }
2586
2587     if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2588       if (ICE->getCastKind() == CK_NoOp ||
2589           ICE->getCastKind() == CK_LValueToRValue ||
2590           ICE->getCastKind() == CK_DerivedToBase ||
2591           ICE->getCastKind() == CK_UncheckedDerivedToBase) {
2592         E = ICE->getSubExpr();
2593         continue;
2594       }
2595     }
2596
2597     if (const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
2598       if (UnOp->getOpcode() == UO_Extension) {
2599         E = UnOp->getSubExpr();
2600         continue;
2601       }
2602     }
2603
2604     if (const MaterializeTemporaryExpr *M
2605                                       = dyn_cast<MaterializeTemporaryExpr>(E)) {
2606       E = M->GetTemporaryExpr();
2607       continue;
2608     }
2609
2610     break;
2611   }
2612
2613   if (const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
2614     return This->isImplicit();
2615
2616   return false;
2617 }
2618
2619 /// hasAnyTypeDependentArguments - Determines if any of the expressions
2620 /// in Exprs is type-dependent.
2621 bool Expr::hasAnyTypeDependentArguments(ArrayRef<Expr *> Exprs) {
2622   for (unsigned I = 0; I < Exprs.size(); ++I)
2623     if (Exprs[I]->isTypeDependent())
2624       return true;
2625
2626   return false;
2627 }
2628
2629 bool Expr::isConstantInitializer(ASTContext &Ctx, bool IsForRef) const {
2630   // This function is attempting whether an expression is an initializer
2631   // which can be evaluated at compile-time.  isEvaluatable handles most
2632   // of the cases, but it can't deal with some initializer-specific
2633   // expressions, and it can't deal with aggregates; we deal with those here,
2634   // and fall back to isEvaluatable for the other cases.
2635
2636   // If we ever capture reference-binding directly in the AST, we can
2637   // kill the second parameter.
2638
2639   if (IsForRef) {
2640     EvalResult Result;
2641     return EvaluateAsLValue(Result, Ctx) && !Result.HasSideEffects;
2642   }
2643
2644   switch (getStmtClass()) {
2645   default: break;
2646   case IntegerLiteralClass:
2647   case FloatingLiteralClass:
2648   case StringLiteralClass:
2649   case ObjCStringLiteralClass:
2650   case ObjCEncodeExprClass:
2651     return true;
2652   case CXXTemporaryObjectExprClass:
2653   case CXXConstructExprClass: {
2654     const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
2655
2656     // Only if it's
2657     if (CE->getConstructor()->isTrivial()) {
2658       // 1) an application of the trivial default constructor or
2659       if (!CE->getNumArgs()) return true;
2660
2661       // 2) an elidable trivial copy construction of an operand which is
2662       //    itself a constant initializer.  Note that we consider the
2663       //    operand on its own, *not* as a reference binding.
2664       if (CE->isElidable() &&
2665           CE->getArg(0)->isConstantInitializer(Ctx, false))
2666         return true;
2667     }
2668
2669     // 3) a foldable constexpr constructor.
2670     break;
2671   }
2672   case CompoundLiteralExprClass: {
2673     // This handles gcc's extension that allows global initializers like
2674     // "struct x {int x;} x = (struct x) {};".
2675     // FIXME: This accepts other cases it shouldn't!
2676     const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
2677     return Exp->isConstantInitializer(Ctx, false);
2678   }
2679   case InitListExprClass: {
2680     // FIXME: This doesn't deal with fields with reference types correctly.
2681     // FIXME: This incorrectly allows pointers cast to integers to be assigned
2682     // to bitfields.
2683     const InitListExpr *Exp = cast<InitListExpr>(this);
2684     unsigned numInits = Exp->getNumInits();
2685     for (unsigned i = 0; i < numInits; i++) {
2686       if (!Exp->getInit(i)->isConstantInitializer(Ctx, false))
2687         return false;
2688     }
2689     return true;
2690   }
2691   case ImplicitValueInitExprClass:
2692     return true;
2693   case ParenExprClass:
2694     return cast<ParenExpr>(this)->getSubExpr()
2695       ->isConstantInitializer(Ctx, IsForRef);
2696   case GenericSelectionExprClass:
2697     if (cast<GenericSelectionExpr>(this)->isResultDependent())
2698       return false;
2699     return cast<GenericSelectionExpr>(this)->getResultExpr()
2700       ->isConstantInitializer(Ctx, IsForRef);
2701   case ChooseExprClass:
2702     return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)
2703       ->isConstantInitializer(Ctx, IsForRef);
2704   case UnaryOperatorClass: {
2705     const UnaryOperator* Exp = cast<UnaryOperator>(this);
2706     if (Exp->getOpcode() == UO_Extension)
2707       return Exp->getSubExpr()->isConstantInitializer(Ctx, false);
2708     break;
2709   }
2710   case CXXFunctionalCastExprClass:
2711   case CXXStaticCastExprClass:
2712   case ImplicitCastExprClass:
2713   case CStyleCastExprClass: {
2714     const CastExpr *CE = cast<CastExpr>(this);
2715
2716     // If we're promoting an integer to an _Atomic type then this is constant
2717     // if the integer is constant.  We also need to check the converse in case
2718     // someone does something like:
2719     //
2720     // int a = (_Atomic(int))42;
2721     //
2722     // I doubt anyone would write code like this directly, but it's quite
2723     // possible as the result of macro expansions.
2724     if (CE->getCastKind() == CK_NonAtomicToAtomic ||
2725         CE->getCastKind() == CK_AtomicToNonAtomic)
2726       return CE->getSubExpr()->isConstantInitializer(Ctx, false);
2727
2728     // Handle bitcasts of vector constants.
2729     if (getType()->isVectorType() && CE->getCastKind() == CK_BitCast)
2730       return CE->getSubExpr()->isConstantInitializer(Ctx, false);
2731
2732     // Handle misc casts we want to ignore.
2733     // FIXME: Is it really safe to ignore all these?
2734     if (CE->getCastKind() == CK_NoOp ||
2735         CE->getCastKind() == CK_LValueToRValue ||
2736         CE->getCastKind() == CK_ToUnion ||
2737         CE->getCastKind() == CK_ConstructorConversion)
2738       return CE->getSubExpr()->isConstantInitializer(Ctx, false);
2739
2740     break;
2741   }
2742   case MaterializeTemporaryExprClass:
2743     return cast<MaterializeTemporaryExpr>(this)->GetTemporaryExpr()
2744                                             ->isConstantInitializer(Ctx, false);
2745   }
2746   return isEvaluatable(Ctx);
2747 }
2748
2749 bool Expr::HasSideEffects(const ASTContext &Ctx) const {
2750   if (isInstantiationDependent())
2751     return true;
2752
2753   switch (getStmtClass()) {
2754   case NoStmtClass:
2755   #define ABSTRACT_STMT(Type)
2756   #define STMT(Type, Base) case Type##Class:
2757   #define EXPR(Type, Base)
2758   #include "clang/AST/StmtNodes.inc"
2759     llvm_unreachable("unexpected Expr kind");
2760
2761   case DependentScopeDeclRefExprClass:
2762   case CXXUnresolvedConstructExprClass:
2763   case CXXDependentScopeMemberExprClass:
2764   case UnresolvedLookupExprClass:
2765   case UnresolvedMemberExprClass:
2766   case PackExpansionExprClass:
2767   case SubstNonTypeTemplateParmPackExprClass:
2768   case FunctionParmPackExprClass:
2769     llvm_unreachable("shouldn't see dependent / unresolved nodes here");
2770
2771   case DeclRefExprClass:
2772   case ObjCIvarRefExprClass:
2773   case PredefinedExprClass:
2774   case IntegerLiteralClass:
2775   case FloatingLiteralClass:
2776   case ImaginaryLiteralClass:
2777   case StringLiteralClass:
2778   case CharacterLiteralClass:
2779   case OffsetOfExprClass:
2780   case ImplicitValueInitExprClass:
2781   case UnaryExprOrTypeTraitExprClass:
2782   case AddrLabelExprClass:
2783   case GNUNullExprClass:
2784   case CXXBoolLiteralExprClass:
2785   case CXXNullPtrLiteralExprClass:
2786   case CXXThisExprClass:
2787   case CXXScalarValueInitExprClass:
2788   case TypeTraitExprClass:
2789   case UnaryTypeTraitExprClass:
2790   case BinaryTypeTraitExprClass:
2791   case ArrayTypeTraitExprClass:
2792   case ExpressionTraitExprClass:
2793   case CXXNoexceptExprClass:
2794   case SizeOfPackExprClass:
2795   case ObjCStringLiteralClass:
2796   case ObjCEncodeExprClass:
2797   case ObjCBoolLiteralExprClass:
2798   case CXXUuidofExprClass:
2799   case OpaqueValueExprClass:
2800     // These never have a side-effect.
2801     return false;
2802
2803   case CallExprClass:
2804   case MSPropertyRefExprClass:
2805   case CompoundAssignOperatorClass:
2806   case VAArgExprClass:
2807   case AtomicExprClass:
2808   case StmtExprClass:
2809   case CXXOperatorCallExprClass:
2810   case CXXMemberCallExprClass:
2811   case UserDefinedLiteralClass:
2812   case CXXThrowExprClass:
2813   case CXXNewExprClass:
2814   case CXXDeleteExprClass:
2815   case ExprWithCleanupsClass:
2816   case CXXBindTemporaryExprClass:
2817   case BlockExprClass:
2818   case CUDAKernelCallExprClass:
2819     // These always have a side-effect.
2820     return true;
2821
2822   case ParenExprClass:
2823   case ArraySubscriptExprClass:
2824   case MemberExprClass:
2825   case ConditionalOperatorClass:
2826   case BinaryConditionalOperatorClass:
2827   case CompoundLiteralExprClass:
2828   case ExtVectorElementExprClass:
2829   case DesignatedInitExprClass:
2830   case ParenListExprClass:
2831   case CXXPseudoDestructorExprClass:
2832   case SubstNonTypeTemplateParmExprClass:
2833   case MaterializeTemporaryExprClass:
2834   case ShuffleVectorExprClass:
2835   case AsTypeExprClass:
2836     // These have a side-effect if any subexpression does.
2837     break;
2838
2839   case UnaryOperatorClass:
2840     if (cast<UnaryOperator>(this)->isIncrementDecrementOp())
2841       return true;
2842     break;
2843
2844   case BinaryOperatorClass:
2845     if (cast<BinaryOperator>(this)->isAssignmentOp())
2846       return true;
2847     break;
2848
2849   case InitListExprClass:
2850     // FIXME: The children for an InitListExpr doesn't include the array filler.
2851     if (const Expr *E = cast<InitListExpr>(this)->getArrayFiller())
2852       if (E->HasSideEffects(Ctx))
2853         return true;
2854     break;
2855
2856   case GenericSelectionExprClass:
2857     return cast<GenericSelectionExpr>(this)->getResultExpr()->
2858         HasSideEffects(Ctx);
2859
2860   case ChooseExprClass:
2861     return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->HasSideEffects(Ctx);
2862
2863   case CXXDefaultArgExprClass:
2864     return cast<CXXDefaultArgExpr>(this)->getExpr()->HasSideEffects(Ctx);
2865
2866   case CXXDefaultInitExprClass:
2867     if (const Expr *E = cast<CXXDefaultInitExpr>(this)->getExpr())
2868       return E->HasSideEffects(Ctx);
2869     // If we've not yet parsed the initializer, assume it has side-effects.
2870     return true;
2871
2872   case CXXDynamicCastExprClass: {
2873     // A dynamic_cast expression has side-effects if it can throw.
2874     const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(this);
2875     if (DCE->getTypeAsWritten()->isReferenceType() &&
2876         DCE->getCastKind() == CK_Dynamic)
2877       return true;
2878   } // Fall through.
2879   case ImplicitCastExprClass:
2880   case CStyleCastExprClass:
2881   case CXXStaticCastExprClass:
2882   case CXXReinterpretCastExprClass:
2883   case CXXConstCastExprClass:
2884   case CXXFunctionalCastExprClass: {
2885     const CastExpr *CE = cast<CastExpr>(this);
2886     if (CE->getCastKind() == CK_LValueToRValue &&
2887         CE->getSubExpr()->getType().isVolatileQualified())
2888       return true;
2889     break;
2890   }
2891
2892   case CXXTypeidExprClass:
2893     // typeid might throw if its subexpression is potentially-evaluated, so has
2894     // side-effects in that case whether or not its subexpression does.
2895     return cast<CXXTypeidExpr>(this)->isPotentiallyEvaluated();
2896
2897   case CXXConstructExprClass:
2898   case CXXTemporaryObjectExprClass: {
2899     const CXXConstructExpr *CE = cast<CXXConstructExpr>(this);
2900     if (!CE->getConstructor()->isTrivial())
2901       return true;
2902     // A trivial constructor does not add any side-effects of its own. Just look
2903     // at its arguments.
2904     break;
2905   }
2906
2907   case LambdaExprClass: {
2908     const LambdaExpr *LE = cast<LambdaExpr>(this);
2909     for (LambdaExpr::capture_iterator I = LE->capture_begin(),
2910                                       E = LE->capture_end(); I != E; ++I)
2911       if (I->getCaptureKind() == LCK_ByCopy)
2912         // FIXME: Only has a side-effect if the variable is volatile or if
2913         // the copy would invoke a non-trivial copy constructor.
2914         return true;
2915     return false;
2916   }
2917
2918   case PseudoObjectExprClass: {
2919     // Only look for side-effects in the semantic form, and look past
2920     // OpaqueValueExpr bindings in that form.
2921     const PseudoObjectExpr *PO = cast<PseudoObjectExpr>(this);
2922     for (PseudoObjectExpr::const_semantics_iterator I = PO->semantics_begin(),
2923                                                     E = PO->semantics_end();
2924          I != E; ++I) {
2925       const Expr *Subexpr = *I;
2926       if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(Subexpr))
2927         Subexpr = OVE->getSourceExpr();
2928       if (Subexpr->HasSideEffects(Ctx))
2929         return true;
2930     }
2931     return false;
2932   }
2933
2934   case ObjCBoxedExprClass:
2935   case ObjCArrayLiteralClass:
2936   case ObjCDictionaryLiteralClass:
2937   case ObjCMessageExprClass:
2938   case ObjCSelectorExprClass:
2939   case ObjCProtocolExprClass:
2940   case ObjCPropertyRefExprClass:
2941   case ObjCIsaExprClass:
2942   case ObjCIndirectCopyRestoreExprClass:
2943   case ObjCSubscriptRefExprClass:
2944   case ObjCBridgedCastExprClass:
2945     // FIXME: Classify these cases better.
2946     return true;
2947   }
2948
2949   // Recurse to children.
2950   for (const_child_range SubStmts = children(); SubStmts; ++SubStmts)
2951     if (const Stmt *S = *SubStmts)
2952       if (cast<Expr>(S)->HasSideEffects(Ctx))
2953         return true;
2954
2955   return false;
2956 }
2957
2958 namespace {
2959   /// \brief Look for a call to a non-trivial function within an expression.
2960   class NonTrivialCallFinder : public EvaluatedExprVisitor<NonTrivialCallFinder>
2961   {
2962     typedef EvaluatedExprVisitor<NonTrivialCallFinder> Inherited;
2963
2964     bool NonTrivial;
2965
2966   public:
2967     explicit NonTrivialCallFinder(ASTContext &Context)
2968       : Inherited(Context), NonTrivial(false) { }
2969
2970     bool hasNonTrivialCall() const { return NonTrivial; }
2971
2972     void VisitCallExpr(CallExpr *E) {
2973       if (CXXMethodDecl *Method
2974           = dyn_cast_or_null<CXXMethodDecl>(E->getCalleeDecl())) {
2975         if (Method->isTrivial()) {
2976           // Recurse to children of the call.
2977           Inherited::VisitStmt(E);
2978           return;
2979         }
2980       }
2981
2982       NonTrivial = true;
2983     }
2984
2985     void VisitCXXConstructExpr(CXXConstructExpr *E) {
2986       if (E->getConstructor()->isTrivial()) {
2987         // Recurse to children of the call.
2988         Inherited::VisitStmt(E);
2989         return;
2990       }
2991
2992       NonTrivial = true;
2993     }
2994
2995     void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
2996       if (E->getTemporary()->getDestructor()->isTrivial()) {
2997         Inherited::VisitStmt(E);
2998         return;
2999       }
3000
3001       NonTrivial = true;
3002     }
3003   };
3004 }
3005
3006 bool Expr::hasNonTrivialCall(ASTContext &Ctx) {
3007   NonTrivialCallFinder Finder(Ctx);
3008   Finder.Visit(this);
3009   return Finder.hasNonTrivialCall();
3010 }
3011
3012 /// isNullPointerConstant - C99 6.3.2.3p3 - Return whether this is a null
3013 /// pointer constant or not, as well as the specific kind of constant detected.
3014 /// Null pointer constants can be integer constant expressions with the
3015 /// value zero, casts of zero to void*, nullptr (C++0X), or __null
3016 /// (a GNU extension).
3017 Expr::NullPointerConstantKind
3018 Expr::isNullPointerConstant(ASTContext &Ctx,
3019                             NullPointerConstantValueDependence NPC) const {
3020   if (isValueDependent()) {
3021     switch (NPC) {
3022     case NPC_NeverValueDependent:
3023       llvm_unreachable("Unexpected value dependent expression!");
3024     case NPC_ValueDependentIsNull:
3025       if (isTypeDependent() || getType()->isIntegralType(Ctx))
3026         return NPCK_ZeroExpression;
3027       else
3028         return NPCK_NotNull;
3029
3030     case NPC_ValueDependentIsNotNull:
3031       return NPCK_NotNull;
3032     }
3033   }
3034
3035   // Strip off a cast to void*, if it exists. Except in C++.
3036   if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
3037     if (!Ctx.getLangOpts().CPlusPlus) {
3038       // Check that it is a cast to void*.
3039       if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
3040         QualType Pointee = PT->getPointeeType();
3041         if (!Pointee.hasQualifiers() &&
3042             Pointee->isVoidType() &&                              // to void*
3043             CE->getSubExpr()->getType()->isIntegerType())         // from int.
3044           return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3045       }
3046     }
3047   } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
3048     // Ignore the ImplicitCastExpr type entirely.
3049     return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3050   } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
3051     // Accept ((void*)0) as a null pointer constant, as many other
3052     // implementations do.
3053     return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3054   } else if (const GenericSelectionExpr *GE =
3055                dyn_cast<GenericSelectionExpr>(this)) {
3056     return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
3057   } else if (const CXXDefaultArgExpr *DefaultArg
3058                = dyn_cast<CXXDefaultArgExpr>(this)) {
3059     // See through default argument expressions.
3060     return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
3061   } else if (const CXXDefaultInitExpr *DefaultInit
3062                = dyn_cast<CXXDefaultInitExpr>(this)) {
3063     // See through default initializer expressions.
3064     return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);
3065   } else if (isa<GNUNullExpr>(this)) {
3066     // The GNU __null extension is always a null pointer constant.
3067     return NPCK_GNUNull;
3068   } else if (const MaterializeTemporaryExpr *M
3069                                    = dyn_cast<MaterializeTemporaryExpr>(this)) {
3070     return M->GetTemporaryExpr()->isNullPointerConstant(Ctx, NPC);
3071   } else if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(this)) {
3072     if (const Expr *Source = OVE->getSourceExpr())
3073       return Source->isNullPointerConstant(Ctx, NPC);
3074   }
3075
3076   // C++11 nullptr_t is always a null pointer constant.
3077   if (getType()->isNullPtrType())
3078     return NPCK_CXX11_nullptr;
3079
3080   if (const RecordType *UT = getType()->getAsUnionType())
3081     if (UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
3082       if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(this)){
3083         const Expr *InitExpr = CLE->getInitializer();
3084         if (const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
3085           return ILE->getInit(0)->isNullPointerConstant(Ctx, NPC);
3086       }
3087   // This expression must be an integer type.
3088   if (!getType()->isIntegerType() ||
3089       (Ctx.getLangOpts().CPlusPlus && getType()->isEnumeralType()))
3090     return NPCK_NotNull;
3091
3092   // If we have an integer constant expression, we need to *evaluate* it and
3093   // test for the value 0. Don't use the C++11 constant expression semantics
3094   // for this, for now; once the dust settles on core issue 903, we might only
3095   // allow a literal 0 here in C++11 mode.
3096   if (Ctx.getLangOpts().CPlusPlus11) {
3097     if (!isCXX98IntegralConstantExpr(Ctx))
3098       return NPCK_NotNull;
3099   } else {
3100     if (!isIntegerConstantExpr(Ctx))
3101       return NPCK_NotNull;
3102   }
3103
3104   if (EvaluateKnownConstInt(Ctx) != 0)
3105     return NPCK_NotNull;
3106
3107   if (isa<IntegerLiteral>(this))
3108     return NPCK_ZeroLiteral;
3109   return NPCK_ZeroExpression;
3110 }
3111
3112 /// \brief If this expression is an l-value for an Objective C
3113 /// property, find the underlying property reference expression.
3114 const ObjCPropertyRefExpr *Expr::getObjCProperty() const {
3115   const Expr *E = this;
3116   while (true) {
3117     assert((E->getValueKind() == VK_LValue &&
3118             E->getObjectKind() == OK_ObjCProperty) &&
3119            "expression is not a property reference");
3120     E = E->IgnoreParenCasts();
3121     if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
3122       if (BO->getOpcode() == BO_Comma) {
3123         E = BO->getRHS();
3124         continue;
3125       }
3126     }
3127
3128     break;
3129   }
3130
3131   return cast<ObjCPropertyRefExpr>(E);
3132 }
3133
3134 bool Expr::isObjCSelfExpr() const {
3135   const Expr *E = IgnoreParenImpCasts();
3136
3137   const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
3138   if (!DRE)
3139     return false;
3140
3141   const ImplicitParamDecl *Param = dyn_cast<ImplicitParamDecl>(DRE->getDecl());
3142   if (!Param)
3143     return false;
3144
3145   const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(Param->getDeclContext());
3146   if (!M)
3147     return false;
3148
3149   return M->getSelfDecl() == Param;
3150 }
3151
3152 FieldDecl *Expr::getSourceBitField() {
3153   Expr *E = this->IgnoreParens();
3154
3155   while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
3156     if (ICE->getCastKind() == CK_LValueToRValue ||
3157         (ICE->getValueKind() != VK_RValue && ICE->getCastKind() == CK_NoOp))
3158       E = ICE->getSubExpr()->IgnoreParens();
3159     else
3160       break;
3161   }
3162
3163   if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
3164     if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
3165       if (Field->isBitField())
3166         return Field;
3167
3168   if (ObjCIvarRefExpr *IvarRef = dyn_cast<ObjCIvarRefExpr>(E))
3169     if (FieldDecl *Ivar = dyn_cast<FieldDecl>(IvarRef->getDecl()))
3170       if (Ivar->isBitField())
3171         return Ivar;
3172
3173   if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E))
3174     if (FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
3175       if (Field->isBitField())
3176         return Field;
3177
3178   if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E)) {
3179     if (BinOp->isAssignmentOp() && BinOp->getLHS())
3180       return BinOp->getLHS()->getSourceBitField();
3181
3182     if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
3183       return BinOp->getRHS()->getSourceBitField();
3184   }
3185
3186   return 0;
3187 }
3188
3189 bool Expr::refersToVectorElement() const {
3190   const Expr *E = this->IgnoreParens();
3191
3192   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
3193     if (ICE->getValueKind() != VK_RValue &&
3194         ICE->getCastKind() == CK_NoOp)
3195       E = ICE->getSubExpr()->IgnoreParens();
3196     else
3197       break;
3198   }
3199
3200   if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
3201     return ASE->getBase()->getType()->isVectorType();
3202
3203   if (isa<ExtVectorElementExpr>(E))
3204     return true;
3205
3206   return false;
3207 }
3208
3209 /// isArrow - Return true if the base expression is a pointer to vector,
3210 /// return false if the base expression is a vector.
3211 bool ExtVectorElementExpr::isArrow() const {
3212   return getBase()->getType()->isPointerType();
3213 }
3214
3215 unsigned ExtVectorElementExpr::getNumElements() const {
3216   if (const VectorType *VT = getType()->getAs<VectorType>())
3217     return VT->getNumElements();
3218   return 1;
3219 }
3220
3221 /// containsDuplicateElements - Return true if any element access is repeated.
3222 bool ExtVectorElementExpr::containsDuplicateElements() const {
3223   // FIXME: Refactor this code to an accessor on the AST node which returns the
3224   // "type" of component access, and share with code below and in Sema.
3225   StringRef Comp = Accessor->getName();
3226
3227   // Halving swizzles do not contain duplicate elements.
3228   if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
3229     return false;
3230
3231   // Advance past s-char prefix on hex swizzles.
3232   if (Comp[0] == 's' || Comp[0] == 'S')
3233     Comp = Comp.substr(1);
3234
3235   for (unsigned i = 0, e = Comp.size(); i != e; ++i)
3236     if (Comp.substr(i + 1).find(Comp[i]) != StringRef::npos)
3237         return true;
3238
3239   return false;
3240 }
3241
3242 /// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
3243 void ExtVectorElementExpr::getEncodedElementAccess(
3244                                   SmallVectorImpl<unsigned> &Elts) const {
3245   StringRef Comp = Accessor->getName();
3246   if (Comp[0] == 's' || Comp[0] == 'S')
3247     Comp = Comp.substr(1);
3248
3249   bool isHi =   Comp == "hi";
3250   bool isLo =   Comp == "lo";
3251   bool isEven = Comp == "even";
3252   bool isOdd  = Comp == "odd";
3253
3254   for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
3255     uint64_t Index;
3256
3257     if (isHi)
3258       Index = e + i;
3259     else if (isLo)
3260       Index = i;
3261     else if (isEven)
3262       Index = 2 * i;
3263     else if (isOdd)
3264       Index = 2 * i + 1;
3265     else
3266       Index = ExtVectorType::getAccessorIdx(Comp[i]);
3267
3268     Elts.push_back(Index);
3269   }
3270 }
3271
3272 ObjCMessageExpr::ObjCMessageExpr(QualType T,
3273                                  ExprValueKind VK,
3274                                  SourceLocation LBracLoc,
3275                                  SourceLocation SuperLoc,
3276                                  bool IsInstanceSuper,
3277                                  QualType SuperType,
3278                                  Selector Sel,
3279                                  ArrayRef<SourceLocation> SelLocs,
3280                                  SelectorLocationsKind SelLocsK,
3281                                  ObjCMethodDecl *Method,
3282                                  ArrayRef<Expr *> Args,
3283                                  SourceLocation RBracLoc,
3284                                  bool isImplicit)
3285   : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary,
3286          /*TypeDependent=*/false, /*ValueDependent=*/false,
3287          /*InstantiationDependent=*/false,
3288          /*ContainsUnexpandedParameterPack=*/false),
3289     SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
3290                                                        : Sel.getAsOpaquePtr())),
3291     Kind(IsInstanceSuper? SuperInstance : SuperClass),
3292     HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit),
3293     SuperLoc(SuperLoc), LBracLoc(LBracLoc), RBracLoc(RBracLoc)
3294 {
3295   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
3296   setReceiverPointer(SuperType.getAsOpaquePtr());
3297 }
3298
3299 ObjCMessageExpr::ObjCMessageExpr(QualType T,
3300                                  ExprValueKind VK,
3301                                  SourceLocation LBracLoc,
3302                                  TypeSourceInfo *Receiver,
3303                                  Selector Sel,
3304                                  ArrayRef<SourceLocation> SelLocs,
3305                                  SelectorLocationsKind SelLocsK,
3306                                  ObjCMethodDecl *Method,
3307                                  ArrayRef<Expr *> Args,
3308                                  SourceLocation RBracLoc,
3309                                  bool isImplicit)
3310   : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, T->isDependentType(),
3311          T->isDependentType(), T->isInstantiationDependentType(),
3312          T->containsUnexpandedParameterPack()),
3313     SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
3314                                                        : Sel.getAsOpaquePtr())),
3315     Kind(Class),
3316     HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit),
3317     LBracLoc(LBracLoc), RBracLoc(RBracLoc)
3318 {
3319   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
3320   setReceiverPointer(Receiver);
3321 }
3322
3323 ObjCMessageExpr::ObjCMessageExpr(QualType T,
3324                                  ExprValueKind VK,
3325                                  SourceLocation LBracLoc,
3326                                  Expr *Receiver,
3327                                  Selector Sel,
3328                                  ArrayRef<SourceLocation> SelLocs,
3329                                  SelectorLocationsKind SelLocsK,
3330                                  ObjCMethodDecl *Method,
3331                                  ArrayRef<Expr *> Args,
3332                                  SourceLocation RBracLoc,
3333                                  bool isImplicit)
3334   : Expr(ObjCMessageExprClass, T, VK, OK_Ordinary, Receiver->isTypeDependent(),
3335          Receiver->isTypeDependent(),
3336          Receiver->isInstantiationDependent(),
3337          Receiver->containsUnexpandedParameterPack()),
3338     SelectorOrMethod(reinterpret_cast<uintptr_t>(Method? Method
3339                                                        : Sel.getAsOpaquePtr())),
3340     Kind(Instance),
3341     HasMethod(Method != 0), IsDelegateInitCall(false), IsImplicit(isImplicit),
3342     LBracLoc(LBracLoc), RBracLoc(RBracLoc)
3343 {
3344   initArgsAndSelLocs(Args, SelLocs, SelLocsK);
3345   setReceiverPointer(Receiver);
3346 }
3347
3348 void ObjCMessageExpr::initArgsAndSelLocs(ArrayRef<Expr *> Args,
3349                                          ArrayRef<SourceLocation> SelLocs,
3350                                          SelectorLocationsKind SelLocsK) {
3351   setNumArgs(Args.size());
3352   Expr **MyArgs = getArgs();
3353   for (unsigned I = 0; I != Args.size(); ++I) {
3354     if (Args[I]->isTypeDependent())
3355       ExprBits.TypeDependent = true;
3356     if (Args[I]->isValueDependent())
3357       ExprBits.ValueDependent = true;
3358     if (Args[I]->isInstantiationDependent())
3359       ExprBits.InstantiationDependent = true;
3360     if (Args[I]->containsUnexpandedParameterPack())
3361       ExprBits.ContainsUnexpandedParameterPack = true;
3362
3363     MyArgs[I] = Args[I];
3364   }
3365
3366   SelLocsKind = SelLocsK;
3367   if (!isImplicit()) {
3368     if (SelLocsK == SelLoc_NonStandard)
3369       std::copy(SelLocs.begin(), SelLocs.end(), getStoredSelLocs());
3370   }
3371 }
3372
3373 ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
3374                                          ExprValueKind VK,
3375                                          SourceLocation LBracLoc,
3376                                          SourceLocation SuperLoc,
3377                                          bool IsInstanceSuper,
3378                                          QualType SuperType,
3379                                          Selector Sel,
3380                                          ArrayRef<SourceLocation> SelLocs,
3381                                          ObjCMethodDecl *Method,
3382                                          ArrayRef<Expr *> Args,
3383                                          SourceLocation RBracLoc,
3384                                          bool isImplicit) {
3385   assert((!SelLocs.empty() || isImplicit) &&
3386          "No selector locs for non-implicit message");
3387   ObjCMessageExpr *Mem;
3388   SelectorLocationsKind SelLocsK = SelectorLocationsKind();
3389   if (isImplicit)
3390     Mem = alloc(Context, Args.size(), 0);
3391   else
3392     Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
3393   return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, SuperLoc, IsInstanceSuper,
3394                                    SuperType, Sel, SelLocs, SelLocsK,
3395                                    Method, Args, RBracLoc, isImplicit);
3396 }
3397
3398 ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
3399                                          ExprValueKind VK,
3400                                          SourceLocation LBracLoc,
3401                                          TypeSourceInfo *Receiver,
3402                                          Selector Sel,
3403                                          ArrayRef<SourceLocation> SelLocs,
3404                                          ObjCMethodDecl *Method,
3405                                          ArrayRef<Expr *> Args,
3406                                          SourceLocation RBracLoc,
3407                                          bool isImplicit) {
3408   assert((!SelLocs.empty() || isImplicit) &&
3409          "No selector locs for non-implicit message");
3410   ObjCMessageExpr *Mem;
3411   SelectorLocationsKind SelLocsK = SelectorLocationsKind();
3412   if (isImplicit)
3413     Mem = alloc(Context, Args.size(), 0);
3414   else
3415     Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
3416   return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel,
3417                                    SelLocs, SelLocsK, Method, Args, RBracLoc,
3418                                    isImplicit);
3419 }
3420
3421 ObjCMessageExpr *ObjCMessageExpr::Create(ASTContext &Context, QualType T,
3422                                          ExprValueKind VK,
3423                                          SourceLocation LBracLoc,
3424                                          Expr *Receiver,
3425                                          Selector Sel,
3426                                          ArrayRef<SourceLocation> SelLocs,
3427                                          ObjCMethodDecl *Method,
3428                                          ArrayRef<Expr *> Args,
3429                                          SourceLocation RBracLoc,
3430                                          bool isImplicit) {
3431   assert((!SelLocs.empty() || isImplicit) &&
3432          "No selector locs for non-implicit message");
3433   ObjCMessageExpr *Mem;
3434   SelectorLocationsKind SelLocsK = SelectorLocationsKind();
3435   if (isImplicit)
3436     Mem = alloc(Context, Args.size(), 0);
3437   else
3438     Mem = alloc(Context, Args, RBracLoc, SelLocs, Sel, SelLocsK);
3439   return new (Mem) ObjCMessageExpr(T, VK, LBracLoc, Receiver, Sel,
3440                                    SelLocs, SelLocsK, Method, Args, RBracLoc,
3441                                    isImplicit);
3442 }
3443
3444 ObjCMessageExpr *ObjCMessageExpr::CreateEmpty(ASTContext &Context,
3445                                               unsigned NumArgs,
3446                                               unsigned NumStoredSelLocs) {
3447   ObjCMessageExpr *Mem = alloc(Context, NumArgs, NumStoredSelLocs);
3448   return new (Mem) ObjCMessageExpr(EmptyShell(), NumArgs);
3449 }
3450
3451 ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext &C,
3452                                         ArrayRef<Expr *> Args,
3453                                         SourceLocation RBraceLoc,
3454                                         ArrayRef<SourceLocation> SelLocs,
3455                                         Selector Sel,
3456                                         SelectorLocationsKind &SelLocsK) {
3457   SelLocsK = hasStandardSelectorLocs(Sel, SelLocs, Args, RBraceLoc);
3458   unsigned NumStoredSelLocs = (SelLocsK == SelLoc_NonStandard) ? SelLocs.size()
3459                                                                : 0;
3460   return alloc(C, Args.size(), NumStoredSelLocs);
3461 }
3462
3463 ObjCMessageExpr *ObjCMessageExpr::alloc(ASTContext &C,
3464                                         unsigned NumArgs,
3465                                         unsigned NumStoredSelLocs) {
3466   unsigned Size = sizeof(ObjCMessageExpr) + sizeof(void *) +
3467     NumArgs * sizeof(Expr *) + NumStoredSelLocs * sizeof(SourceLocation);
3468   return (ObjCMessageExpr *)C.Allocate(Size,
3469                                      llvm::AlignOf<ObjCMessageExpr>::Alignment);
3470 }
3471
3472 void ObjCMessageExpr::getSelectorLocs(
3473                                SmallVectorImpl<SourceLocation> &SelLocs) const {
3474   for (unsigned i = 0, e = getNumSelectorLocs(); i != e; ++i)
3475     SelLocs.push_back(getSelectorLoc(i));
3476 }
3477
3478 SourceRange ObjCMessageExpr::getReceiverRange() const {
3479   switch (getReceiverKind()) {
3480   case Instance:
3481     return getInstanceReceiver()->getSourceRange();
3482
3483   case Class:
3484     return getClassReceiverTypeInfo()->getTypeLoc().getSourceRange();
3485
3486   case SuperInstance:
3487   case SuperClass:
3488     return getSuperLoc();
3489   }
3490
3491   llvm_unreachable("Invalid ReceiverKind!");
3492 }
3493
3494 Selector ObjCMessageExpr::getSelector() const {
3495   if (HasMethod)
3496     return reinterpret_cast<const ObjCMethodDecl *>(SelectorOrMethod)
3497                                                                ->getSelector();
3498   return Selector(SelectorOrMethod);
3499 }
3500
3501 QualType ObjCMessageExpr::getReceiverType() const {
3502   switch (getReceiverKind()) {
3503   case Instance:
3504     return getInstanceReceiver()->getType();
3505   case Class:
3506     return getClassReceiver();
3507   case SuperInstance:
3508   case SuperClass:
3509     return getSuperType();
3510   }
3511
3512   llvm_unreachable("unexpected receiver kind");
3513 }
3514
3515 ObjCInterfaceDecl *ObjCMessageExpr::getReceiverInterface() const {
3516   QualType T = getReceiverType();
3517
3518   if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
3519     return Ptr->getInterfaceDecl();
3520
3521   if (const ObjCObjectType *Ty = T->getAs<ObjCObjectType>())
3522     return Ty->getInterface();
3523
3524   return 0;
3525 }
3526
3527 StringRef ObjCBridgedCastExpr::getBridgeKindName() const {
3528   switch (getBridgeKind()) {
3529   case OBC_Bridge:
3530     return "__bridge";
3531   case OBC_BridgeTransfer:
3532     return "__bridge_transfer";
3533   case OBC_BridgeRetained:
3534     return "__bridge_retained";
3535   }
3536
3537   llvm_unreachable("Invalid BridgeKind!");
3538 }
3539
3540 bool ChooseExpr::isConditionTrue(const ASTContext &C) const {
3541   return getCond()->EvaluateKnownConstInt(C) != 0;
3542 }
3543
3544 ShuffleVectorExpr::ShuffleVectorExpr(ASTContext &C, ArrayRef<Expr*> args,
3545                                      QualType Type, SourceLocation BLoc,
3546                                      SourceLocation RP)
3547    : Expr(ShuffleVectorExprClass, Type, VK_RValue, OK_Ordinary,
3548           Type->isDependentType(), Type->isDependentType(),
3549           Type->isInstantiationDependentType(),
3550           Type->containsUnexpandedParameterPack()),
3551      BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size())
3552 {
3553   SubExprs = new (C) Stmt*[args.size()];
3554   for (unsigned i = 0; i != args.size(); i++) {
3555     if (args[i]->isTypeDependent())
3556       ExprBits.TypeDependent = true;
3557     if (args[i]->isValueDependent())
3558       ExprBits.ValueDependent = true;
3559     if (args[i]->isInstantiationDependent())
3560       ExprBits.InstantiationDependent = true;
3561     if (args[i]->containsUnexpandedParameterPack())
3562       ExprBits.ContainsUnexpandedParameterPack = true;
3563
3564     SubExprs[i] = args[i];
3565   }
3566 }
3567
3568 void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
3569                                  unsigned NumExprs) {
3570   if (SubExprs) C.Deallocate(SubExprs);
3571
3572   SubExprs = new (C) Stmt* [NumExprs];
3573   this->NumExprs = NumExprs;
3574   memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
3575 }
3576
3577 GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
3578                                SourceLocation GenericLoc, Expr *ControllingExpr,
3579                                ArrayRef<TypeSourceInfo*> AssocTypes,
3580                                ArrayRef<Expr*> AssocExprs,
3581                                SourceLocation DefaultLoc,
3582                                SourceLocation RParenLoc,
3583                                bool ContainsUnexpandedParameterPack,
3584                                unsigned ResultIndex)
3585   : Expr(GenericSelectionExprClass,
3586          AssocExprs[ResultIndex]->getType(),
3587          AssocExprs[ResultIndex]->getValueKind(),
3588          AssocExprs[ResultIndex]->getObjectKind(),
3589          AssocExprs[ResultIndex]->isTypeDependent(),
3590          AssocExprs[ResultIndex]->isValueDependent(),
3591          AssocExprs[ResultIndex]->isInstantiationDependent(),
3592          ContainsUnexpandedParameterPack),
3593     AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]),
3594     SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]),
3595     NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
3596     GenericLoc(GenericLoc), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
3597   SubExprs[CONTROLLING] = ControllingExpr;
3598   assert(AssocTypes.size() == AssocExprs.size());
3599   std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes);
3600   std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR);
3601 }
3602
3603 GenericSelectionExpr::GenericSelectionExpr(ASTContext &Context,
3604                                SourceLocation GenericLoc, Expr *ControllingExpr,
3605                                ArrayRef<TypeSourceInfo*> AssocTypes,
3606                                ArrayRef<Expr*> AssocExprs,
3607                                SourceLocation DefaultLoc,
3608                                SourceLocation RParenLoc,
3609                                bool ContainsUnexpandedParameterPack)
3610   : Expr(GenericSelectionExprClass,
3611          Context.DependentTy,
3612          VK_RValue,
3613          OK_Ordinary,
3614          /*isTypeDependent=*/true,
3615          /*isValueDependent=*/true,
3616          /*isInstantiationDependent=*/true,
3617          ContainsUnexpandedParameterPack),
3618     AssocTypes(new (Context) TypeSourceInfo*[AssocTypes.size()]),
3619     SubExprs(new (Context) Stmt*[END_EXPR+AssocExprs.size()]),
3620     NumAssocs(AssocExprs.size()), ResultIndex(-1U), GenericLoc(GenericLoc),
3621     DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
3622   SubExprs[CONTROLLING] = ControllingExpr;
3623   assert(AssocTypes.size() == AssocExprs.size());
3624   std::copy(AssocTypes.begin(), AssocTypes.end(), this->AssocTypes);
3625   std::copy(AssocExprs.begin(), AssocExprs.end(), SubExprs+END_EXPR);
3626 }
3627
3628 //===----------------------------------------------------------------------===//
3629 //  DesignatedInitExpr
3630 //===----------------------------------------------------------------------===//
3631
3632 IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() const {
3633   assert(Kind == FieldDesignator && "Only valid on a field designator");
3634   if (Field.NameOrField & 0x01)
3635     return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
3636   else
3637     return getField()->getIdentifier();
3638 }
3639
3640 DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
3641                                        unsigned NumDesignators,
3642                                        const Designator *Designators,
3643                                        SourceLocation EqualOrColonLoc,
3644                                        bool GNUSyntax,
3645                                        ArrayRef<Expr*> IndexExprs,
3646                                        Expr *Init)
3647   : Expr(DesignatedInitExprClass, Ty,
3648          Init->getValueKind(), Init->getObjectKind(),
3649          Init->isTypeDependent(), Init->isValueDependent(),
3650          Init->isInstantiationDependent(),
3651          Init->containsUnexpandedParameterPack()),
3652     EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
3653     NumDesignators(NumDesignators), NumSubExprs(IndexExprs.size() + 1) {
3654   this->Designators = new (C) Designator[NumDesignators];
3655
3656   // Record the initializer itself.
3657   child_range Child = children();
3658   *Child++ = Init;
3659
3660   // Copy the designators and their subexpressions, computing
3661   // value-dependence along the way.
3662   unsigned IndexIdx = 0;
3663   for (unsigned I = 0; I != NumDesignators; ++I) {
3664     this->Designators[I] = Designators[I];
3665
3666     if (this->Designators[I].isArrayDesignator()) {
3667       // Compute type- and value-dependence.
3668       Expr *Index = IndexExprs[IndexIdx];
3669       if (Index->isTypeDependent() || Index->isValueDependent())
3670         ExprBits.ValueDependent = true;
3671       if (Index->isInstantiationDependent())
3672         ExprBits.InstantiationDependent = true;
3673       // Propagate unexpanded parameter packs.
3674       if (Index->containsUnexpandedParameterPack())
3675         ExprBits.ContainsUnexpandedParameterPack = true;
3676
3677       // Copy the index expressions into permanent storage.
3678       *Child++ = IndexExprs[IndexIdx++];
3679     } else if (this->Designators[I].isArrayRangeDesignator()) {
3680       // Compute type- and value-dependence.
3681       Expr *Start = IndexExprs[IndexIdx];
3682       Expr *End = IndexExprs[IndexIdx + 1];
3683       if (Start->isTypeDependent() || Start->isValueDependent() ||
3684           End->isTypeDependent() || End->isValueDependent()) {
3685         ExprBits.ValueDependent = true;
3686         ExprBits.InstantiationDependent = true;
3687       } else if (Start->isInstantiationDependent() ||
3688                  End->isInstantiationDependent()) {
3689         ExprBits.InstantiationDependent = true;
3690       }
3691
3692       // Propagate unexpanded parameter packs.
3693       if (Start->containsUnexpandedParameterPack() ||
3694           End->containsUnexpandedParameterPack())
3695         ExprBits.ContainsUnexpandedParameterPack = true;
3696
3697       // Copy the start/end expressions into permanent storage.
3698       *Child++ = IndexExprs[IndexIdx++];
3699       *Child++ = IndexExprs[IndexIdx++];
3700     }
3701   }
3702
3703   assert(IndexIdx == IndexExprs.size() && "Wrong number of index expressions");
3704 }
3705
3706 DesignatedInitExpr *
3707 DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
3708                            unsigned NumDesignators,
3709                            ArrayRef<Expr*> IndexExprs,
3710                            SourceLocation ColonOrEqualLoc,
3711                            bool UsesColonSyntax, Expr *Init) {
3712   void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
3713                          sizeof(Stmt *) * (IndexExprs.size() + 1), 8);
3714   return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
3715                                       ColonOrEqualLoc, UsesColonSyntax,
3716                                       IndexExprs, Init);
3717 }
3718
3719 DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
3720                                                     unsigned NumIndexExprs) {
3721   void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
3722                          sizeof(Stmt *) * (NumIndexExprs + 1), 8);
3723   return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
3724 }
3725
3726 void DesignatedInitExpr::setDesignators(ASTContext &C,
3727                                         const Designator *Desigs,
3728                                         unsigned NumDesigs) {
3729   Designators = new (C) Designator[NumDesigs];
3730   NumDesignators = NumDesigs;
3731   for (unsigned I = 0; I != NumDesigs; ++I)
3732     Designators[I] = Desigs[I];
3733 }
3734
3735 SourceRange DesignatedInitExpr::getDesignatorsSourceRange() const {
3736   DesignatedInitExpr *DIE = const_cast<DesignatedInitExpr*>(this);
3737   if (size() == 1)
3738     return DIE->getDesignator(0)->getSourceRange();
3739   return SourceRange(DIE->getDesignator(0)->getLocStart(),
3740                      DIE->getDesignator(size()-1)->getLocEnd());
3741 }
3742
3743 SourceLocation DesignatedInitExpr::getLocStart() const {
3744   SourceLocation StartLoc;
3745   Designator &First =
3746     *const_cast<DesignatedInitExpr*>(this)->designators_begin();
3747   if (First.isFieldDesignator()) {
3748     if (GNUSyntax)
3749       StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
3750     else
3751       StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
3752   } else
3753     StartLoc =
3754       SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
3755   return StartLoc;
3756 }
3757
3758 SourceLocation DesignatedInitExpr::getLocEnd() const {
3759   return getInit()->getLocEnd();
3760 }
3761
3762 Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) const {
3763   assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
3764   char *Ptr = static_cast<char *>(
3765                   const_cast<void *>(static_cast<const void *>(this)));
3766   Ptr += sizeof(DesignatedInitExpr);
3767   Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3768   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
3769 }
3770
3771 Expr *DesignatedInitExpr::getArrayRangeStart(const Designator &D) const {
3772   assert(D.Kind == Designator::ArrayRangeDesignator &&
3773          "Requires array range designator");
3774   char *Ptr = static_cast<char *>(
3775                   const_cast<void *>(static_cast<const void *>(this)));
3776   Ptr += sizeof(DesignatedInitExpr);
3777   Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3778   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
3779 }
3780
3781 Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator &D) const {
3782   assert(D.Kind == Designator::ArrayRangeDesignator &&
3783          "Requires array range designator");
3784   char *Ptr = static_cast<char *>(
3785                   const_cast<void *>(static_cast<const void *>(this)));
3786   Ptr += sizeof(DesignatedInitExpr);
3787   Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
3788   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
3789 }
3790
3791 /// \brief Replaces the designator at index @p Idx with the series
3792 /// of designators in [First, Last).
3793 void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
3794                                           const Designator *First,
3795                                           const Designator *Last) {
3796   unsigned NumNewDesignators = Last - First;
3797   if (NumNewDesignators == 0) {
3798     std::copy_backward(Designators + Idx + 1,
3799                        Designators + NumDesignators,
3800                        Designators + Idx);
3801     --NumNewDesignators;
3802     return;
3803   } else if (NumNewDesignators == 1) {
3804     Designators[Idx] = *First;
3805     return;
3806   }
3807
3808   Designator *NewDesignators
3809     = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
3810   std::copy(Designators, Designators + Idx, NewDesignators);
3811   std::copy(First, Last, NewDesignators + Idx);
3812   std::copy(Designators + Idx + 1, Designators + NumDesignators,
3813             NewDesignators + Idx + NumNewDesignators);
3814   Designators = NewDesignators;
3815   NumDesignators = NumDesignators - 1 + NumNewDesignators;
3816 }
3817
3818 ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
3819                              ArrayRef<Expr*> exprs,
3820                              SourceLocation rparenloc)
3821   : Expr(ParenListExprClass, QualType(), VK_RValue, OK_Ordinary,
3822          false, false, false, false),
3823     NumExprs(exprs.size()), LParenLoc(lparenloc), RParenLoc(rparenloc) {
3824   Exprs = new (C) Stmt*[exprs.size()];
3825   for (unsigned i = 0; i != exprs.size(); ++i) {
3826     if (exprs[i]->isTypeDependent())
3827       ExprBits.TypeDependent = true;
3828     if (exprs[i]->isValueDependent())
3829       ExprBits.ValueDependent = true;
3830     if (exprs[i]->isInstantiationDependent())
3831       ExprBits.InstantiationDependent = true;
3832     if (exprs[i]->containsUnexpandedParameterPack())
3833       ExprBits.ContainsUnexpandedParameterPack = true;
3834
3835     Exprs[i] = exprs[i];
3836   }
3837 }
3838
3839 const OpaqueValueExpr *OpaqueValueExpr::findInCopyConstruct(const Expr *e) {
3840   if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(e))
3841     e = ewc->getSubExpr();
3842   if (const MaterializeTemporaryExpr *m = dyn_cast<MaterializeTemporaryExpr>(e))
3843     e = m->GetTemporaryExpr();
3844   e = cast<CXXConstructExpr>(e)->getArg(0);
3845   while (const ImplicitCastExpr *ice = dyn_cast<ImplicitCastExpr>(e))
3846     e = ice->getSubExpr();
3847   return cast<OpaqueValueExpr>(e);
3848 }
3849
3850 PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext &Context, EmptyShell sh,
3851                                            unsigned numSemanticExprs) {
3852   void *buffer = Context.Allocate(sizeof(PseudoObjectExpr) +
3853                                     (1 + numSemanticExprs) * sizeof(Expr*),
3854                                   llvm::alignOf<PseudoObjectExpr>());
3855   return new(buffer) PseudoObjectExpr(sh, numSemanticExprs);
3856 }
3857
3858 PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell, unsigned numSemanticExprs)
3859   : Expr(PseudoObjectExprClass, shell) {
3860   PseudoObjectExprBits.NumSubExprs = numSemanticExprs + 1;
3861 }
3862
3863 PseudoObjectExpr *PseudoObjectExpr::Create(ASTContext &C, Expr *syntax,
3864                                            ArrayRef<Expr*> semantics,
3865                                            unsigned resultIndex) {
3866   assert(syntax && "no syntactic expression!");
3867   assert(semantics.size() && "no semantic expressions!");
3868
3869   QualType type;
3870   ExprValueKind VK;
3871   if (resultIndex == NoResult) {
3872     type = C.VoidTy;
3873     VK = VK_RValue;
3874   } else {
3875     assert(resultIndex < semantics.size());
3876     type = semantics[resultIndex]->getType();
3877     VK = semantics[resultIndex]->getValueKind();
3878     assert(semantics[resultIndex]->getObjectKind() == OK_Ordinary);
3879   }
3880
3881   void *buffer = C.Allocate(sizeof(PseudoObjectExpr) +
3882                               (1 + semantics.size()) * sizeof(Expr*),
3883                             llvm::alignOf<PseudoObjectExpr>());
3884   return new(buffer) PseudoObjectExpr(type, VK, syntax, semantics,
3885                                       resultIndex);
3886 }
3887
3888 PseudoObjectExpr::PseudoObjectExpr(QualType type, ExprValueKind VK,
3889                                    Expr *syntax, ArrayRef<Expr*> semantics,
3890                                    unsigned resultIndex)
3891   : Expr(PseudoObjectExprClass, type, VK, OK_Ordinary,
3892          /*filled in at end of ctor*/ false, false, false, false) {
3893   PseudoObjectExprBits.NumSubExprs = semantics.size() + 1;
3894   PseudoObjectExprBits.ResultIndex = resultIndex + 1;
3895
3896   for (unsigned i = 0, e = semantics.size() + 1; i != e; ++i) {
3897     Expr *E = (i == 0 ? syntax : semantics[i-1]);
3898     getSubExprsBuffer()[i] = E;
3899
3900     if (E->isTypeDependent())
3901       ExprBits.TypeDependent = true;
3902     if (E->isValueDependent())
3903       ExprBits.ValueDependent = true;
3904     if (E->isInstantiationDependent())
3905       ExprBits.InstantiationDependent = true;
3906     if (E->containsUnexpandedParameterPack())
3907       ExprBits.ContainsUnexpandedParameterPack = true;
3908
3909     if (isa<OpaqueValueExpr>(E))
3910       assert(cast<OpaqueValueExpr>(E)->getSourceExpr() != 0 &&
3911              "opaque-value semantic expressions for pseudo-object "
3912              "operations must have sources");
3913   }
3914 }
3915
3916 //===----------------------------------------------------------------------===//
3917 //  ExprIterator.
3918 //===----------------------------------------------------------------------===//
3919
3920 Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
3921 Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
3922 Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
3923 const Expr* ConstExprIterator::operator[](size_t idx) const {
3924   return cast<Expr>(I[idx]);
3925 }
3926 const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
3927 const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
3928
3929 //===----------------------------------------------------------------------===//
3930 //  Child Iterators for iterating over subexpressions/substatements
3931 //===----------------------------------------------------------------------===//
3932
3933 // UnaryExprOrTypeTraitExpr
3934 Stmt::child_range UnaryExprOrTypeTraitExpr::children() {
3935   // If this is of a type and the type is a VLA type (and not a typedef), the
3936   // size expression of the VLA needs to be treated as an executable expression.
3937   // Why isn't this weirdness documented better in StmtIterator?
3938   if (isArgumentType()) {
3939     if (const VariableArrayType* T = dyn_cast<VariableArrayType>(
3940                                    getArgumentType().getTypePtr()))
3941       return child_range(child_iterator(T), child_iterator());
3942     return child_range();
3943   }
3944   return child_range(&Argument.Ex, &Argument.Ex + 1);
3945 }
3946
3947 // ObjCMessageExpr
3948 Stmt::child_range ObjCMessageExpr::children() {
3949   Stmt **begin;
3950   if (getReceiverKind() == Instance)
3951     begin = reinterpret_cast<Stmt **>(this + 1);
3952   else
3953     begin = reinterpret_cast<Stmt **>(getArgs());
3954   return child_range(begin,
3955                      reinterpret_cast<Stmt **>(getArgs() + getNumArgs()));
3956 }
3957
3958 ObjCArrayLiteral::ObjCArrayLiteral(ArrayRef<Expr *> Elements,
3959                                    QualType T, ObjCMethodDecl *Method,
3960                                    SourceRange SR)
3961   : Expr(ObjCArrayLiteralClass, T, VK_RValue, OK_Ordinary,
3962          false, false, false, false),
3963     NumElements(Elements.size()), Range(SR), ArrayWithObjectsMethod(Method)
3964 {
3965   Expr **SaveElements = getElements();
3966   for (unsigned I = 0, N = Elements.size(); I != N; ++I) {
3967     if (Elements[I]->isTypeDependent() || Elements[I]->isValueDependent())
3968       ExprBits.ValueDependent = true;
3969     if (Elements[I]->isInstantiationDependent())
3970       ExprBits.InstantiationDependent = true;
3971     if (Elements[I]->containsUnexpandedParameterPack())
3972       ExprBits.ContainsUnexpandedParameterPack = true;
3973
3974     SaveElements[I] = Elements[I];
3975   }
3976 }
3977
3978 ObjCArrayLiteral *ObjCArrayLiteral::Create(ASTContext &C,
3979                                            ArrayRef<Expr *> Elements,
3980                                            QualType T, ObjCMethodDecl * Method,
3981                                            SourceRange SR) {
3982   void *Mem = C.Allocate(sizeof(ObjCArrayLiteral)
3983                          + Elements.size() * sizeof(Expr *));
3984   return new (Mem) ObjCArrayLiteral(Elements, T, Method, SR);
3985 }
3986
3987 ObjCArrayLiteral *ObjCArrayLiteral::CreateEmpty(ASTContext &C,
3988                                                 unsigned NumElements) {
3989
3990   void *Mem = C.Allocate(sizeof(ObjCArrayLiteral)
3991                          + NumElements * sizeof(Expr *));
3992   return new (Mem) ObjCArrayLiteral(EmptyShell(), NumElements);
3993 }
3994
3995 ObjCDictionaryLiteral::ObjCDictionaryLiteral(
3996                                              ArrayRef<ObjCDictionaryElement> VK,
3997                                              bool HasPackExpansions,
3998                                              QualType T, ObjCMethodDecl *method,
3999                                              SourceRange SR)
4000   : Expr(ObjCDictionaryLiteralClass, T, VK_RValue, OK_Ordinary, false, false,
4001          false, false),
4002     NumElements(VK.size()), HasPackExpansions(HasPackExpansions), Range(SR),
4003     DictWithObjectsMethod(method)
4004 {
4005   KeyValuePair *KeyValues = getKeyValues();
4006   ExpansionData *Expansions = getExpansionData();
4007   for (unsigned I = 0; I < NumElements; I++) {
4008     if (VK[I].Key->isTypeDependent() || VK[I].Key->isValueDependent() ||
4009         VK[I].Value->isTypeDependent() || VK[I].Value->isValueDependent())
4010       ExprBits.ValueDependent = true;
4011     if (VK[I].Key->isInstantiationDependent() ||
4012         VK[I].Value->isInstantiationDependent())
4013       ExprBits.InstantiationDependent = true;
4014     if (VK[I].EllipsisLoc.isInvalid() &&
4015         (VK[I].Key->containsUnexpandedParameterPack() ||
4016          VK[I].Value->containsUnexpandedParameterPack()))
4017       ExprBits.ContainsUnexpandedParameterPack = true;
4018
4019     KeyValues[I].Key = VK[I].Key;
4020     KeyValues[I].Value = VK[I].Value;
4021     if (Expansions) {
4022       Expansions[I].EllipsisLoc = VK[I].EllipsisLoc;
4023       if (VK[I].NumExpansions)
4024         Expansions[I].NumExpansionsPlusOne = *VK[I].NumExpansions + 1;
4025       else
4026         Expansions[I].NumExpansionsPlusOne = 0;
4027     }
4028   }
4029 }
4030
4031 ObjCDictionaryLiteral *
4032 ObjCDictionaryLiteral::Create(ASTContext &C,
4033                               ArrayRef<ObjCDictionaryElement> VK,
4034                               bool HasPackExpansions,
4035                               QualType T, ObjCMethodDecl *method,
4036                               SourceRange SR) {
4037   unsigned ExpansionsSize = 0;
4038   if (HasPackExpansions)
4039     ExpansionsSize = sizeof(ExpansionData) * VK.size();
4040
4041   void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) +
4042                          sizeof(KeyValuePair) * VK.size() + ExpansionsSize);
4043   return new (Mem) ObjCDictionaryLiteral(VK, HasPackExpansions, T, method, SR);
4044 }
4045
4046 ObjCDictionaryLiteral *
4047 ObjCDictionaryLiteral::CreateEmpty(ASTContext &C, unsigned NumElements,
4048                                    bool HasPackExpansions) {
4049   unsigned ExpansionsSize = 0;
4050   if (HasPackExpansions)
4051     ExpansionsSize = sizeof(ExpansionData) * NumElements;
4052   void *Mem = C.Allocate(sizeof(ObjCDictionaryLiteral) +
4053                          sizeof(KeyValuePair) * NumElements + ExpansionsSize);
4054   return new (Mem) ObjCDictionaryLiteral(EmptyShell(), NumElements,
4055                                          HasPackExpansions);
4056 }
4057
4058 ObjCSubscriptRefExpr *ObjCSubscriptRefExpr::Create(ASTContext &C,
4059                                                    Expr *base,
4060                                                    Expr *key, QualType T,
4061                                                    ObjCMethodDecl *getMethod,
4062                                                    ObjCMethodDecl *setMethod,
4063                                                    SourceLocation RB) {
4064   void *Mem = C.Allocate(sizeof(ObjCSubscriptRefExpr));
4065   return new (Mem) ObjCSubscriptRefExpr(base, key, T, VK_LValue,
4066                                         OK_ObjCSubscript,
4067                                         getMethod, setMethod, RB);
4068 }
4069
4070 AtomicExpr::AtomicExpr(SourceLocation BLoc, ArrayRef<Expr*> args,
4071                        QualType t, AtomicOp op, SourceLocation RP)
4072   : Expr(AtomicExprClass, t, VK_RValue, OK_Ordinary,
4073          false, false, false, false),
4074     NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op)
4075 {
4076   assert(args.size() == getNumSubExprs(op) && "wrong number of subexpressions");
4077   for (unsigned i = 0; i != args.size(); i++) {
4078     if (args[i]->isTypeDependent())
4079       ExprBits.TypeDependent = true;
4080     if (args[i]->isValueDependent())
4081       ExprBits.ValueDependent = true;
4082     if (args[i]->isInstantiationDependent())
4083       ExprBits.InstantiationDependent = true;
4084     if (args[i]->containsUnexpandedParameterPack())
4085       ExprBits.ContainsUnexpandedParameterPack = true;
4086
4087     SubExprs[i] = args[i];
4088   }
4089 }
4090
4091 unsigned AtomicExpr::getNumSubExprs(AtomicOp Op) {
4092   switch (Op) {
4093   case AO__c11_atomic_init:
4094   case AO__c11_atomic_load:
4095   case AO__atomic_load_n:
4096     return 2;
4097
4098   case AO__c11_atomic_store:
4099   case AO__c11_atomic_exchange:
4100   case AO__atomic_load:
4101   case AO__atomic_store:
4102   case AO__atomic_store_n:
4103   case AO__atomic_exchange_n:
4104   case AO__c11_atomic_fetch_add:
4105   case AO__c11_atomic_fetch_sub:
4106   case AO__c11_atomic_fetch_and:
4107   case AO__c11_atomic_fetch_or:
4108   case AO__c11_atomic_fetch_xor:
4109   case AO__atomic_fetch_add:
4110   case AO__atomic_fetch_sub:
4111   case AO__atomic_fetch_and:
4112   case AO__atomic_fetch_or:
4113   case AO__atomic_fetch_xor:
4114   case AO__atomic_fetch_nand:
4115   case AO__atomic_add_fetch:
4116   case AO__atomic_sub_fetch:
4117   case AO__atomic_and_fetch:
4118   case AO__atomic_or_fetch:
4119   case AO__atomic_xor_fetch:
4120   case AO__atomic_nand_fetch:
4121     return 3;
4122
4123   case AO__atomic_exchange:
4124     return 4;
4125
4126   case AO__c11_atomic_compare_exchange_strong:
4127   case AO__c11_atomic_compare_exchange_weak:
4128     return 5;
4129
4130   case AO__atomic_compare_exchange:
4131   case AO__atomic_compare_exchange_n:
4132     return 6;
4133   }
4134   llvm_unreachable("unknown atomic op");
4135 }