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/Expr.h"
  15 #include "clang/AST/ExprCXX.h"
  16 #include "clang/AST/APValue.h"
  17 #include "clang/AST/ASTContext.h"
  18 #include "clang/AST/DeclObjC.h"
  19 #include "clang/AST/DeclCXX.h"
  20 #include "clang/AST/DeclTemplate.h"
  21 #include "clang/AST/RecordLayout.h"
  22 #include "clang/AST/StmtVisitor.h"
  23 #include "clang/Basic/Builtins.h"
  24 #include "clang/Basic/TargetInfo.h"
  25 #include "llvm/Support/ErrorHandling.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include <algorithm>
  28 using namespace clang;
  29
  30 //===----------------------------------------------------------------------===//
  31 // Primary Expressions.
  32 //===----------------------------------------------------------------------===//
  33
  34 void ExplicitTemplateArgumentList::initializeFrom(
  35                                       const TemplateArgumentListInfo &Info) {
  36   LAngleLoc = Info.getLAngleLoc();
  37   RAngleLoc = Info.getRAngleLoc();
  38   NumTemplateArgs = Info.size();
  39
  40   TemplateArgumentLoc *ArgBuffer = getTemplateArgs();
  41   for (unsigned i = 0; i != NumTemplateArgs; ++i)
  42     new (&ArgBuffer[i]) TemplateArgumentLoc(Info[i]);
  43 }
  44
  45 void ExplicitTemplateArgumentList::copyInto(
  46                                       TemplateArgumentListInfo &Info) const {
  47   Info.setLAngleLoc(LAngleLoc);
  48   Info.setRAngleLoc(RAngleLoc);
  49   for (unsigned I = 0; I != NumTemplateArgs; ++I)
  50     Info.addArgument(getTemplateArgs()[I]);
  51 }
  52
  53 std::size_t ExplicitTemplateArgumentList::sizeFor(
  54                                       const TemplateArgumentListInfo &Info) {
  55   return sizeof(ExplicitTemplateArgumentList) +
  56          sizeof(TemplateArgumentLoc) * Info.size();
  57 }
  58
  59 void DeclRefExpr::computeDependence() {
  60   TypeDependent = false;
  61   ValueDependent = false;
  62
  63   NamedDecl *D = getDecl();
  64
  65   // (TD) C++ [temp.dep.expr]p3:
  66   //   An id-expression is type-dependent if it contains:
  67   //
  68   // and
  69   //
  70   // (VD) C++ [temp.dep.constexpr]p2:
  71   //  An identifier is value-dependent if it is:
  72
  73   //  (TD)  - an identifier that was declared with dependent type
  74   //  (VD)  - a name declared with a dependent type,
  75   if (getType()->isDependentType()) {
  76     TypeDependent = true;
  77     ValueDependent = true;
  78   }
  79   //  (TD)  - a conversion-function-id that specifies a dependent type
  80   else if (D->getDeclName().getNameKind()
  81                                == DeclarationName::CXXConversionFunctionName &&
  82            D->getDeclName().getCXXNameType()->isDependentType()) {
  83     TypeDependent = true;
  84     ValueDependent = true;
  85   }
  86   //  (TD)  - a template-id that is dependent,
  87   else if (hasExplicitTemplateArgumentList() &&
  88            TemplateSpecializationType::anyDependentTemplateArguments(
  89                                                        getTemplateArgs(),
  90                                                        getNumTemplateArgs())) {
  91     TypeDependent = true;
  92     ValueDependent = true;
  93   }
  94   //  (VD)  - the name of a non-type template parameter,
  95   else if (isa<NonTypeTemplateParmDecl>(D))
  96     ValueDependent = true;
  97   //  (VD) - a constant with integral or enumeration type and is
  98   //         initialized with an expression that is value-dependent.
  99   else if (VarDecl *Var = dyn_cast<VarDecl>(D)) {
 100     if (Var->getType()->isIntegralType() &&
 101         Var->getType().getCVRQualifiers() == Qualifiers::Const) {
 102       if (const Expr *Init = Var->getAnyInitializer())
 103         if (Init->isValueDependent())
 104           ValueDependent = true;
 105     }
 106   }
 107   //  (TD)  - a nested-name-specifier or a qualified-id that names a
 108   //          member of an unknown specialization.
 109   //        (handled by DependentScopeDeclRefExpr)
 110 }
 111
 112 DeclRefExpr::DeclRefExpr(NestedNameSpecifier *Qualifier,
 113                          SourceRange QualifierRange,
 114                          ValueDecl *D, SourceLocation NameLoc,
 115                          const TemplateArgumentListInfo *TemplateArgs,
 116                          QualType T)
 117   : Expr(DeclRefExprClass, T, false, false),
 118     DecoratedD(D,
 119                (Qualifier? HasQualifierFlag : 0) |
 120                (TemplateArgs ? HasExplicitTemplateArgumentListFlag : 0)),
 121     Loc(NameLoc) {
 122   if (Qualifier) {
 123     NameQualifier *NQ = getNameQualifier();
 124     NQ->NNS = Qualifier;
 125     NQ->Range = QualifierRange;
 126   }
 127
 128   if (TemplateArgs)
 129     getExplicitTemplateArgumentList()->initializeFrom(*TemplateArgs);
 130
 131   computeDependence();
 132 }
 133
 134 DeclRefExpr *DeclRefExpr::Create(ASTContext &Context,
 135                                  NestedNameSpecifier *Qualifier,
 136                                  SourceRange QualifierRange,
 137                                  ValueDecl *D,
 138                                  SourceLocation NameLoc,
 139                                  QualType T,
 140                                  const TemplateArgumentListInfo *TemplateArgs) {
 141   std::size_t Size = sizeof(DeclRefExpr);
 142   if (Qualifier != 0)
 143     Size += sizeof(NameQualifier);
 144
 145   if (TemplateArgs)
 146     Size += ExplicitTemplateArgumentList::sizeFor(*TemplateArgs);
 147
 148   void *Mem = Context.Allocate(Size, llvm::alignof<DeclRefExpr>());
 149   return new (Mem) DeclRefExpr(Qualifier, QualifierRange, D, NameLoc,
 150                                TemplateArgs, T);
 151 }
 152
 153 SourceRange DeclRefExpr::getSourceRange() const {
 154   // FIXME: Does not handle multi-token names well, e.g., operator[].
 155   SourceRange R(Loc);
 156
 157   if (hasQualifier())
 158     R.setBegin(getQualifierRange().getBegin());
 159   if (hasExplicitTemplateArgumentList())
 160     R.setEnd(getRAngleLoc());
 161   return R;
 162 }
 163
 164 // FIXME: Maybe this should use DeclPrinter with a special "print predefined
 165 // expr" policy instead.
 166 std::string PredefinedExpr::ComputeName(IdentType IT, const Decl *CurrentDecl) {
 167   ASTContext &Context = CurrentDecl->getASTContext();
 168
 169   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
 170     if (IT != PrettyFunction && IT != PrettyFunctionNoVirtual)
 171       return FD->getNameAsString();
 172
 173     llvm::SmallString<256> Name;
 174     llvm::raw_svector_ostream Out(Name);
 175
 176     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
 177       if (MD->isVirtual() && IT != PrettyFunctionNoVirtual)
 178         Out << "virtual ";
 179       if (MD->isStatic())
 180         Out << "static ";
 181     }
 182
 183     PrintingPolicy Policy(Context.getLangOptions());
 184
 185     std::string Proto = FD->getQualifiedNameAsString(Policy);
 186
 187     const FunctionType *AFT = FD->getType()->getAs<FunctionType>();
 188     const FunctionProtoType *FT = 0;
 189     if (FD->hasWrittenPrototype())
 190       FT = dyn_cast<FunctionProtoType>(AFT);
 191
 192     Proto += "(";
 193     if (FT) {
 194       llvm::raw_string_ostream POut(Proto);
 195       for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
 196         if (i) POut << ", ";
 197         std::string Param;
 198         FD->getParamDecl(i)->getType().getAsStringInternal(Param, Policy);
 199         POut << Param;
 200       }
 201
 202       if (FT->isVariadic()) {
 203         if (FD->getNumParams()) POut << ", ";
 204         POut << "...";
 205       }
 206     }
 207     Proto += ")";
 208
 209     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
 210       Qualifiers ThisQuals = Qualifiers::fromCVRMask(MD->getTypeQualifiers());
 211       if (ThisQuals.hasConst())
 212         Proto += " const";
 213       if (ThisQuals.hasVolatile())
 214         Proto += " volatile";
 215     }
 216
 217     if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
 218       AFT->getResultType().getAsStringInternal(Proto, Policy);
 219
 220     Out << Proto;
 221
 222     Out.flush();
 223     return Name.str().str();
 224   }
 225   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
 226     llvm::SmallString<256> Name;
 227     llvm::raw_svector_ostream Out(Name);
 228     Out << (MD->isInstanceMethod() ? '-' : '+');
 229     Out << '[';
 230
 231     // For incorrect code, there might not be an ObjCInterfaceDecl.  Do
 232     // a null check to avoid a crash.
 233     if (const ObjCInterfaceDecl *ID = MD->getClassInterface())
 234       Out << ID->getNameAsString();
 235
 236     if (const ObjCCategoryImplDecl *CID =
 237         dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext())) {
 238       Out << '(';
 239       Out <<  CID->getNameAsString();
 240       Out <<  ')';
 241     }
 242     Out <<  ' ';
 243     Out << MD->getSelector().getAsString();
 244     Out <<  ']';
 245
 246     Out.flush();
 247     return Name.str().str();
 248   }
 249   if (isa<TranslationUnitDecl>(CurrentDecl) && IT == PrettyFunction) {
 250     // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string.
 251     return "top level";
 252   }
 253   return "";
 254 }
 255
 256 /// getValueAsApproximateDouble - This returns the value as an inaccurate
 257 /// double.  Note that this may cause loss of precision, but is useful for
 258 /// debugging dumps, etc.
 259 double FloatingLiteral::getValueAsApproximateDouble() const {
 260   llvm::APFloat V = getValue();
 261   bool ignored;
 262   V.convert(llvm::APFloat::IEEEdouble, llvm::APFloat::rmNearestTiesToEven,
 263             &ignored);
 264   return V.convertToDouble();
 265 }
 266
 267 StringLiteral *StringLiteral::Create(ASTContext &C, const char *StrData,
 268                                      unsigned ByteLength, bool Wide,
 269                                      QualType Ty,
 270                                      const SourceLocation *Loc,
 271                                      unsigned NumStrs) {
 272   // Allocate enough space for the StringLiteral plus an array of locations for
 273   // any concatenated string tokens.
 274   void *Mem = C.Allocate(sizeof(StringLiteral)+
 275                          sizeof(SourceLocation)*(NumStrs-1),
 276                          llvm::alignof<StringLiteral>());
 277   StringLiteral *SL = new (Mem) StringLiteral(Ty);
 278
 279   // OPTIMIZE: could allocate this appended to the StringLiteral.
 280   char *AStrData = new (C, 1) char[ByteLength];
 281   memcpy(AStrData, StrData, ByteLength);
 282   SL->StrData = AStrData;
 283   SL->ByteLength = ByteLength;
 284   SL->IsWide = Wide;
 285   SL->TokLocs[0] = Loc[0];
 286   SL->NumConcatenated = NumStrs;
 287
 288   if (NumStrs != 1)
 289     memcpy(&SL->TokLocs[1], Loc+1, sizeof(SourceLocation)*(NumStrs-1));
 290   return SL;
 291 }
 292
 293 StringLiteral *StringLiteral::CreateEmpty(ASTContext &C, unsigned NumStrs) {
 294   void *Mem = C.Allocate(sizeof(StringLiteral)+
 295                          sizeof(SourceLocation)*(NumStrs-1),
 296                          llvm::alignof<StringLiteral>());
 297   StringLiteral *SL = new (Mem) StringLiteral(QualType());
 298   SL->StrData = 0;
 299   SL->ByteLength = 0;
 300   SL->NumConcatenated = NumStrs;
 301   return SL;
 302 }
 303
 304 void StringLiteral::DoDestroy(ASTContext &C) {
 305   C.Deallocate(const_cast<char*>(StrData));
 306   Expr::DoDestroy(C);
 307 }
 308
 309 void StringLiteral::setString(ASTContext &C, llvm::StringRef Str) {
 310   if (StrData)
 311     C.Deallocate(const_cast<char*>(StrData));
 312
 313   char *AStrData = new (C, 1) char[Str.size()];
 314   memcpy(AStrData, Str.data(), Str.size());
 315   StrData = AStrData;
 316   ByteLength = Str.size();
 317 }
 318
 319 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
 320 /// corresponds to, e.g. "sizeof" or "[pre]++".
 321 const char *UnaryOperator::getOpcodeStr(Opcode Op) {
 322   switch (Op) {
 323   default: assert(0 && "Unknown unary operator");
 324   case PostInc: return "++";
 325   case PostDec: return "--";
 326   case PreInc:  return "++";
 327   case PreDec:  return "--";
 328   case AddrOf:  return "&";
 329   case Deref:   return "*";
 330   case Plus:    return "+";
 331   case Minus:   return "-";
 332   case Not:     return "~";
 333   case LNot:    return "!";
 334   case Real:    return "__real";
 335   case Imag:    return "__imag";
 336   case Extension: return "__extension__";
 337   case OffsetOf: return "__builtin_offsetof";
 338   }
 339 }
 340
 341 UnaryOperator::Opcode
 342 UnaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix) {
 343   switch (OO) {
 344   default: assert(false && "No unary operator for overloaded function");
 345   case OO_PlusPlus:   return Postfix ? PostInc : PreInc;
 346   case OO_MinusMinus: return Postfix ? PostDec : PreDec;
 347   case OO_Amp:        return AddrOf;
 348   case OO_Star:       return Deref;
 349   case OO_Plus:       return Plus;
 350   case OO_Minus:      return Minus;
 351   case OO_Tilde:      return Not;
 352   case OO_Exclaim:    return LNot;
 353   }
 354 }
 355
 356 OverloadedOperatorKind UnaryOperator::getOverloadedOperator(Opcode Opc) {
 357   switch (Opc) {
 358   case PostInc: case PreInc: return OO_PlusPlus;
 359   case PostDec: case PreDec: return OO_MinusMinus;
 360   case AddrOf: return OO_Amp;
 361   case Deref: return OO_Star;
 362   case Plus: return OO_Plus;
 363   case Minus: return OO_Minus;
 364   case Not: return OO_Tilde;
 365   case LNot: return OO_Exclaim;
 366   default: return OO_None;
 367   }
 368 }
 369
 370
 371 //===----------------------------------------------------------------------===//
 372 // Postfix Operators.
 373 //===----------------------------------------------------------------------===//
 374
 375 CallExpr::CallExpr(ASTContext& C, StmtClass SC, Expr *fn, Expr **args,
 376                    unsigned numargs, QualType t, SourceLocation rparenloc)
 377   : Expr(SC, t,
 378          fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
 379          fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
 380     NumArgs(numargs) {
 381
 382   SubExprs = new (C) Stmt*[numargs+1];
 383   SubExprs[FN] = fn;
 384   for (unsigned i = 0; i != numargs; ++i)
 385     SubExprs[i+ARGS_START] = args[i];
 386
 387   RParenLoc = rparenloc;
 388 }
 389
 390 CallExpr::CallExpr(ASTContext& C, Expr *fn, Expr **args, unsigned numargs,
 391                    QualType t, SourceLocation rparenloc)
 392   : Expr(CallExprClass, t,
 393          fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
 394          fn->isValueDependent() || hasAnyValueDependentArguments(args,numargs)),
 395     NumArgs(numargs) {
 396
 397   SubExprs = new (C) Stmt*[numargs+1];
 398   SubExprs[FN] = fn;
 399   for (unsigned i = 0; i != numargs; ++i)
 400     SubExprs[i+ARGS_START] = args[i];
 401
 402   RParenLoc = rparenloc;
 403 }
 404
 405 CallExpr::CallExpr(ASTContext &C, StmtClass SC, EmptyShell Empty)
 406   : Expr(SC, Empty), SubExprs(0), NumArgs(0) {
 407   SubExprs = new (C) Stmt*[1];
 408 }
 409
 410 void CallExpr::DoDestroy(ASTContext& C) {
 411   DestroyChildren(C);
 412   if (SubExprs) C.Deallocate(SubExprs);
 413   this->~CallExpr();
 414   C.Deallocate(this);
 415 }
 416
 417 Decl *CallExpr::getCalleeDecl() {
 418   Expr *CEE = getCallee()->IgnoreParenCasts();
 419   if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
 420     return DRE->getDecl();
 421   if (MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
 422     return ME->getMemberDecl();
 423
 424   return 0;
 425 }
 426
 427 FunctionDecl *CallExpr::getDirectCallee() {
 428   return dyn_cast_or_null<FunctionDecl>(getCalleeDecl());
 429 }
 430
 431 /// setNumArgs - This changes the number of arguments present in this call.
 432 /// Any orphaned expressions are deleted by this, and any new operands are set
 433 /// to null.
 434 void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
 435   // No change, just return.
 436   if (NumArgs == getNumArgs()) return;
 437
 438   // If shrinking # arguments, just delete the extras and forgot them.
 439   if (NumArgs < getNumArgs()) {
 440     for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i)
 441       getArg(i)->Destroy(C);
 442     this->NumArgs = NumArgs;
 443     return;
 444   }
 445
 446   // Otherwise, we are growing the # arguments.  New an bigger argument array.
 447   Stmt **NewSubExprs = new (C) Stmt*[NumArgs+1];
 448   // Copy over args.
 449   for (unsigned i = 0; i != getNumArgs()+ARGS_START; ++i)
 450     NewSubExprs[i] = SubExprs[i];
 451   // Null out new args.
 452   for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
 453     NewSubExprs[i] = 0;
 454
 455   if (SubExprs) C.Deallocate(SubExprs);
 456   SubExprs = NewSubExprs;
 457   this->NumArgs = NumArgs;
 458 }
 459
 460 /// isBuiltinCall - If this is a call to a builtin, return the builtin ID.  If
 461 /// not, return 0.
 462 unsigned CallExpr::isBuiltinCall(ASTContext &Context) const {
 463   // All simple function calls (e.g. func()) are implicitly cast to pointer to
 464   // function. As a result, we try and obtain the DeclRefExpr from the
 465   // ImplicitCastExpr.
 466   const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(getCallee());
 467   if (!ICE) // FIXME: deal with more complex calls (e.g. (func)(), (*func)()).
 468     return 0;
 469
 470   const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr());
 471   if (!DRE)
 472     return 0;
 473
 474   const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl());
 475   if (!FDecl)
 476     return 0;
 477
 478   if (!FDecl->getIdentifier())
 479     return 0;
 480
 481   return FDecl->getBuiltinID();
 482 }
 483
 484 QualType CallExpr::getCallReturnType() const {
 485   QualType CalleeType = getCallee()->getType();
 486   if (const PointerType *FnTypePtr = CalleeType->getAs<PointerType>())
 487     CalleeType = FnTypePtr->getPointeeType();
 488   else if (const BlockPointerType *BPT = CalleeType->getAs<BlockPointerType>())
 489     CalleeType = BPT->getPointeeType();
 490
 491   const FunctionType *FnType = CalleeType->getAs<FunctionType>();
 492   return FnType->getResultType();
 493 }
 494
 495 MemberExpr *MemberExpr::Create(ASTContext &C, Expr *base, bool isarrow,
 496                                NestedNameSpecifier *qual,
 497                                SourceRange qualrange,
 498                                ValueDecl *memberdecl,
 499                                NamedDecl *founddecl,
 500                                SourceLocation l,
 501                                const TemplateArgumentListInfo *targs,
 502                                QualType ty) {
 503   std::size_t Size = sizeof(MemberExpr);
 504
 505   bool hasQualOrFound = (qual != 0 || founddecl != memberdecl);
 506   if (hasQualOrFound)
 507     Size += sizeof(MemberNameQualifier);
 508
 509   if (targs)
 510     Size += ExplicitTemplateArgumentList::sizeFor(*targs);
 511
 512   void *Mem = C.Allocate(Size, llvm::alignof<MemberExpr>());
 513   MemberExpr *E = new (Mem) MemberExpr(base, isarrow, memberdecl, l, ty);
 514
 515   if (hasQualOrFound) {
 516     if (qual && qual->isDependent()) {
 517       E->setValueDependent(true);
 518       E->setTypeDependent(true);
 519     }
 520     E->HasQualifierOrFoundDecl = true;
 521
 522     MemberNameQualifier *NQ = E->getMemberQualifier();
 523     NQ->NNS = qual;
 524     NQ->Range = qualrange;
 525     NQ->FoundDecl = founddecl;
 526   }
 527
 528   if (targs) {
 529     E->HasExplicitTemplateArgumentList = true;
 530     E->getExplicitTemplateArgumentList()->initializeFrom(*targs);
 531   }
 532
 533   return E;
 534 }
 535
 536 const char *CastExpr::getCastKindName() const {
 537   switch (getCastKind()) {
 538   case CastExpr::CK_Unknown:
 539     return "Unknown";
 540   case CastExpr::CK_BitCast:
 541     return "BitCast";
 542   case CastExpr::CK_NoOp:
 543     return "NoOp";
 544   case CastExpr::CK_BaseToDerived:
 545     return "BaseToDerived";
 546   case CastExpr::CK_DerivedToBase:
 547     return "DerivedToBase";
 548   case CastExpr::CK_UncheckedDerivedToBase:
 549     return "UncheckedDerivedToBase";
 550   case CastExpr::CK_Dynamic:
 551     return "Dynamic";
 552   case CastExpr::CK_ToUnion:
 553     return "ToUnion";
 554   case CastExpr::CK_ArrayToPointerDecay:
 555     return "ArrayToPointerDecay";
 556   case CastExpr::CK_FunctionToPointerDecay:
 557     return "FunctionToPointerDecay";
 558   case CastExpr::CK_NullToMemberPointer:
 559     return "NullToMemberPointer";
 560   case CastExpr::CK_BaseToDerivedMemberPointer:
 561     return "BaseToDerivedMemberPointer";
 562   case CastExpr::CK_DerivedToBaseMemberPointer:
 563     return "DerivedToBaseMemberPointer";
 564   case CastExpr::CK_UserDefinedConversion:
 565     return "UserDefinedConversion";
 566   case CastExpr::CK_ConstructorConversion:
 567     return "ConstructorConversion";
 568   case CastExpr::CK_IntegralToPointer:
 569     return "IntegralToPointer";
 570   case CastExpr::CK_PointerToIntegral:
 571     return "PointerToIntegral";
 572   case CastExpr::CK_ToVoid:
 573     return "ToVoid";
 574   case CastExpr::CK_VectorSplat:
 575     return "VectorSplat";
 576   case CastExpr::CK_IntegralCast:
 577     return "IntegralCast";
 578   case CastExpr::CK_IntegralToFloating:
 579     return "IntegralToFloating";
 580   case CastExpr::CK_FloatingToIntegral:
 581     return "FloatingToIntegral";
 582   case CastExpr::CK_FloatingCast:
 583     return "FloatingCast";
 584   case CastExpr::CK_MemberPointerToBoolean:
 585     return "MemberPointerToBoolean";
 586   case CastExpr::CK_AnyPointerToObjCPointerCast:
 587     return "AnyPointerToObjCPointerCast";
 588   case CastExpr::CK_AnyPointerToBlockPointerCast:
 589     return "AnyPointerToBlockPointerCast";
 590   }
 591
 592   assert(0 && "Unhandled cast kind!");
 593   return 0;
 594 }
 595
 596 Expr *CastExpr::getSubExprAsWritten() {
 597   Expr *SubExpr = 0;
 598   CastExpr *E = this;
 599   do {
 600     SubExpr = E->getSubExpr();
 601
 602     // Skip any temporary bindings; they're implicit.
 603     if (CXXBindTemporaryExpr *Binder = dyn_cast<CXXBindTemporaryExpr>(SubExpr))
 604       SubExpr = Binder->getSubExpr();
 605
 606     // Conversions by constructor and conversion functions have a
 607     // subexpression describing the call; strip it off.
 608     if (E->getCastKind() == CastExpr::CK_ConstructorConversion)
 609       SubExpr = cast<CXXConstructExpr>(SubExpr)->getArg(0);
 610     else if (E->getCastKind() == CastExpr::CK_UserDefinedConversion)
 611       SubExpr = cast<CXXMemberCallExpr>(SubExpr)->getImplicitObjectArgument();
 612
 613     // If the subexpression we're left with is an implicit cast, look
 614     // through that, too.
 615   } while ((E = dyn_cast<ImplicitCastExpr>(SubExpr)));
 616
 617   return SubExpr;
 618 }
 619
 620 /// getOpcodeStr - Turn an Opcode enum value into the punctuation char it
 621 /// corresponds to, e.g. "<<=".
 622 const char *BinaryOperator::getOpcodeStr(Opcode Op) {
 623   switch (Op) {
 624   case PtrMemD:   return ".*";
 625   case PtrMemI:   return "->*";
 626   case Mul:       return "*";
 627   case Div:       return "/";
 628   case Rem:       return "%";
 629   case Add:       return "+";
 630   case Sub:       return "-";
 631   case Shl:       return "<<";
 632   case Shr:       return ">>";
 633   case LT:        return "<";
 634   case GT:        return ">";
 635   case LE:        return "<=";
 636   case GE:        return ">=";
 637   case EQ:        return "==";
 638   case NE:        return "!=";
 639   case And:       return "&";
 640   case Xor:       return "^";
 641   case Or:        return "|";
 642   case LAnd:      return "&&";
 643   case LOr:       return "||";
 644   case Assign:    return "=";
 645   case MulAssign: return "*=";
 646   case DivAssign: return "/=";
 647   case RemAssign: return "%=";
 648   case AddAssign: return "+=";
 649   case SubAssign: return "-=";
 650   case ShlAssign: return "<<=";
 651   case ShrAssign: return ">>=";
 652   case AndAssign: return "&=";
 653   case XorAssign: return "^=";
 654   case OrAssign:  return "|=";
 655   case Comma:     return ",";
 656   }
 657
 658   return "";
 659 }
 660
 661 BinaryOperator::Opcode
 662 BinaryOperator::getOverloadedOpcode(OverloadedOperatorKind OO) {
 663   switch (OO) {
 664   default: assert(false && "Not an overloadable binary operator");
 665   case OO_Plus: return Add;
 666   case OO_Minus: return Sub;
 667   case OO_Star: return Mul;
 668   case OO_Slash: return Div;
 669   case OO_Percent: return Rem;
 670   case OO_Caret: return Xor;
 671   case OO_Amp: return And;
 672   case OO_Pipe: return Or;
 673   case OO_Equal: return Assign;
 674   case OO_Less: return LT;
 675   case OO_Greater: return GT;
 676   case OO_PlusEqual: return AddAssign;
 677   case OO_MinusEqual: return SubAssign;
 678   case OO_StarEqual: return MulAssign;
 679   case OO_SlashEqual: return DivAssign;
 680   case OO_PercentEqual: return RemAssign;
 681   case OO_CaretEqual: return XorAssign;
 682   case OO_AmpEqual: return AndAssign;
 683   case OO_PipeEqual: return OrAssign;
 684   case OO_LessLess: return Shl;
 685   case OO_GreaterGreater: return Shr;
 686   case OO_LessLessEqual: return ShlAssign;
 687   case OO_GreaterGreaterEqual: return ShrAssign;
 688   case OO_EqualEqual: return EQ;
 689   case OO_ExclaimEqual: return NE;
 690   case OO_LessEqual: return LE;
 691   case OO_GreaterEqual: return GE;
 692   case OO_AmpAmp: return LAnd;
 693   case OO_PipePipe: return LOr;
 694   case OO_Comma: return Comma;
 695   case OO_ArrowStar: return PtrMemI;
 696   }
 697 }
 698
 699 OverloadedOperatorKind BinaryOperator::getOverloadedOperator(Opcode Opc) {
 700   static const OverloadedOperatorKind OverOps[] = {
 701     /* .* Cannot be overloaded */OO_None, OO_ArrowStar,
 702     OO_Star, OO_Slash, OO_Percent,
 703     OO_Plus, OO_Minus,
 704     OO_LessLess, OO_GreaterGreater,
 705     OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
 706     OO_EqualEqual, OO_ExclaimEqual,
 707     OO_Amp,
 708     OO_Caret,
 709     OO_Pipe,
 710     OO_AmpAmp,
 711     OO_PipePipe,
 712     OO_Equal, OO_StarEqual,
 713     OO_SlashEqual, OO_PercentEqual,
 714     OO_PlusEqual, OO_MinusEqual,
 715     OO_LessLessEqual, OO_GreaterGreaterEqual,
 716     OO_AmpEqual, OO_CaretEqual,
 717     OO_PipeEqual,
 718     OO_Comma
 719   };
 720   return OverOps[Opc];
 721 }
 722
 723 InitListExpr::InitListExpr(SourceLocation lbraceloc,
 724                            Expr **initExprs, unsigned numInits,
 725                            SourceLocation rbraceloc)
 726   : Expr(InitListExprClass, QualType(), false, false),
 727     LBraceLoc(lbraceloc), RBraceLoc(rbraceloc), SyntacticForm(0),
 728     UnionFieldInit(0), HadArrayRangeDesignator(false)
 729 {
 730   for (unsigned I = 0; I != numInits; ++I) {
 731     if (initExprs[I]->isTypeDependent())
 732       TypeDependent = true;
 733     if (initExprs[I]->isValueDependent())
 734       ValueDependent = true;
 735   }
 736
 737   InitExprs.insert(InitExprs.end(), initExprs, initExprs+numInits);
 738 }
 739
 740 void InitListExpr::reserveInits(unsigned NumInits) {
 741   if (NumInits > InitExprs.size())
 742     InitExprs.reserve(NumInits);
 743 }
 744
 745 void InitListExpr::resizeInits(ASTContext &Context, unsigned NumInits) {
 746   for (unsigned Idx = NumInits, LastIdx = InitExprs.size();
 747        Idx < LastIdx; ++Idx)
 748     InitExprs[Idx]->Destroy(Context);
 749   InitExprs.resize(NumInits, 0);
 750 }
 751
 752 Expr *InitListExpr::updateInit(unsigned Init, Expr *expr) {
 753   if (Init >= InitExprs.size()) {
 754     InitExprs.insert(InitExprs.end(), Init - InitExprs.size() + 1, 0);
 755     InitExprs.back() = expr;
 756     return 0;
 757   }
 758
 759   Expr *Result = cast_or_null<Expr>(InitExprs[Init]);
 760   InitExprs[Init] = expr;
 761   return Result;
 762 }
 763
 764 /// getFunctionType - Return the underlying function type for this block.
 765 ///
 766 const FunctionType *BlockExpr::getFunctionType() const {
 767   return getType()->getAs<BlockPointerType>()->
 768                     getPointeeType()->getAs<FunctionType>();
 769 }
 770
 771 SourceLocation BlockExpr::getCaretLocation() const {
 772   return TheBlock->getCaretLocation();
 773 }
 774 const Stmt *BlockExpr::getBody() const {
 775   return TheBlock->getBody();
 776 }
 777 Stmt *BlockExpr::getBody() {
 778   return TheBlock->getBody();
 779 }
 780
 781
 782 //===----------------------------------------------------------------------===//
 783 // Generic Expression Routines
 784 //===----------------------------------------------------------------------===//
 785
 786 /// isUnusedResultAWarning - Return true if this immediate expression should
 787 /// be warned about if the result is unused.  If so, fill in Loc and Ranges
 788 /// with location to warn on and the source range[s] to report with the
 789 /// warning.
 790 bool Expr::isUnusedResultAWarning(SourceLocation &Loc, SourceRange &R1,
 791                                   SourceRange &R2, ASTContext &Ctx) const {
 792   // Don't warn if the expr is type dependent. The type could end up
 793   // instantiating to void.
 794   if (isTypeDependent())
 795     return false;
 796
 797   switch (getStmtClass()) {
 798   default:
 799     if (getType()->isVoidType())
 800       return false;
 801     Loc = getExprLoc();
 802     R1 = getSourceRange();
 803     return true;
 804   case ParenExprClass:
 805     return cast<ParenExpr>(this)->getSubExpr()->
 806       isUnusedResultAWarning(Loc, R1, R2, Ctx);
 807   case UnaryOperatorClass: {
 808     const UnaryOperator *UO = cast<UnaryOperator>(this);
 809
 810     switch (UO->getOpcode()) {
 811     default: break;
 812     case UnaryOperator::PostInc:
 813     case UnaryOperator::PostDec:
 814     case UnaryOperator::PreInc:
 815     case UnaryOperator::PreDec:                 // ++/--
 816       return false;  // Not a warning.
 817     case UnaryOperator::Deref:
 818       // Dereferencing a volatile pointer is a side-effect.
 819       if (Ctx.getCanonicalType(getType()).isVolatileQualified())
 820         return false;
 821       break;
 822     case UnaryOperator::Real:
 823     case UnaryOperator::Imag:
 824       // accessing a piece of a volatile complex is a side-effect.
 825       if (Ctx.getCanonicalType(UO->getSubExpr()->getType())
 826           .isVolatileQualified())
 827         return false;
 828       break;
 829     case UnaryOperator::Extension:
 830       return UO->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
 831     }
 832     Loc = UO->getOperatorLoc();
 833     R1 = UO->getSubExpr()->getSourceRange();
 834     return true;
 835   }
 836   case BinaryOperatorClass: {
 837     const BinaryOperator *BO = cast<BinaryOperator>(this);
 838     // Consider comma to have side effects if the LHS or RHS does.
 839     if (BO->getOpcode() == BinaryOperator::Comma) {
 840       // ((foo = <blah>), 0) is an idiom for hiding the result (and
 841       // lvalue-ness) of an assignment written in a macro.
 842       if (IntegerLiteral *IE =
 843             dyn_cast<IntegerLiteral>(BO->getRHS()->IgnoreParens()))
 844         if (IE->getValue() == 0)
 845           return false;
 846
 847       return (BO->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx) ||
 848               BO->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
 849     }
 850
 851     if (BO->isAssignmentOp())
 852       return false;
 853     Loc = BO->getOperatorLoc();
 854     R1 = BO->getLHS()->getSourceRange();
 855     R2 = BO->getRHS()->getSourceRange();
 856     return true;
 857   }
 858   case CompoundAssignOperatorClass:
 859     return false;
 860
 861   case ConditionalOperatorClass: {
 862     // The condition must be evaluated, but if either the LHS or RHS is a
 863     // warning, warn about them.
 864     const ConditionalOperator *Exp = cast<ConditionalOperator>(this);
 865     if (Exp->getLHS() &&
 866         Exp->getLHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx))
 867       return true;
 868     return Exp->getRHS()->isUnusedResultAWarning(Loc, R1, R2, Ctx);
 869   }
 870
 871   case MemberExprClass:
 872     // If the base pointer or element is to a volatile pointer/field, accessing
 873     // it is a side effect.
 874     if (Ctx.getCanonicalType(getType()).isVolatileQualified())
 875       return false;
 876     Loc = cast<MemberExpr>(this)->getMemberLoc();
 877     R1 = SourceRange(Loc, Loc);
 878     R2 = cast<MemberExpr>(this)->getBase()->getSourceRange();
 879     return true;
 880
 881   case ArraySubscriptExprClass:
 882     // If the base pointer or element is to a volatile pointer/field, accessing
 883     // it is a side effect.
 884     if (Ctx.getCanonicalType(getType()).isVolatileQualified())
 885       return false;
 886     Loc = cast<ArraySubscriptExpr>(this)->getRBracketLoc();
 887     R1 = cast<ArraySubscriptExpr>(this)->getLHS()->getSourceRange();
 888     R2 = cast<ArraySubscriptExpr>(this)->getRHS()->getSourceRange();
 889     return true;
 890
 891   case CallExprClass:
 892   case CXXOperatorCallExprClass:
 893   case CXXMemberCallExprClass: {
 894     // If this is a direct call, get the callee.
 895     const CallExpr *CE = cast<CallExpr>(this);
 896     if (const Decl *FD = CE->getCalleeDecl()) {
 897       // If the callee has attribute pure, const, or warn_unused_result, warn
 898       // about it. void foo() { strlen("bar"); } should warn.
 899       //
 900       // Note: If new cases are added here, DiagnoseUnusedExprResult should be
 901       // updated to match for QoI.
 902       if (FD->getAttr<WarnUnusedResultAttr>() ||
 903           FD->getAttr<PureAttr>() || FD->getAttr<ConstAttr>()) {
 904         Loc = CE->getCallee()->getLocStart();
 905         R1 = CE->getCallee()->getSourceRange();
 906
 907         if (unsigned NumArgs = CE->getNumArgs())
 908           R2 = SourceRange(CE->getArg(0)->getLocStart(),
 909                            CE->getArg(NumArgs-1)->getLocEnd());
 910         return true;
 911       }
 912     }
 913     return false;
 914   }
 915
 916   case CXXTemporaryObjectExprClass:
 917   case CXXConstructExprClass:
 918     return false;
 919
 920   case ObjCMessageExprClass: {
 921     const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
 922     const ObjCMethodDecl *MD = ME->getMethodDecl();
 923     if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
 924       Loc = getExprLoc();
 925       return true;
 926     }
 927     return false;
 928   }
 929
 930   case ObjCImplicitSetterGetterRefExprClass: {   // Dot syntax for message send.
 931 #if 0
 932     const ObjCImplicitSetterGetterRefExpr *Ref =
 933       cast<ObjCImplicitSetterGetterRefExpr>(this);
 934     // FIXME: We really want the location of the '.' here.
 935     Loc = Ref->getLocation();
 936     R1 = SourceRange(Ref->getLocation(), Ref->getLocation());
 937     if (Ref->getBase())
 938       R2 = Ref->getBase()->getSourceRange();
 939 #else
 940     Loc = getExprLoc();
 941     R1 = getSourceRange();
 942 #endif
 943     return true;
 944   }
 945   case StmtExprClass: {
 946     // Statement exprs don't logically have side effects themselves, but are
 947     // sometimes used in macros in ways that give them a type that is unused.
 948     // For example ({ blah; foo(); }) will end up with a type if foo has a type.
 949     // however, if the result of the stmt expr is dead, we don't want to emit a
 950     // warning.
 951     const CompoundStmt *CS = cast<StmtExpr>(this)->getSubStmt();
 952     if (!CS->body_empty())
 953       if (const Expr *E = dyn_cast<Expr>(CS->body_back()))
 954         return E->isUnusedResultAWarning(Loc, R1, R2, Ctx);
 955
 956     if (getType()->isVoidType())
 957       return false;
 958     Loc = cast<StmtExpr>(this)->getLParenLoc();
 959     R1 = getSourceRange();
 960     return true;
 961   }
 962   case CStyleCastExprClass:
 963     // If this is an explicit cast to void, allow it.  People do this when they
 964     // think they know what they're doing :).
 965     if (getType()->isVoidType())
 966       return false;
 967     Loc = cast<CStyleCastExpr>(this)->getLParenLoc();
 968     R1 = cast<CStyleCastExpr>(this)->getSubExpr()->getSourceRange();
 969     return true;
 970   case CXXFunctionalCastExprClass: {
 971     if (getType()->isVoidType())
 972       return false;
 973     const CastExpr *CE = cast<CastExpr>(this);
 974
 975     // If this is a cast to void or a constructor conversion, check the operand.
 976     // Otherwise, the result of the cast is unused.
 977     if (CE->getCastKind() == CastExpr::CK_ToVoid ||
 978         CE->getCastKind() == CastExpr::CK_ConstructorConversion)
 979       return (cast<CastExpr>(this)->getSubExpr()
 980               ->isUnusedResultAWarning(Loc, R1, R2, Ctx));
 981     Loc = cast<CXXFunctionalCastExpr>(this)->getTypeBeginLoc();
 982     R1 = cast<CXXFunctionalCastExpr>(this)->getSubExpr()->getSourceRange();
 983     return true;
 984   }
 985
 986   case ImplicitCastExprClass:
 987     // Check the operand, since implicit casts are inserted by Sema
 988     return (cast<ImplicitCastExpr>(this)
 989             ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
 990
 991   case CXXDefaultArgExprClass:
 992     return (cast<CXXDefaultArgExpr>(this)
 993             ->getExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
 994
 995   case CXXNewExprClass:
 996     // FIXME: In theory, there might be new expressions that don't have side
 997     // effects (e.g. a placement new with an uninitialized POD).
 998   case CXXDeleteExprClass:
 999     return false;
1000   case CXXBindTemporaryExprClass:
1001     return (cast<CXXBindTemporaryExpr>(this)
1002             ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1003   case CXXExprWithTemporariesClass:
1004     return (cast<CXXExprWithTemporaries>(this)
1005             ->getSubExpr()->isUnusedResultAWarning(Loc, R1, R2, Ctx));
1006   }
1007 }
1008
1009 /// DeclCanBeLvalue - Determine whether the given declaration can be
1010 /// an lvalue. This is a helper routine for isLvalue.
1011 static bool DeclCanBeLvalue(const NamedDecl *Decl, ASTContext &Ctx) {
1012   // C++ [temp.param]p6:
1013   //   A non-type non-reference template-parameter is not an lvalue.
1014   if (const NonTypeTemplateParmDecl *NTTParm
1015         = dyn_cast<NonTypeTemplateParmDecl>(Decl))
1016     return NTTParm->getType()->isReferenceType();
1017
1018   return isa<VarDecl>(Decl) || isa<FieldDecl>(Decl) ||
1019     // C++ 3.10p2: An lvalue refers to an object or function.
1020     (Ctx.getLangOptions().CPlusPlus &&
1021      (isa<FunctionDecl>(Decl) || isa<FunctionTemplateDecl>(Decl)));
1022 }
1023
1024 /// isLvalue - C99 6.3.2.1: an lvalue is an expression with an object type or an
1025 /// incomplete type other than void. Nonarray expressions that can be lvalues:
1026 ///  - name, where name must be a variable
1027 ///  - e[i]
1028 ///  - (e), where e must be an lvalue
1029 ///  - e.name, where e must be an lvalue
1030 ///  - e->name
1031 ///  - *e, the type of e cannot be a function type
1032 ///  - string-constant
1033 ///  - (__real__ e) and (__imag__ e) where e is an lvalue  [GNU extension]
1034 ///  - reference type [C++ [expr]]
1035 ///
1036 Expr::isLvalueResult Expr::isLvalue(ASTContext &Ctx) const {
1037   assert(!TR->isReferenceType() && "Expressions can't have reference type.");
1038
1039   isLvalueResult Res = isLvalueInternal(Ctx);
1040   if (Res != LV_Valid || Ctx.getLangOptions().CPlusPlus)
1041     return Res;
1042
1043   // first, check the type (C99 6.3.2.1). Expressions with function
1044   // type in C are not lvalues, but they can be lvalues in C++.
1045   if (TR->isFunctionType() || TR == Ctx.OverloadTy)
1046     return LV_NotObjectType;
1047
1048   // Allow qualified void which is an incomplete type other than void (yuck).
1049   if (TR->isVoidType() && !Ctx.getCanonicalType(TR).hasQualifiers())
1050     return LV_IncompleteVoidType;
1051
1052   return LV_Valid;
1053 }
1054
1055 // Check whether the expression can be sanely treated like an l-value
1056 Expr::isLvalueResult Expr::isLvalueInternal(ASTContext &Ctx) const {
1057   switch (getStmtClass()) {
1058   case ObjCIsaExprClass:
1059   case StringLiteralClass:  // C99 6.5.1p4
1060   case ObjCEncodeExprClass: // @encode behaves like its string in every way.
1061     return LV_Valid;
1062   case ArraySubscriptExprClass: // C99 6.5.3p4 (e1[e2] == (*((e1)+(e2))))
1063     // For vectors, make sure base is an lvalue (i.e. not a function call).
1064     if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
1065       return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue(Ctx);
1066     return LV_Valid;
1067   case DeclRefExprClass: { // C99 6.5.1p2
1068     const NamedDecl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
1069     if (DeclCanBeLvalue(RefdDecl, Ctx))
1070       return LV_Valid;
1071     break;
1072   }
1073   case BlockDeclRefExprClass: {
1074     const BlockDeclRefExpr *BDR = cast<BlockDeclRefExpr>(this);
1075     if (isa<VarDecl>(BDR->getDecl()))
1076       return LV_Valid;
1077     break;
1078   }
1079   case MemberExprClass: {
1080     const MemberExpr *m = cast<MemberExpr>(this);
1081     if (Ctx.getLangOptions().CPlusPlus) { // C++ [expr.ref]p4:
1082       NamedDecl *Member = m->getMemberDecl();
1083       // C++ [expr.ref]p4:
1084       //   If E2 is declared to have type "reference to T", then E1.E2
1085       //   is an lvalue.
1086       if (ValueDecl *Value = dyn_cast<ValueDecl>(Member))
1087         if (Value->getType()->isReferenceType())
1088           return LV_Valid;
1089
1090       //   -- If E2 is a static data member [...] then E1.E2 is an lvalue.
1091       if (isa<VarDecl>(Member) && Member->getDeclContext()->isRecord())
1092         return LV_Valid;
1093
1094       //   -- If E2 is a non-static data member [...]. If E1 is an
1095       //      lvalue, then E1.E2 is an lvalue.
1096       if (isa<FieldDecl>(Member)) {
1097         if (m->isArrow())
1098           return LV_Valid;
1099         return m->getBase()->isLvalue(Ctx);
1100       }
1101
1102       //   -- If it refers to a static member function [...], then
1103       //      E1.E2 is an lvalue.
1104       //   -- Otherwise, if E1.E2 refers to a non-static member
1105       //      function [...], then E1.E2 is not an lvalue.
1106       if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Member))
1107         return Method->isStatic()? LV_Valid : LV_MemberFunction;
1108
1109       //   -- If E2 is a member enumerator [...], the expression E1.E2
1110       //      is not an lvalue.
1111       if (isa<EnumConstantDecl>(Member))
1112         return LV_InvalidExpression;
1113
1114         // Not an lvalue.
1115       return LV_InvalidExpression;
1116     }
1117
1118     // C99 6.5.2.3p4
1119     if (m->isArrow())
1120       return LV_Valid;
1121     Expr *BaseExp = m->getBase();
1122     if (BaseExp->getStmtClass() == ObjCPropertyRefExprClass ||
1123         BaseExp->getStmtClass() == ObjCImplicitSetterGetterRefExprClass)
1124           return LV_SubObjCPropertySetting;
1125     return
1126        BaseExp->isLvalue(Ctx);
1127   }
1128   case UnaryOperatorClass:
1129     if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Deref)
1130       return LV_Valid; // C99 6.5.3p4
1131
1132     if (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Real ||
1133         cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Imag ||
1134         cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::Extension)
1135       return cast<UnaryOperator>(this)->getSubExpr()->isLvalue(Ctx);  // GNU.
1136
1137     if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.pre.incr]p1
1138         (cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreInc ||
1139          cast<UnaryOperator>(this)->getOpcode() == UnaryOperator::PreDec))
1140       return LV_Valid;
1141     break;
1142   case ImplicitCastExprClass:
1143     if (cast<ImplicitCastExpr>(this)->isLvalueCast())
1144       return LV_Valid;
1145
1146     // If this is a conversion to a class temporary, make a note of
1147     // that.
1148     if (Ctx.getLangOptions().CPlusPlus && getType()->isRecordType())
1149       return LV_ClassTemporary;
1150
1151     break;
1152   case ParenExprClass: // C99 6.5.1p5
1153     return cast<ParenExpr>(this)->getSubExpr()->isLvalue(Ctx);
1154   case BinaryOperatorClass:
1155   case CompoundAssignOperatorClass: {
1156     const BinaryOperator *BinOp = cast<BinaryOperator>(this);
1157
1158     if (Ctx.getLangOptions().CPlusPlus && // C++ [expr.comma]p1
1159         BinOp->getOpcode() == BinaryOperator::Comma)
1160       return BinOp->getRHS()->isLvalue(Ctx);
1161
1162     // C++ [expr.mptr.oper]p6
1163     // The result of a .* expression is an lvalue only if its first operand is
1164     // an lvalue and its second operand is a pointer to data member.
1165     if (BinOp->getOpcode() == BinaryOperator::PtrMemD &&
1166         !BinOp->getType()->isFunctionType())
1167       return BinOp->getLHS()->isLvalue(Ctx);
1168
1169     // The result of an ->* expression is an lvalue only if its second operand
1170     // is a pointer to data member.
1171     if (BinOp->getOpcode() == BinaryOperator::PtrMemI &&
1172         !BinOp->getType()->isFunctionType()) {
1173       QualType Ty = BinOp->getRHS()->getType();
1174       if (Ty->isMemberPointerType() && !Ty->isMemberFunctionPointerType())
1175         return LV_Valid;
1176     }
1177
1178     if (!BinOp->isAssignmentOp())
1179       return LV_InvalidExpression;
1180
1181     if (Ctx.getLangOptions().CPlusPlus)
1182       // C++ [expr.ass]p1:
1183       //   The result of an assignment operation [...] is an lvalue.
1184       return LV_Valid;
1185
1186
1187     // C99 6.5.16:
1188     //   An assignment expression [...] is not an lvalue.
1189     return LV_InvalidExpression;
1190   }
1191   case CallExprClass:
1192   case CXXOperatorCallExprClass:
1193   case CXXMemberCallExprClass: {
1194     // C++0x [expr.call]p10
1195     //   A function call is an lvalue if and only if the result type
1196     //   is an lvalue reference.
1197     QualType ReturnType = cast<CallExpr>(this)->getCallReturnType();
1198     if (ReturnType->isLValueReferenceType())
1199       return LV_Valid;
1200
1201     // If the function is returning a class temporary, make a note of
1202     // that.
1203     if (Ctx.getLangOptions().CPlusPlus && ReturnType->isRecordType())
1204       return LV_ClassTemporary;
1205
1206     break;
1207   }
1208   case CompoundLiteralExprClass: // C99 6.5.2.5p5
1209     // FIXME: Is this what we want in C++?
1210     return LV_Valid;
1211   case ChooseExprClass:
1212     // __builtin_choose_expr is an lvalue if the selected operand is.
1213     return cast<ChooseExpr>(this)->getChosenSubExpr(Ctx)->isLvalue(Ctx);
1214   case ExtVectorElementExprClass:
1215     if (cast<ExtVectorElementExpr>(this)->containsDuplicateElements())
1216       return LV_DuplicateVectorComponents;
1217     return LV_Valid;
1218   case ObjCIvarRefExprClass: // ObjC instance variables are lvalues.
1219     return LV_Valid;
1220   case ObjCPropertyRefExprClass: // FIXME: check if read-only property.
1221     return LV_Valid;
1222   case ObjCImplicitSetterGetterRefExprClass: // FIXME: check if read-only property.
1223     return LV_Valid;
1224   case PredefinedExprClass:
1225     return LV_Valid;
1226   case UnresolvedLookupExprClass:
1227     return LV_Valid;
1228   case CXXDefaultArgExprClass:
1229     return cast<CXXDefaultArgExpr>(this)->getExpr()->isLvalue(Ctx);
1230   case CStyleCastExprClass:
1231   case CXXFunctionalCastExprClass:
1232   case CXXStaticCastExprClass:
1233   case CXXDynamicCastExprClass:
1234   case CXXReinterpretCastExprClass:
1235   case CXXConstCastExprClass:
1236     // The result of an explicit cast is an lvalue if the type we are
1237     // casting to is an lvalue reference type. See C++ [expr.cast]p1,
1238     // C++ [expr.static.cast]p2, C++ [expr.dynamic.cast]p2,
1239     // C++ [expr.reinterpret.cast]p1, C++ [expr.const.cast]p1.
1240     if (cast<ExplicitCastExpr>(this)->getTypeAsWritten()->
1241           isLValueReferenceType())
1242       return LV_Valid;
1243
1244     // If this is a conversion to a class temporary, make a note of
1245     // that.
1246     if (Ctx.getLangOptions().CPlusPlus &&
1247         cast<ExplicitCastExpr>(this)->getTypeAsWritten()->isRecordType())
1248       return LV_ClassTemporary;
1249
1250     break;
1251   case CXXTypeidExprClass:
1252     // C++ 5.2.8p1: The result of a typeid expression is an lvalue of ...
1253     return LV_Valid;
1254   case CXXBindTemporaryExprClass:
1255     return cast<CXXBindTemporaryExpr>(this)->getSubExpr()->
1256       isLvalueInternal(Ctx);
1257   case CXXBindReferenceExprClass:
1258     // Something that's bound to a reference is always an lvalue.
1259     return LV_Valid;
1260   case ConditionalOperatorClass: {
1261     // Complicated handling is only for C++.
1262     if (!Ctx.getLangOptions().CPlusPlus)
1263       return LV_InvalidExpression;
1264
1265     // Sema should have taken care to ensure that a CXXTemporaryObjectExpr is
1266     // everywhere there's an object converted to an rvalue. Also, any other
1267     // casts should be wrapped by ImplicitCastExprs. There's just the special
1268     // case involving throws to work out.
1269     const ConditionalOperator *Cond = cast<ConditionalOperator>(this);
1270     Expr *True = Cond->getTrueExpr();
1271     Expr *False = Cond->getFalseExpr();
1272     // C++0x 5.16p2
1273     //   If either the second or the third operand has type (cv) void, [...]
1274     //   the result [...] is an rvalue.
1275     if (True->getType()->isVoidType() || False->getType()->isVoidType())
1276       return LV_InvalidExpression;
1277
1278     // Both sides must be lvalues for the result to be an lvalue.
1279     if (True->isLvalue(Ctx) != LV_Valid || False->isLvalue(Ctx) != LV_Valid)
1280       return LV_InvalidExpression;
1281
1282     // That's it.
1283     return LV_Valid;
1284   }
1285
1286   case Expr::CXXExprWithTemporariesClass:
1287     return cast<CXXExprWithTemporaries>(this)->getSubExpr()->isLvalue(Ctx);
1288
1289   case Expr::ObjCMessageExprClass:
1290     if (const ObjCMethodDecl *Method
1291           = cast<ObjCMessageExpr>(this)->getMethodDecl())
1292       if (Method->getResultType()->isLValueReferenceType())
1293         return LV_Valid;
1294     break;
1295
1296   case Expr::CXXConstructExprClass:
1297   case Expr::CXXTemporaryObjectExprClass:
1298   case Expr::CXXZeroInitValueExprClass:
1299     return LV_ClassTemporary;
1300
1301   default:
1302     break;
1303   }
1304   return LV_InvalidExpression;
1305 }
1306
1307 /// isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type,
1308 /// does not have an incomplete type, does not have a const-qualified type, and
1309 /// if it is a structure or union, does not have any member (including,
1310 /// recursively, any member or element of all contained aggregates or unions)
1311 /// with a const-qualified type.
1312 Expr::isModifiableLvalueResult
1313 Expr::isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc) const {
1314   isLvalueResult lvalResult = isLvalue(Ctx);
1315
1316   switch (lvalResult) {
1317   case LV_Valid:
1318     // C++ 3.10p11: Functions cannot be modified, but pointers to
1319     // functions can be modifiable.
1320     if (Ctx.getLangOptions().CPlusPlus && TR->isFunctionType())
1321       return MLV_NotObjectType;
1322     break;
1323
1324   case LV_NotObjectType: return MLV_NotObjectType;
1325   case LV_IncompleteVoidType: return MLV_IncompleteVoidType;
1326   case LV_DuplicateVectorComponents: return MLV_DuplicateVectorComponents;
1327   case LV_InvalidExpression:
1328     // If the top level is a C-style cast, and the subexpression is a valid
1329     // lvalue, then this is probably a use of the old-school "cast as lvalue"
1330     // GCC extension.  We don't support it, but we want to produce good
1331     // diagnostics when it happens so that the user knows why.
1332     if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(IgnoreParens())) {
1333       if (CE->getSubExpr()->isLvalue(Ctx) == LV_Valid) {
1334         if (Loc)
1335           *Loc = CE->getLParenLoc();
1336         return MLV_LValueCast;
1337       }
1338     }
1339     return MLV_InvalidExpression;
1340   case LV_MemberFunction: return MLV_MemberFunction;
1341   case LV_SubObjCPropertySetting: return MLV_SubObjCPropertySetting;
1342   case LV_ClassTemporary:
1343     return MLV_ClassTemporary;
1344   }
1345
1346   // The following is illegal:
1347   //   void takeclosure(void (^C)(void));
1348   //   void func() { int x = 1; takeclosure(^{ x = 7; }); }
1349   //
1350   if (const BlockDeclRefExpr *BDR = dyn_cast<BlockDeclRefExpr>(this)) {
1351     if (!BDR->isByRef() && isa<VarDecl>(BDR->getDecl()))
1352       return MLV_NotBlockQualified;
1353   }
1354
1355   // Assigning to an 'implicit' property?
1356   if (const ObjCImplicitSetterGetterRefExpr* Expr =
1357         dyn_cast<ObjCImplicitSetterGetterRefExpr>(this)) {
1358     if (Expr->getSetterMethod() == 0)
1359       return MLV_NoSetterProperty;
1360   }
1361
1362   QualType CT = Ctx.getCanonicalType(getType());
1363
1364   if (CT.isConstQualified())
1365     return MLV_ConstQualified;
1366   if (CT->isArrayType())
1367     return MLV_ArrayType;
1368   if (CT->isIncompleteType())
1369     return MLV_IncompleteType;
1370
1371   if (const RecordType *r = CT->getAs<RecordType>()) {
1372     if (r->hasConstFields())
1373       return MLV_ConstQualified;
1374   }
1375
1376   return MLV_Valid;
1377 }
1378
1379 /// isOBJCGCCandidate - Check if an expression is objc gc'able.
1380 /// returns true, if it is; false otherwise.
1381 bool Expr::isOBJCGCCandidate(ASTContext &Ctx) const {
1382   switch (getStmtClass()) {
1383   default:
1384     return false;
1385   case ObjCIvarRefExprClass:
1386     return true;
1387   case Expr::UnaryOperatorClass:
1388     return cast<UnaryOperator>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1389   case ParenExprClass:
1390     return cast<ParenExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1391   case ImplicitCastExprClass:
1392     return cast<ImplicitCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1393   case CStyleCastExprClass:
1394     return cast<CStyleCastExpr>(this)->getSubExpr()->isOBJCGCCandidate(Ctx);
1395   case DeclRefExprClass: {
1396     const Decl *D = cast<DeclRefExpr>(this)->getDecl();
1397     if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1398       if (VD->hasGlobalStorage())
1399         return true;
1400       QualType T = VD->getType();
1401       // dereferencing to a  pointer is always a gc'able candidate,
1402       // unless it is __weak.
1403       return T->isPointerType() &&
1404              (Ctx.getObjCGCAttrKind(T) != Qualifiers::Weak);
1405     }
1406     return false;
1407   }
1408   case MemberExprClass: {
1409     const MemberExpr *M = cast<MemberExpr>(this);
1410     return M->getBase()->isOBJCGCCandidate(Ctx);
1411   }
1412   case ArraySubscriptExprClass:
1413     return cast<ArraySubscriptExpr>(this)->getBase()->isOBJCGCCandidate(Ctx);
1414   }
1415 }
1416 Expr* Expr::IgnoreParens() {
1417   Expr* E = this;
1418   while (ParenExpr* P = dyn_cast<ParenExpr>(E))
1419     E = P->getSubExpr();
1420
1421   return E;
1422 }
1423
1424 /// IgnoreParenCasts - Ignore parentheses and casts.  Strip off any ParenExpr
1425 /// or CastExprs or ImplicitCastExprs, returning their operand.
1426 Expr *Expr::IgnoreParenCasts() {
1427   Expr *E = this;
1428   while (true) {
1429     if (ParenExpr *P = dyn_cast<ParenExpr>(E))
1430       E = P->getSubExpr();
1431     else if (CastExpr *P = dyn_cast<CastExpr>(E))
1432       E = P->getSubExpr();
1433     else
1434       return E;
1435   }
1436 }
1437
1438 /// IgnoreParenNoopCasts - Ignore parentheses and casts that do not change the
1439 /// value (including ptr->int casts of the same size).  Strip off any
1440 /// ParenExpr or CastExprs, returning their operand.
1441 Expr *Expr::IgnoreParenNoopCasts(ASTContext &Ctx) {
1442   Expr *E = this;
1443   while (true) {
1444     if (ParenExpr *P = dyn_cast<ParenExpr>(E)) {
1445       E = P->getSubExpr();
1446       continue;
1447     }
1448
1449     if (CastExpr *P = dyn_cast<CastExpr>(E)) {
1450       // We ignore integer <-> casts that are of the same width, ptr<->ptr and
1451       // ptr<->int casts of the same width.  We also ignore all identify casts.
1452       Expr *SE = P->getSubExpr();
1453
1454       if (Ctx.hasSameUnqualifiedType(E->getType(), SE->getType())) {
1455         E = SE;
1456         continue;
1457       }
1458
1459       if ((E->getType()->isPointerType() || E->getType()->isIntegralType()) &&
1460           (SE->getType()->isPointerType() || SE->getType()->isIntegralType()) &&
1461           Ctx.getTypeSize(E->getType()) == Ctx.getTypeSize(SE->getType())) {
1462         E = SE;
1463         continue;
1464       }
1465     }
1466
1467     return E;
1468   }
1469 }
1470
1471 bool Expr::isDefaultArgument() const {
1472   const Expr *E = this;
1473   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
1474     E = ICE->getSubExprAsWritten();
1475
1476   return isa<CXXDefaultArgExpr>(E);
1477 }
1478
1479 /// hasAnyTypeDependentArguments - Determines if any of the expressions
1480 /// in Exprs is type-dependent.
1481 bool Expr::hasAnyTypeDependentArguments(Expr** Exprs, unsigned NumExprs) {
1482   for (unsigned I = 0; I < NumExprs; ++I)
1483     if (Exprs[I]->isTypeDependent())
1484       return true;
1485
1486   return false;
1487 }
1488
1489 /// hasAnyValueDependentArguments - Determines if any of the expressions
1490 /// in Exprs is value-dependent.
1491 bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
1492   for (unsigned I = 0; I < NumExprs; ++I)
1493     if (Exprs[I]->isValueDependent())
1494       return true;
1495
1496   return false;
1497 }
1498
1499 bool Expr::isConstantInitializer(ASTContext &Ctx) const {
1500   // This function is attempting whether an expression is an initializer
1501   // which can be evaluated at compile-time.  isEvaluatable handles most
1502   // of the cases, but it can't deal with some initializer-specific
1503   // expressions, and it can't deal with aggregates; we deal with those here,
1504   // and fall back to isEvaluatable for the other cases.
1505
1506   // FIXME: This function assumes the variable being assigned to
1507   // isn't a reference type!
1508
1509   switch (getStmtClass()) {
1510   default: break;
1511   case StringLiteralClass:
1512   case ObjCStringLiteralClass:
1513   case ObjCEncodeExprClass:
1514     return true;
1515   case CompoundLiteralExprClass: {
1516     // This handles gcc's extension that allows global initializers like
1517     // "struct x {int x;} x = (struct x) {};".
1518     // FIXME: This accepts other cases it shouldn't!
1519     const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
1520     return Exp->isConstantInitializer(Ctx);
1521   }
1522   case InitListExprClass: {
1523     // FIXME: This doesn't deal with fields with reference types correctly.
1524     // FIXME: This incorrectly allows pointers cast to integers to be assigned
1525     // to bitfields.
1526     const InitListExpr *Exp = cast<InitListExpr>(this);
1527     unsigned numInits = Exp->getNumInits();
1528     for (unsigned i = 0; i < numInits; i++) {
1529       if (!Exp->getInit(i)->isConstantInitializer(Ctx))
1530         return false;
1531     }
1532     return true;
1533   }
1534   case ImplicitValueInitExprClass:
1535     return true;
1536   case ParenExprClass:
1537     return cast<ParenExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1538   case UnaryOperatorClass: {
1539     const UnaryOperator* Exp = cast<UnaryOperator>(this);
1540     if (Exp->getOpcode() == UnaryOperator::Extension)
1541       return Exp->getSubExpr()->isConstantInitializer(Ctx);
1542     break;
1543   }
1544   case BinaryOperatorClass: {
1545     // Special case &&foo - &&bar.  It would be nice to generalize this somehow
1546     // but this handles the common case.
1547     const BinaryOperator *Exp = cast<BinaryOperator>(this);
1548     if (Exp->getOpcode() == BinaryOperator::Sub &&
1549         isa<AddrLabelExpr>(Exp->getLHS()->IgnoreParenNoopCasts(Ctx)) &&
1550         isa<AddrLabelExpr>(Exp->getRHS()->IgnoreParenNoopCasts(Ctx)))
1551       return true;
1552     break;
1553   }
1554   case ImplicitCastExprClass:
1555   case CStyleCastExprClass:
1556     // Handle casts with a destination that's a struct or union; this
1557     // deals with both the gcc no-op struct cast extension and the
1558     // cast-to-union extension.
1559     if (getType()->isRecordType())
1560       return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1561
1562     // Integer->integer casts can be handled here, which is important for
1563     // things like (int)(&&x-&&y).  Scary but true.
1564     if (getType()->isIntegerType() &&
1565         cast<CastExpr>(this)->getSubExpr()->getType()->isIntegerType())
1566       return cast<CastExpr>(this)->getSubExpr()->isConstantInitializer(Ctx);
1567
1568     break;
1569   }
1570   return isEvaluatable(Ctx);
1571 }
1572
1573 /// isIntegerConstantExpr - this recursive routine will test if an expression is
1574 /// an integer constant expression.
1575
1576 /// FIXME: Pass up a reason why! Invalid operation in i-c-e, division by zero,
1577 /// comma, etc
1578 ///
1579 /// FIXME: Handle offsetof.  Two things to do:  Handle GCC's __builtin_offsetof
1580 /// to support gcc 4.0+  and handle the idiom GCC recognizes with a null pointer
1581 /// cast+dereference.
1582
1583 // CheckICE - This function does the fundamental ICE checking: the returned
1584 // ICEDiag contains a Val of 0, 1, or 2, and a possibly null SourceLocation.
1585 // Note that to reduce code duplication, this helper does no evaluation
1586 // itself; the caller checks whether the expression is evaluatable, and
1587 // in the rare cases where CheckICE actually cares about the evaluated
1588 // value, it calls into Evalute.
1589 //
1590 // Meanings of Val:
1591 // 0: This expression is an ICE if it can be evaluated by Evaluate.
1592 // 1: This expression is not an ICE, but if it isn't evaluated, it's
1593 //    a legal subexpression for an ICE. This return value is used to handle
1594 //    the comma operator in C99 mode.
1595 // 2: This expression is not an ICE, and is not a legal subexpression for one.
1596
1597 struct ICEDiag {
1598   unsigned Val;
1599   SourceLocation Loc;
1600
1601   public:
1602   ICEDiag(unsigned v, SourceLocation l) : Val(v), Loc(l) {}
1603   ICEDiag() : Val(0) {}
1604 };
1605
1606 ICEDiag NoDiag() { return ICEDiag(); }
1607
1608 static ICEDiag CheckEvalInICE(const Expr* E, ASTContext &Ctx) {
1609   Expr::EvalResult EVResult;
1610   if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1611       !EVResult.Val.isInt()) {
1612     return ICEDiag(2, E->getLocStart());
1613   }
1614   return NoDiag();
1615 }
1616
1617 static ICEDiag CheckICE(const Expr* E, ASTContext &Ctx) {
1618   assert(!E->isValueDependent() && "Should not see value dependent exprs!");
1619   if (!E->getType()->isIntegralType()) {
1620     return ICEDiag(2, E->getLocStart());
1621   }
1622
1623   switch (E->getStmtClass()) {
1624 #define STMT(Node, Base) case Expr::Node##Class:
1625 #define EXPR(Node, Base)
1626 #include "clang/AST/StmtNodes.def"
1627   case Expr::PredefinedExprClass:
1628   case Expr::FloatingLiteralClass:
1629   case Expr::ImaginaryLiteralClass:
1630   case Expr::StringLiteralClass:
1631   case Expr::ArraySubscriptExprClass:
1632   case Expr::MemberExprClass:
1633   case Expr::CompoundAssignOperatorClass:
1634   case Expr::CompoundLiteralExprClass:
1635   case Expr::ExtVectorElementExprClass:
1636   case Expr::InitListExprClass:
1637   case Expr::DesignatedInitExprClass:
1638   case Expr::ImplicitValueInitExprClass:
1639   case Expr::ParenListExprClass:
1640   case Expr::VAArgExprClass:
1641   case Expr::AddrLabelExprClass:
1642   case Expr::StmtExprClass:
1643   case Expr::CXXMemberCallExprClass:
1644   case Expr::CXXDynamicCastExprClass:
1645   case Expr::CXXTypeidExprClass:
1646   case Expr::CXXNullPtrLiteralExprClass:
1647   case Expr::CXXThisExprClass:
1648   case Expr::CXXThrowExprClass:
1649   case Expr::CXXNewExprClass:
1650   case Expr::CXXDeleteExprClass:
1651   case Expr::CXXPseudoDestructorExprClass:
1652   case Expr::UnresolvedLookupExprClass:
1653   case Expr::DependentScopeDeclRefExprClass:
1654   case Expr::CXXConstructExprClass:
1655   case Expr::CXXBindTemporaryExprClass:
1656   case Expr::CXXBindReferenceExprClass:
1657   case Expr::CXXExprWithTemporariesClass:
1658   case Expr::CXXTemporaryObjectExprClass:
1659   case Expr::CXXUnresolvedConstructExprClass:
1660   case Expr::CXXDependentScopeMemberExprClass:
1661   case Expr::UnresolvedMemberExprClass:
1662   case Expr::ObjCStringLiteralClass:
1663   case Expr::ObjCEncodeExprClass:
1664   case Expr::ObjCMessageExprClass:
1665   case Expr::ObjCSelectorExprClass:
1666   case Expr::ObjCProtocolExprClass:
1667   case Expr::ObjCIvarRefExprClass:
1668   case Expr::ObjCPropertyRefExprClass:
1669   case Expr::ObjCImplicitSetterGetterRefExprClass:
1670   case Expr::ObjCSuperExprClass:
1671   case Expr::ObjCIsaExprClass:
1672   case Expr::ShuffleVectorExprClass:
1673   case Expr::BlockExprClass:
1674   case Expr::BlockDeclRefExprClass:
1675   case Expr::NoStmtClass:
1676     return ICEDiag(2, E->getLocStart());
1677
1678   case Expr::GNUNullExprClass:
1679     // GCC considers the GNU __null value to be an integral constant expression.
1680     return NoDiag();
1681
1682   case Expr::ParenExprClass:
1683     return CheckICE(cast<ParenExpr>(E)->getSubExpr(), Ctx);
1684   case Expr::IntegerLiteralClass:
1685   case Expr::CharacterLiteralClass:
1686   case Expr::CXXBoolLiteralExprClass:
1687   case Expr::CXXZeroInitValueExprClass:
1688   case Expr::TypesCompatibleExprClass:
1689   case Expr::UnaryTypeTraitExprClass:
1690     return NoDiag();
1691   case Expr::CallExprClass:
1692   case Expr::CXXOperatorCallExprClass: {
1693     const CallExpr *CE = cast<CallExpr>(E);
1694     if (CE->isBuiltinCall(Ctx))
1695       return CheckEvalInICE(E, Ctx);
1696     return ICEDiag(2, E->getLocStart());
1697   }
1698   case Expr::DeclRefExprClass:
1699     if (isa<EnumConstantDecl>(cast<DeclRefExpr>(E)->getDecl()))
1700       return NoDiag();
1701     if (Ctx.getLangOptions().CPlusPlus &&
1702         E->getType().getCVRQualifiers() == Qualifiers::Const) {
1703       const NamedDecl *D = cast<DeclRefExpr>(E)->getDecl();
1704
1705       // Parameter variables are never constants.  Without this check,
1706       // getAnyInitializer() can find a default argument, which leads
1707       // to chaos.
1708       if (isa<ParmVarDecl>(D))
1709         return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
1710
1711       // C++ 7.1.5.1p2
1712       //   A variable of non-volatile const-qualified integral or enumeration
1713       //   type initialized by an ICE can be used in ICEs.
1714       if (const VarDecl *Dcl = dyn_cast<VarDecl>(D)) {
1715         Qualifiers Quals = Ctx.getCanonicalType(Dcl->getType()).getQualifiers();
1716         if (Quals.hasVolatile() || !Quals.hasConst())
1717           return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
1718
1719         // Look for a declaration of this variable that has an initializer.
1720         const VarDecl *ID = 0;
1721         const Expr *Init = Dcl->getAnyInitializer(ID);
1722         if (Init) {
1723           if (ID->isInitKnownICE()) {
1724             // We have already checked whether this subexpression is an
1725             // integral constant expression.
1726             if (ID->isInitICE())
1727               return NoDiag();
1728             else
1729               return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
1730           }
1731
1732           // It's an ICE whether or not the definition we found is
1733           // out-of-line.  See DR 721 and the discussion in Clang PR
1734           // 6206 for details.
1735
1736           if (Dcl->isCheckingICE()) {
1737             return ICEDiag(2, cast<DeclRefExpr>(E)->getLocation());
1738           }
1739
1740           Dcl->setCheckingICE();
1741           ICEDiag Result = CheckICE(Init, Ctx);
1742           // Cache the result of the ICE test.
1743           Dcl->setInitKnownICE(Result.Val == 0);
1744           return Result;
1745         }
1746       }
1747     }
1748     return ICEDiag(2, E->getLocStart());
1749   case Expr::UnaryOperatorClass: {
1750     const UnaryOperator *Exp = cast<UnaryOperator>(E);
1751     switch (Exp->getOpcode()) {
1752     case UnaryOperator::PostInc:
1753     case UnaryOperator::PostDec:
1754     case UnaryOperator::PreInc:
1755     case UnaryOperator::PreDec:
1756     case UnaryOperator::AddrOf:
1757     case UnaryOperator::Deref:
1758       return ICEDiag(2, E->getLocStart());
1759
1760     case UnaryOperator::Extension:
1761     case UnaryOperator::LNot:
1762     case UnaryOperator::Plus:
1763     case UnaryOperator::Minus:
1764     case UnaryOperator::Not:
1765     case UnaryOperator::Real:
1766     case UnaryOperator::Imag:
1767       return CheckICE(Exp->getSubExpr(), Ctx);
1768     case UnaryOperator::OffsetOf:
1769       // Note that per C99, offsetof must be an ICE. And AFAIK, using
1770       // Evaluate matches the proposed gcc behavior for cases like
1771       // "offsetof(struct s{int x[4];}, x[!.0])".  This doesn't affect
1772       // compliance: we should warn earlier for offsetof expressions with
1773       // array subscripts that aren't ICEs, and if the array subscripts
1774       // are ICEs, the value of the offsetof must be an integer constant.
1775       return CheckEvalInICE(E, Ctx);
1776     }
1777   }
1778   case Expr::SizeOfAlignOfExprClass: {
1779     const SizeOfAlignOfExpr *Exp = cast<SizeOfAlignOfExpr>(E);
1780     if (Exp->isSizeOf() && Exp->getTypeOfArgument()->isVariableArrayType())
1781       return ICEDiag(2, E->getLocStart());
1782     return NoDiag();
1783   }
1784   case Expr::BinaryOperatorClass: {
1785     const BinaryOperator *Exp = cast<BinaryOperator>(E);
1786     switch (Exp->getOpcode()) {
1787     case BinaryOperator::PtrMemD:
1788     case BinaryOperator::PtrMemI:
1789     case BinaryOperator::Assign:
1790     case BinaryOperator::MulAssign:
1791     case BinaryOperator::DivAssign:
1792     case BinaryOperator::RemAssign:
1793     case BinaryOperator::AddAssign:
1794     case BinaryOperator::SubAssign:
1795     case BinaryOperator::ShlAssign:
1796     case BinaryOperator::ShrAssign:
1797     case BinaryOperator::AndAssign:
1798     case BinaryOperator::XorAssign:
1799     case BinaryOperator::OrAssign:
1800       return ICEDiag(2, E->getLocStart());
1801
1802     case BinaryOperator::Mul:
1803     case BinaryOperator::Div:
1804     case BinaryOperator::Rem:
1805     case BinaryOperator::Add:
1806     case BinaryOperator::Sub:
1807     case BinaryOperator::Shl:
1808     case BinaryOperator::Shr:
1809     case BinaryOperator::LT:
1810     case BinaryOperator::GT:
1811     case BinaryOperator::LE:
1812     case BinaryOperator::GE:
1813     case BinaryOperator::EQ:
1814     case BinaryOperator::NE:
1815     case BinaryOperator::And:
1816     case BinaryOperator::Xor:
1817     case BinaryOperator::Or:
1818     case BinaryOperator::Comma: {
1819       ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1820       ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1821       if (Exp->getOpcode() == BinaryOperator::Div ||
1822           Exp->getOpcode() == BinaryOperator::Rem) {
1823         // Evaluate gives an error for undefined Div/Rem, so make sure
1824         // we don't evaluate one.
1825         if (LHSResult.Val != 2 && RHSResult.Val != 2) {
1826           llvm::APSInt REval = Exp->getRHS()->EvaluateAsInt(Ctx);
1827           if (REval == 0)
1828             return ICEDiag(1, E->getLocStart());
1829           if (REval.isSigned() && REval.isAllOnesValue()) {
1830             llvm::APSInt LEval = Exp->getLHS()->EvaluateAsInt(Ctx);
1831             if (LEval.isMinSignedValue())
1832               return ICEDiag(1, E->getLocStart());
1833           }
1834         }
1835       }
1836       if (Exp->getOpcode() == BinaryOperator::Comma) {
1837         if (Ctx.getLangOptions().C99) {
1838           // C99 6.6p3 introduces a strange edge case: comma can be in an ICE
1839           // if it isn't evaluated.
1840           if (LHSResult.Val == 0 && RHSResult.Val == 0)
1841             return ICEDiag(1, E->getLocStart());
1842         } else {
1843           // In both C89 and C++, commas in ICEs are illegal.
1844           return ICEDiag(2, E->getLocStart());
1845         }
1846       }
1847       if (LHSResult.Val >= RHSResult.Val)
1848         return LHSResult;
1849       return RHSResult;
1850     }
1851     case BinaryOperator::LAnd:
1852     case BinaryOperator::LOr: {
1853       ICEDiag LHSResult = CheckICE(Exp->getLHS(), Ctx);
1854       ICEDiag RHSResult = CheckICE(Exp->getRHS(), Ctx);
1855       if (LHSResult.Val == 0 && RHSResult.Val == 1) {
1856         // Rare case where the RHS has a comma "side-effect"; we need
1857         // to actually check the condition to see whether the side
1858         // with the comma is evaluated.
1859         if ((Exp->getOpcode() == BinaryOperator::LAnd) !=
1860             (Exp->getLHS()->EvaluateAsInt(Ctx) == 0))
1861           return RHSResult;
1862         return NoDiag();
1863       }
1864
1865       if (LHSResult.Val >= RHSResult.Val)
1866         return LHSResult;
1867       return RHSResult;
1868     }
1869     }
1870   }
1871   case Expr::ImplicitCastExprClass:
1872   case Expr::CStyleCastExprClass:
1873   case Expr::CXXFunctionalCastExprClass:
1874   case Expr::CXXNamedCastExprClass:
1875   case Expr::CXXStaticCastExprClass:
1876   case Expr::CXXReinterpretCastExprClass:
1877   case Expr::CXXConstCastExprClass: {
1878     const Expr *SubExpr = cast<CastExpr>(E)->getSubExpr();
1879     if (SubExpr->getType()->isIntegralType())
1880       return CheckICE(SubExpr, Ctx);
1881     if (isa<FloatingLiteral>(SubExpr->IgnoreParens()))
1882       return NoDiag();
1883     return ICEDiag(2, E->getLocStart());
1884   }
1885   case Expr::ConditionalOperatorClass: {
1886     const ConditionalOperator *Exp = cast<ConditionalOperator>(E);
1887     // If the condition (ignoring parens) is a __builtin_constant_p call,
1888     // then only the true side is actually considered in an integer constant
1889     // expression, and it is fully evaluated.  This is an important GNU
1890     // extension.  See GCC PR38377 for discussion.
1891     if (const CallExpr *CallCE = dyn_cast<CallExpr>(Exp->getCond()->IgnoreParenCasts()))
1892       if (CallCE->isBuiltinCall(Ctx) == Builtin::BI__builtin_constant_p) {
1893         Expr::EvalResult EVResult;
1894         if (!E->Evaluate(EVResult, Ctx) || EVResult.HasSideEffects ||
1895             !EVResult.Val.isInt()) {
1896           return ICEDiag(2, E->getLocStart());
1897         }
1898         return NoDiag();
1899       }
1900     ICEDiag CondResult = CheckICE(Exp->getCond(), Ctx);
1901     ICEDiag TrueResult = CheckICE(Exp->getTrueExpr(), Ctx);
1902     ICEDiag FalseResult = CheckICE(Exp->getFalseExpr(), Ctx);
1903     if (CondResult.Val == 2)
1904       return CondResult;
1905     if (TrueResult.Val == 2)
1906       return TrueResult;
1907     if (FalseResult.Val == 2)
1908       return FalseResult;
1909     if (CondResult.Val == 1)
1910       return CondResult;
1911     if (TrueResult.Val == 0 && FalseResult.Val == 0)
1912       return NoDiag();
1913     // Rare case where the diagnostics depend on which side is evaluated
1914     // Note that if we get here, CondResult is 0, and at least one of
1915     // TrueResult and FalseResult is non-zero.
1916     if (Exp->getCond()->EvaluateAsInt(Ctx) == 0) {
1917       return FalseResult;
1918     }
1919     return TrueResult;
1920   }
1921   case Expr::CXXDefaultArgExprClass:
1922     return CheckICE(cast<CXXDefaultArgExpr>(E)->getExpr(), Ctx);
1923   case Expr::ChooseExprClass: {
1924     return CheckICE(cast<ChooseExpr>(E)->getChosenSubExpr(Ctx), Ctx);
1925   }
1926   }
1927
1928   // Silence a GCC warning
1929   return ICEDiag(2, E->getLocStart());
1930 }
1931
1932 bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
1933                                  SourceLocation *Loc, bool isEvaluated) const {
1934   ICEDiag d = CheckICE(this, Ctx);
1935   if (d.Val != 0) {
1936     if (Loc) *Loc = d.Loc;
1937     return false;
1938   }
1939   EvalResult EvalResult;
1940   if (!Evaluate(EvalResult, Ctx))
1941     llvm_unreachable("ICE cannot be evaluated!");
1942   assert(!EvalResult.HasSideEffects && "ICE with side effects!");
1943   assert(EvalResult.Val.isInt() && "ICE that isn't integer!");
1944   Result = EvalResult.Val.getInt();
1945   return true;
1946 }
1947
1948 /// isNullPointerConstant - C99 6.3.2.3p3 -  Return true if this is either an
1949 /// integer constant expression with the value zero, or if this is one that is
1950 /// cast to void*.
1951 bool Expr::isNullPointerConstant(ASTContext &Ctx,
1952                                  NullPointerConstantValueDependence NPC) const {
1953   if (isValueDependent()) {
1954     switch (NPC) {
1955     case NPC_NeverValueDependent:
1956       assert(false && "Unexpected value dependent expression!");
1957       // If the unthinkable happens, fall through to the safest alternative.
1958
1959     case NPC_ValueDependentIsNull:
1960       return isTypeDependent() || getType()->isIntegralType();
1961
1962     case NPC_ValueDependentIsNotNull:
1963       return false;
1964     }
1965   }
1966
1967   // Strip off a cast to void*, if it exists. Except in C++.
1968   if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
1969     if (!Ctx.getLangOptions().CPlusPlus) {
1970       // Check that it is a cast to void*.
1971       if (const PointerType *PT = CE->getType()->getAs<PointerType>()) {
1972         QualType Pointee = PT->getPointeeType();
1973         if (!Pointee.hasQualifiers() &&
1974             Pointee->isVoidType() &&                              // to void*
1975             CE->getSubExpr()->getType()->isIntegerType())         // from int.
1976           return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1977       }
1978     }
1979   } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
1980     // Ignore the ImplicitCastExpr type entirely.
1981     return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1982   } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
1983     // Accept ((void*)0) as a null pointer constant, as many other
1984     // implementations do.
1985     return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
1986   } else if (const CXXDefaultArgExpr *DefaultArg
1987                = dyn_cast<CXXDefaultArgExpr>(this)) {
1988     // See through default argument expressions
1989     return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
1990   } else if (isa<GNUNullExpr>(this)) {
1991     // The GNU __null extension is always a null pointer constant.
1992     return true;
1993   }
1994
1995   // C++0x nullptr_t is always a null pointer constant.
1996   if (getType()->isNullPtrType())
1997     return true;
1998
1999   // This expression must be an integer type.
2000   if (!getType()->isIntegerType() ||
2001       (Ctx.getLangOptions().CPlusPlus && getType()->isEnumeralType()))
2002     return false;
2003
2004   // If we have an integer constant expression, we need to *evaluate* it and
2005   // test for the value 0.
2006   llvm::APSInt Result;
2007   return isIntegerConstantExpr(Result, Ctx) && Result == 0;
2008 }
2009
2010 FieldDecl *Expr::getBitField() {
2011   Expr *E = this->IgnoreParens();
2012
2013   while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2014     if (ICE->isLvalueCast() && ICE->getCastKind() == CastExpr::CK_NoOp)
2015       E = ICE->getSubExpr()->IgnoreParens();
2016     else
2017       break;
2018   }
2019
2020   if (MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
2021     if (FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
2022       if (Field->isBitField())
2023         return Field;
2024
2025   if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(E))
2026     if (BinOp->isAssignmentOp() && BinOp->getLHS())
2027       return BinOp->getLHS()->getBitField();
2028
2029   return 0;
2030 }
2031
2032 bool Expr::refersToVectorElement() const {
2033   const Expr *E = this->IgnoreParens();
2034
2035   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
2036     if (ICE->isLvalueCast() && ICE->getCastKind() == CastExpr::CK_NoOp)
2037       E = ICE->getSubExpr()->IgnoreParens();
2038     else
2039       break;
2040   }
2041
2042   if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(E))
2043     return ASE->getBase()->getType()->isVectorType();
2044
2045   if (isa<ExtVectorElementExpr>(E))
2046     return true;
2047
2048   return false;
2049 }
2050
2051 /// isArrow - Return true if the base expression is a pointer to vector,
2052 /// return false if the base expression is a vector.
2053 bool ExtVectorElementExpr::isArrow() const {
2054   return getBase()->getType()->isPointerType();
2055 }
2056
2057 unsigned ExtVectorElementExpr::getNumElements() const {
2058   if (const VectorType *VT = getType()->getAs<VectorType>())
2059     return VT->getNumElements();
2060   return 1;
2061 }
2062
2063 /// containsDuplicateElements - Return true if any element access is repeated.
2064 bool ExtVectorElementExpr::containsDuplicateElements() const {
2065   // FIXME: Refactor this code to an accessor on the AST node which returns the
2066   // "type" of component access, and share with code below and in Sema.
2067   llvm::StringRef Comp = Accessor->getName();
2068
2069   // Halving swizzles do not contain duplicate elements.
2070   if (Comp == "hi" || Comp == "lo" || Comp == "even" || Comp == "odd")
2071     return false;
2072
2073   // Advance past s-char prefix on hex swizzles.
2074   if (Comp[0] == 's' || Comp[0] == 'S')
2075     Comp = Comp.substr(1);
2076
2077   for (unsigned i = 0, e = Comp.size(); i != e; ++i)
2078     if (Comp.substr(i + 1).find(Comp[i]) != llvm::StringRef::npos)
2079         return true;
2080
2081   return false;
2082 }
2083
2084 /// getEncodedElementAccess - We encode the fields as a llvm ConstantArray.
2085 void ExtVectorElementExpr::getEncodedElementAccess(
2086                                   llvm::SmallVectorImpl<unsigned> &Elts) const {
2087   llvm::StringRef Comp = Accessor->getName();
2088   if (Comp[0] == 's' || Comp[0] == 'S')
2089     Comp = Comp.substr(1);
2090
2091   bool isHi =   Comp == "hi";
2092   bool isLo =   Comp == "lo";
2093   bool isEven = Comp == "even";
2094   bool isOdd  = Comp == "odd";
2095
2096   for (unsigned i = 0, e = getNumElements(); i != e; ++i) {
2097     uint64_t Index;
2098
2099     if (isHi)
2100       Index = e + i;
2101     else if (isLo)
2102       Index = i;
2103     else if (isEven)
2104       Index = 2 * i;
2105     else if (isOdd)
2106       Index = 2 * i + 1;
2107     else
2108       Index = ExtVectorType::getAccessorIdx(Comp[i]);
2109
2110     Elts.push_back(Index);
2111   }
2112 }
2113
2114 // constructor for instance messages.
2115 ObjCMessageExpr::ObjCMessageExpr(ASTContext &C, Expr *receiver,
2116                                  Selector selInfo,
2117                                  QualType retType, ObjCMethodDecl *mproto,
2118                                  SourceLocation LBrac, SourceLocation RBrac,
2119                                  Expr **ArgExprs, unsigned nargs)
2120   : Expr(ObjCMessageExprClass, retType, false, false), SelName(selInfo),
2121     MethodProto(mproto) {
2122   NumArgs = nargs;
2123   SubExprs = new (C) Stmt*[NumArgs+1];
2124   SubExprs[RECEIVER] = receiver;
2125   if (NumArgs) {
2126     for (unsigned i = 0; i != NumArgs; ++i)
2127       SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
2128   }
2129   LBracloc = LBrac;
2130   RBracloc = RBrac;
2131 }
2132
2133 // constructor for class messages.
2134 // FIXME: clsName should be typed to ObjCInterfaceType
2135 ObjCMessageExpr::ObjCMessageExpr(ASTContext &C, IdentifierInfo *clsName,
2136                                  SourceLocation clsNameLoc, Selector selInfo,
2137                                  QualType retType, ObjCMethodDecl *mproto,
2138                                  SourceLocation LBrac, SourceLocation RBrac,
2139                                  Expr **ArgExprs, unsigned nargs)
2140   : Expr(ObjCMessageExprClass, retType, false, false), ClassNameLoc(clsNameLoc),
2141     SelName(selInfo), MethodProto(mproto) {
2142   NumArgs = nargs;
2143   SubExprs = new (C) Stmt*[NumArgs+1];
2144   SubExprs[RECEIVER] = (Expr*) ((uintptr_t) clsName | IsClsMethDeclUnknown);
2145   if (NumArgs) {
2146     for (unsigned i = 0; i != NumArgs; ++i)
2147       SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
2148   }
2149   LBracloc = LBrac;
2150   RBracloc = RBrac;
2151 }
2152
2153 // constructor for class messages.
2154 ObjCMessageExpr::ObjCMessageExpr(ASTContext &C, ObjCInterfaceDecl *cls,
2155                                  SourceLocation clsNameLoc, Selector selInfo,
2156                                  QualType retType,
2157                                  ObjCMethodDecl *mproto, SourceLocation LBrac,
2158                                  SourceLocation RBrac, Expr **ArgExprs,
2159                                  unsigned nargs)
2160   : Expr(ObjCMessageExprClass, retType, false, false), ClassNameLoc(clsNameLoc),
2161     SelName(selInfo), MethodProto(mproto)
2162 {
2163   NumArgs = nargs;
2164   SubExprs = new (C) Stmt*[NumArgs+1];
2165   SubExprs[RECEIVER] = (Expr*) ((uintptr_t) cls | IsClsMethDeclKnown);
2166   if (NumArgs) {
2167     for (unsigned i = 0; i != NumArgs; ++i)
2168       SubExprs[i+ARGS_START] = static_cast<Expr *>(ArgExprs[i]);
2169   }
2170   LBracloc = LBrac;
2171   RBracloc = RBrac;
2172 }
2173
2174 ObjCMessageExpr::ClassInfo ObjCMessageExpr::getClassInfo() const {
2175   uintptr_t x = (uintptr_t) SubExprs[RECEIVER];
2176   switch (x & Flags) {
2177     default:
2178       assert(false && "Invalid ObjCMessageExpr.");
2179     case IsInstMeth:
2180       return ClassInfo(0, 0, SourceLocation());
2181     case IsClsMethDeclUnknown:
2182       return ClassInfo(0, (IdentifierInfo*) (x & ~Flags), ClassNameLoc);
2183     case IsClsMethDeclKnown: {
2184       ObjCInterfaceDecl* D = (ObjCInterfaceDecl*) (x & ~Flags);
2185       return ClassInfo(D, D->getIdentifier(), ClassNameLoc);
2186     }
2187   }
2188 }
2189
2190 void ObjCMessageExpr::setClassInfo(const ObjCMessageExpr::ClassInfo &CI) {
2191   if (CI.Decl == 0 && CI.Name == 0) {
2192     SubExprs[RECEIVER] = (Expr*)((uintptr_t)0 | IsInstMeth);
2193     return;
2194   }
2195
2196   if (CI.Decl == 0)
2197     SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.Name | IsClsMethDeclUnknown);
2198   else
2199     SubExprs[RECEIVER] = (Expr*)((uintptr_t)CI.Decl | IsClsMethDeclKnown);
2200   ClassNameLoc = CI.Loc;
2201 }
2202
2203 void ObjCMessageExpr::DoDestroy(ASTContext &C) {
2204   DestroyChildren(C);
2205   if (SubExprs)
2206     C.Deallocate(SubExprs);
2207   this->~ObjCMessageExpr();
2208   C.Deallocate((void*) this);
2209 }
2210
2211 bool ChooseExpr::isConditionTrue(ASTContext &C) const {
2212   return getCond()->EvaluateAsInt(C) != 0;
2213 }
2214
2215 void ShuffleVectorExpr::setExprs(ASTContext &C, Expr ** Exprs,
2216                                  unsigned NumExprs) {
2217   if (SubExprs) C.Deallocate(SubExprs);
2218
2219   SubExprs = new (C) Stmt* [NumExprs];
2220   this->NumExprs = NumExprs;
2221   memcpy(SubExprs, Exprs, sizeof(Expr *) * NumExprs);
2222 }
2223
2224 void ShuffleVectorExpr::DoDestroy(ASTContext& C) {
2225   DestroyChildren(C);
2226   if (SubExprs) C.Deallocate(SubExprs);
2227   this->~ShuffleVectorExpr();
2228   C.Deallocate(this);
2229 }
2230
2231 void SizeOfAlignOfExpr::DoDestroy(ASTContext& C) {
2232   // Override default behavior of traversing children. If this has a type
2233   // operand and the type is a variable-length array, the child iteration
2234   // will iterate over the size expression. However, this expression belongs
2235   // to the type, not to this, so we don't want to delete it.
2236   // We still want to delete this expression.
2237   if (isArgumentType()) {
2238     this->~SizeOfAlignOfExpr();
2239     C.Deallocate(this);
2240   }
2241   else
2242     Expr::DoDestroy(C);
2243 }
2244
2245 //===----------------------------------------------------------------------===//
2246 //  DesignatedInitExpr
2247 //===----------------------------------------------------------------------===//
2248
2249 IdentifierInfo *DesignatedInitExpr::Designator::getFieldName() {
2250   assert(Kind == FieldDesignator && "Only valid on a field designator");
2251   if (Field.NameOrField & 0x01)
2252     return reinterpret_cast<IdentifierInfo *>(Field.NameOrField&~0x01);
2253   else
2254     return getField()->getIdentifier();
2255 }
2256
2257 DesignatedInitExpr::DesignatedInitExpr(ASTContext &C, QualType Ty,
2258                                        unsigned NumDesignators,
2259                                        const Designator *Designators,
2260                                        SourceLocation EqualOrColonLoc,
2261                                        bool GNUSyntax,
2262                                        Expr **IndexExprs,
2263                                        unsigned NumIndexExprs,
2264                                        Expr *Init)
2265   : Expr(DesignatedInitExprClass, Ty,
2266          Init->isTypeDependent(), Init->isValueDependent()),
2267     EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
2268     NumDesignators(NumDesignators), NumSubExprs(NumIndexExprs + 1) {
2269   this->Designators = new (C) Designator[NumDesignators];
2270
2271   // Record the initializer itself.
2272   child_iterator Child = child_begin();
2273   *Child++ = Init;
2274
2275   // Copy the designators and their subexpressions, computing
2276   // value-dependence along the way.
2277   unsigned IndexIdx = 0;
2278   for (unsigned I = 0; I != NumDesignators; ++I) {
2279     this->Designators[I] = Designators[I];
2280
2281     if (this->Designators[I].isArrayDesignator()) {
2282       // Compute type- and value-dependence.
2283       Expr *Index = IndexExprs[IndexIdx];
2284       ValueDependent = ValueDependent ||
2285         Index->isTypeDependent() || Index->isValueDependent();
2286
2287       // Copy the index expressions into permanent storage.
2288       *Child++ = IndexExprs[IndexIdx++];
2289     } else if (this->Designators[I].isArrayRangeDesignator()) {
2290       // Compute type- and value-dependence.
2291       Expr *Start = IndexExprs[IndexIdx];
2292       Expr *End = IndexExprs[IndexIdx + 1];
2293       ValueDependent = ValueDependent ||
2294         Start->isTypeDependent() || Start->isValueDependent() ||
2295         End->isTypeDependent() || End->isValueDependent();
2296
2297       // Copy the start/end expressions into permanent storage.
2298       *Child++ = IndexExprs[IndexIdx++];
2299       *Child++ = IndexExprs[IndexIdx++];
2300     }
2301   }
2302
2303   assert(IndexIdx == NumIndexExprs && "Wrong number of index expressions");
2304 }
2305
2306 DesignatedInitExpr *
2307 DesignatedInitExpr::Create(ASTContext &C, Designator *Designators,
2308                            unsigned NumDesignators,
2309                            Expr **IndexExprs, unsigned NumIndexExprs,
2310                            SourceLocation ColonOrEqualLoc,
2311                            bool UsesColonSyntax, Expr *Init) {
2312   void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2313                          sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2314   return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
2315                                       ColonOrEqualLoc, UsesColonSyntax,
2316                                       IndexExprs, NumIndexExprs, Init);
2317 }
2318
2319 DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(ASTContext &C,
2320                                                     unsigned NumIndexExprs) {
2321   void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
2322                          sizeof(Stmt *) * (NumIndexExprs + 1), 8);
2323   return new (Mem) DesignatedInitExpr(NumIndexExprs + 1);
2324 }
2325
2326 void DesignatedInitExpr::setDesignators(ASTContext &C,
2327                                         const Designator *Desigs,
2328                                         unsigned NumDesigs) {
2329   DestroyDesignators(C);
2330
2331   Designators = new (C) Designator[NumDesigs];
2332   NumDesignators = NumDesigs;
2333   for (unsigned I = 0; I != NumDesigs; ++I)
2334     Designators[I] = Desigs[I];
2335 }
2336
2337 SourceRange DesignatedInitExpr::getSourceRange() const {
2338   SourceLocation StartLoc;
2339   Designator &First =
2340     *const_cast<DesignatedInitExpr*>(this)->designators_begin();
2341   if (First.isFieldDesignator()) {
2342     if (GNUSyntax)
2343       StartLoc = SourceLocation::getFromRawEncoding(First.Field.FieldLoc);
2344     else
2345       StartLoc = SourceLocation::getFromRawEncoding(First.Field.DotLoc);
2346   } else
2347     StartLoc =
2348       SourceLocation::getFromRawEncoding(First.ArrayOrRange.LBracketLoc);
2349   return SourceRange(StartLoc, getInit()->getSourceRange().getEnd());
2350 }
2351
2352 Expr *DesignatedInitExpr::getArrayIndex(const Designator& D) {
2353   assert(D.Kind == Designator::ArrayDesignator && "Requires array designator");
2354   char* Ptr = static_cast<char*>(static_cast<void *>(this));
2355   Ptr += sizeof(DesignatedInitExpr);
2356   Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2357   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2358 }
2359
2360 Expr *DesignatedInitExpr::getArrayRangeStart(const Designator& D) {
2361   assert(D.Kind == Designator::ArrayRangeDesignator &&
2362          "Requires array range designator");
2363   char* Ptr = static_cast<char*>(static_cast<void *>(this));
2364   Ptr += sizeof(DesignatedInitExpr);
2365   Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2366   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 1));
2367 }
2368
2369 Expr *DesignatedInitExpr::getArrayRangeEnd(const Designator& D) {
2370   assert(D.Kind == Designator::ArrayRangeDesignator &&
2371          "Requires array range designator");
2372   char* Ptr = static_cast<char*>(static_cast<void *>(this));
2373   Ptr += sizeof(DesignatedInitExpr);
2374   Stmt **SubExprs = reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2375   return cast<Expr>(*(SubExprs + D.ArrayOrRange.Index + 2));
2376 }
2377
2378 /// \brief Replaces the designator at index @p Idx with the series
2379 /// of designators in [First, Last).
2380 void DesignatedInitExpr::ExpandDesignator(ASTContext &C, unsigned Idx,
2381                                           const Designator *First,
2382                                           const Designator *Last) {
2383   unsigned NumNewDesignators = Last - First;
2384   if (NumNewDesignators == 0) {
2385     std::copy_backward(Designators + Idx + 1,
2386                        Designators + NumDesignators,
2387                        Designators + Idx);
2388     --NumNewDesignators;
2389     return;
2390   } else if (NumNewDesignators == 1) {
2391     Designators[Idx] = *First;
2392     return;
2393   }
2394
2395   Designator *NewDesignators
2396     = new (C) Designator[NumDesignators - 1 + NumNewDesignators];
2397   std::copy(Designators, Designators + Idx, NewDesignators);
2398   std::copy(First, Last, NewDesignators + Idx);
2399   std::copy(Designators + Idx + 1, Designators + NumDesignators,
2400             NewDesignators + Idx + NumNewDesignators);
2401   DestroyDesignators(C);
2402   Designators = NewDesignators;
2403   NumDesignators = NumDesignators - 1 + NumNewDesignators;
2404 }
2405
2406 void DesignatedInitExpr::DoDestroy(ASTContext &C) {
2407   DestroyDesignators(C);
2408   Expr::DoDestroy(C);
2409 }
2410
2411 void DesignatedInitExpr::DestroyDesignators(ASTContext &C) {
2412   for (unsigned I = 0; I != NumDesignators; ++I)
2413     Designators[I].~Designator();
2414   C.Deallocate(Designators);
2415   Designators = 0;
2416 }
2417
2418 ParenListExpr::ParenListExpr(ASTContext& C, SourceLocation lparenloc,
2419                              Expr **exprs, unsigned nexprs,
2420                              SourceLocation rparenloc)
2421 : Expr(ParenListExprClass, QualType(),
2422        hasAnyTypeDependentArguments(exprs, nexprs),
2423        hasAnyValueDependentArguments(exprs, nexprs)),
2424   NumExprs(nexprs), LParenLoc(lparenloc), RParenLoc(rparenloc) {
2425
2426   Exprs = new (C) Stmt*[nexprs];
2427   for (unsigned i = 0; i != nexprs; ++i)
2428     Exprs[i] = exprs[i];
2429 }
2430
2431 void ParenListExpr::DoDestroy(ASTContext& C) {
2432   DestroyChildren(C);
2433   if (Exprs) C.Deallocate(Exprs);
2434   this->~ParenListExpr();
2435   C.Deallocate(this);
2436 }
2437
2438 //===----------------------------------------------------------------------===//
2439 //  ExprIterator.
2440 //===----------------------------------------------------------------------===//
2441
2442 Expr* ExprIterator::operator[](size_t idx) { return cast<Expr>(I[idx]); }
2443 Expr* ExprIterator::operator*() const { return cast<Expr>(*I); }
2444 Expr* ExprIterator::operator->() const { return cast<Expr>(*I); }
2445 const Expr* ConstExprIterator::operator[](size_t idx) const {
2446   return cast<Expr>(I[idx]);
2447 }
2448 const Expr* ConstExprIterator::operator*() const { return cast<Expr>(*I); }
2449 const Expr* ConstExprIterator::operator->() const { return cast<Expr>(*I); }
2450
2451 //===----------------------------------------------------------------------===//
2452 //  Child Iterators for iterating over subexpressions/substatements
2453 //===----------------------------------------------------------------------===//
2454
2455 // DeclRefExpr
2456 Stmt::child_iterator DeclRefExpr::child_begin() { return child_iterator(); }
2457 Stmt::child_iterator DeclRefExpr::child_end() { return child_iterator(); }
2458
2459 // ObjCIvarRefExpr
2460 Stmt::child_iterator ObjCIvarRefExpr::child_begin() { return &Base; }
2461 Stmt::child_iterator ObjCIvarRefExpr::child_end() { return &Base+1; }
2462
2463 // ObjCPropertyRefExpr
2464 Stmt::child_iterator ObjCPropertyRefExpr::child_begin() { return &Base; }
2465 Stmt::child_iterator ObjCPropertyRefExpr::child_end() { return &Base+1; }
2466
2467 // ObjCImplicitSetterGetterRefExpr
2468 Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_begin() {
2469   return &Base;
2470 }
2471 Stmt::child_iterator ObjCImplicitSetterGetterRefExpr::child_end() {
2472   return &Base+1;
2473 }
2474
2475 // ObjCSuperExpr
2476 Stmt::child_iterator ObjCSuperExpr::child_begin() { return child_iterator(); }
2477 Stmt::child_iterator ObjCSuperExpr::child_end() { return child_iterator(); }
2478
2479 // ObjCIsaExpr
2480 Stmt::child_iterator ObjCIsaExpr::child_begin() { return &Base; }
2481 Stmt::child_iterator ObjCIsaExpr::child_end() { return &Base+1; }
2482
2483 // PredefinedExpr
2484 Stmt::child_iterator PredefinedExpr::child_begin() { return child_iterator(); }
2485 Stmt::child_iterator PredefinedExpr::child_end() { return child_iterator(); }
2486
2487 // IntegerLiteral
2488 Stmt::child_iterator IntegerLiteral::child_begin() { return child_iterator(); }
2489 Stmt::child_iterator IntegerLiteral::child_end() { return child_iterator(); }
2490
2491 // CharacterLiteral
2492 Stmt::child_iterator CharacterLiteral::child_begin() { return child_iterator();}
2493 Stmt::child_iterator CharacterLiteral::child_end() { return child_iterator(); }
2494
2495 // FloatingLiteral
2496 Stmt::child_iterator FloatingLiteral::child_begin() { return child_iterator(); }
2497 Stmt::child_iterator FloatingLiteral::child_end() { return child_iterator(); }
2498
2499 // ImaginaryLiteral
2500 Stmt::child_iterator ImaginaryLiteral::child_begin() { return &Val; }
2501 Stmt::child_iterator ImaginaryLiteral::child_end() { return &Val+1; }
2502
2503 // StringLiteral
2504 Stmt::child_iterator StringLiteral::child_begin() { return child_iterator(); }
2505 Stmt::child_iterator StringLiteral::child_end() { return child_iterator(); }
2506
2507 // ParenExpr
2508 Stmt::child_iterator ParenExpr::child_begin() { return &Val; }
2509 Stmt::child_iterator ParenExpr::child_end() { return &Val+1; }
2510
2511 // UnaryOperator
2512 Stmt::child_iterator UnaryOperator::child_begin() { return &Val; }
2513 Stmt::child_iterator UnaryOperator::child_end() { return &Val+1; }
2514
2515 // SizeOfAlignOfExpr
2516 Stmt::child_iterator SizeOfAlignOfExpr::child_begin() {
2517   // If this is of a type and the type is a VLA type (and not a typedef), the
2518   // size expression of the VLA needs to be treated as an executable expression.
2519   // Why isn't this weirdness documented better in StmtIterator?
2520   if (isArgumentType()) {
2521     if (VariableArrayType* T = dyn_cast<VariableArrayType>(
2522                                    getArgumentType().getTypePtr()))
2523       return child_iterator(T);
2524     return child_iterator();
2525   }
2526   return child_iterator(&Argument.Ex);
2527 }
2528 Stmt::child_iterator SizeOfAlignOfExpr::child_end() {
2529   if (isArgumentType())
2530     return child_iterator();
2531   return child_iterator(&Argument.Ex + 1);
2532 }
2533
2534 // ArraySubscriptExpr
2535 Stmt::child_iterator ArraySubscriptExpr::child_begin() {
2536   return &SubExprs[0];
2537 }
2538 Stmt::child_iterator ArraySubscriptExpr::child_end() {
2539   return &SubExprs[0]+END_EXPR;
2540 }
2541
2542 // CallExpr
2543 Stmt::child_iterator CallExpr::child_begin() {
2544   return &SubExprs[0];
2545 }
2546 Stmt::child_iterator CallExpr::child_end() {
2547   return &SubExprs[0]+NumArgs+ARGS_START;
2548 }
2549
2550 // MemberExpr
2551 Stmt::child_iterator MemberExpr::child_begin() { return &Base; }
2552 Stmt::child_iterator MemberExpr::child_end() { return &Base+1; }
2553
2554 // ExtVectorElementExpr
2555 Stmt::child_iterator ExtVectorElementExpr::child_begin() { return &Base; }
2556 Stmt::child_iterator ExtVectorElementExpr::child_end() { return &Base+1; }
2557
2558 // CompoundLiteralExpr
2559 Stmt::child_iterator CompoundLiteralExpr::child_begin() { return &Init; }
2560 Stmt::child_iterator CompoundLiteralExpr::child_end() { return &Init+1; }
2561
2562 // CastExpr
2563 Stmt::child_iterator CastExpr::child_begin() { return &Op; }
2564 Stmt::child_iterator CastExpr::child_end() { return &Op+1; }
2565
2566 // BinaryOperator
2567 Stmt::child_iterator BinaryOperator::child_begin() {
2568   return &SubExprs[0];
2569 }
2570 Stmt::child_iterator BinaryOperator::child_end() {
2571   return &SubExprs[0]+END_EXPR;
2572 }
2573
2574 // ConditionalOperator
2575 Stmt::child_iterator ConditionalOperator::child_begin() {
2576   return &SubExprs[0];
2577 }
2578 Stmt::child_iterator ConditionalOperator::child_end() {
2579   return &SubExprs[0]+END_EXPR;
2580 }
2581
2582 // AddrLabelExpr
2583 Stmt::child_iterator AddrLabelExpr::child_begin() { return child_iterator(); }
2584 Stmt::child_iterator AddrLabelExpr::child_end() { return child_iterator(); }
2585
2586 // StmtExpr
2587 Stmt::child_iterator StmtExpr::child_begin() { return &SubStmt; }
2588 Stmt::child_iterator StmtExpr::child_end() { return &SubStmt+1; }
2589
2590 // TypesCompatibleExpr
2591 Stmt::child_iterator TypesCompatibleExpr::child_begin() {
2592   return child_iterator();
2593 }
2594
2595 Stmt::child_iterator TypesCompatibleExpr::child_end() {
2596   return child_iterator();
2597 }
2598
2599 // ChooseExpr
2600 Stmt::child_iterator ChooseExpr::child_begin() { return &SubExprs[0]; }
2601 Stmt::child_iterator ChooseExpr::child_end() { return &SubExprs[0]+END_EXPR; }
2602
2603 // GNUNullExpr
2604 Stmt::child_iterator GNUNullExpr::child_begin() { return child_iterator(); }
2605 Stmt::child_iterator GNUNullExpr::child_end() { return child_iterator(); }
2606
2607 // ShuffleVectorExpr
2608 Stmt::child_iterator ShuffleVectorExpr::child_begin() {
2609   return &SubExprs[0];
2610 }
2611 Stmt::child_iterator ShuffleVectorExpr::child_end() {
2612   return &SubExprs[0]+NumExprs;
2613 }
2614
2615 // VAArgExpr
2616 Stmt::child_iterator VAArgExpr::child_begin() { return &Val; }
2617 Stmt::child_iterator VAArgExpr::child_end() { return &Val+1; }
2618
2619 // InitListExpr
2620 Stmt::child_iterator InitListExpr::child_begin() {
2621   return InitExprs.size() ? &InitExprs[0] : 0;
2622 }
2623 Stmt::child_iterator InitListExpr::child_end() {
2624   return InitExprs.size() ? &InitExprs[0] + InitExprs.size() : 0;
2625 }
2626
2627 // DesignatedInitExpr
2628 Stmt::child_iterator DesignatedInitExpr::child_begin() {
2629   char* Ptr = static_cast<char*>(static_cast<void *>(this));
2630   Ptr += sizeof(DesignatedInitExpr);
2631   return reinterpret_cast<Stmt**>(reinterpret_cast<void**>(Ptr));
2632 }
2633 Stmt::child_iterator DesignatedInitExpr::child_end() {
2634   return child_iterator(&*child_begin() + NumSubExprs);
2635 }
2636
2637 // ImplicitValueInitExpr
2638 Stmt::child_iterator ImplicitValueInitExpr::child_begin() {
2639   return child_iterator();
2640 }
2641
2642 Stmt::child_iterator ImplicitValueInitExpr::child_end() {
2643   return child_iterator();
2644 }
2645
2646 // ParenListExpr
2647 Stmt::child_iterator ParenListExpr::child_begin() {
2648   return &Exprs[0];
2649 }
2650 Stmt::child_iterator ParenListExpr::child_end() {
2651   return &Exprs[0]+NumExprs;
2652 }
2653
2654 // ObjCStringLiteral
2655 Stmt::child_iterator ObjCStringLiteral::child_begin() {
2656   return &String;
2657 }
2658 Stmt::child_iterator ObjCStringLiteral::child_end() {
2659   return &String+1;
2660 }
2661
2662 // ObjCEncodeExpr
2663 Stmt::child_iterator ObjCEncodeExpr::child_begin() { return child_iterator(); }
2664 Stmt::child_iterator ObjCEncodeExpr::child_end() { return child_iterator(); }
2665
2666 // ObjCSelectorExpr
2667 Stmt::child_iterator ObjCSelectorExpr::child_begin() {
2668   return child_iterator();
2669 }
2670 Stmt::child_iterator ObjCSelectorExpr::child_end() {
2671   return child_iterator();
2672 }
2673
2674 // ObjCProtocolExpr
2675 Stmt::child_iterator ObjCProtocolExpr::child_begin() {
2676   return child_iterator();
2677 }
2678 Stmt::child_iterator ObjCProtocolExpr::child_end() {
2679   return child_iterator();
2680 }
2681
2682 // ObjCMessageExpr
2683 Stmt::child_iterator ObjCMessageExpr::child_begin() {
2684   return getReceiver() ? &SubExprs[0] : &SubExprs[0] + ARGS_START;
2685 }
2686 Stmt::child_iterator ObjCMessageExpr::child_end() {
2687   return &SubExprs[0]+ARGS_START+getNumArgs();
2688 }
2689
2690 // Blocks
2691 Stmt::child_iterator BlockExpr::child_begin() { return child_iterator(); }
2692 Stmt::child_iterator BlockExpr::child_end() { return child_iterator(); }
2693
2694 Stmt::child_iterator BlockDeclRefExpr::child_begin() { return child_iterator();}
2695 Stmt::child_iterator BlockDeclRefExpr::child_end() { return child_iterator(); }