clang/lib/Sema/SemaStmt.cpp

   1 //===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
   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 semantic analysis for statements.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Sema/SemaInternal.h"
  15 #include "clang/Sema/Scope.h"
  16 #include "clang/Sema/ScopeInfo.h"
  17 #include "clang/Sema/Initialization.h"
  18 #include "clang/Sema/Lookup.h"
  19 #include "clang/AST/ASTContext.h"
  20 #include "clang/AST/CharUnits.h"
  21 #include "clang/AST/DeclObjC.h"
  22 #include "clang/AST/EvaluatedExprVisitor.h"
  23 #include "clang/AST/ExprCXX.h"
  24 #include "clang/AST/ExprObjC.h"
  25 #include "clang/AST/StmtObjC.h"
  26 #include "clang/AST/StmtCXX.h"
  27 #include "clang/AST/TypeLoc.h"
  28 #include "clang/Lex/Preprocessor.h"
  29 #include "clang/Basic/TargetInfo.h"
  30 #include "llvm/ADT/ArrayRef.h"
  31 #include "llvm/ADT/BitVector.h"
  32 #include "llvm/ADT/STLExtras.h"
  33 #include "llvm/ADT/SmallPtrSet.h"
  34 #include "llvm/ADT/SmallString.h"
  35 #include "llvm/ADT/SmallVector.h"
  36 #include "llvm/ADT/Triple.h"
  37 #include "llvm/MC/MCAsmInfo.h"
  38 #include "llvm/MC/MCContext.h"
  39 #include "llvm/MC/MCInst.h"
  40 #include "llvm/MC/MCInstPrinter.h"
  41 #include "llvm/MC/MCInstrInfo.h"
  42 #include "llvm/MC/MCObjectFileInfo.h"
  43 #include "llvm/MC/MCRegisterInfo.h"
  44 #include "llvm/MC/MCStreamer.h"
  45 #include "llvm/MC/MCSubtargetInfo.h"
  46 #include "llvm/MC/MCTargetAsmParser.h"
  47 #include "llvm/MC/MCParser/MCAsmLexer.h"
  48 #include "llvm/MC/MCParser/MCAsmParser.h"
  49 #include "llvm/Support/SourceMgr.h"
  50 #include "llvm/Support/TargetRegistry.h"
  51 #include "llvm/Support/TargetSelect.h"
  52 using namespace clang;
  53 using namespace sema;
  54
  55 StmtResult Sema::ActOnExprStmt(FullExprArg expr) {
  56   Expr *E = expr.get();
  57   if (!E) // FIXME: FullExprArg has no error state?
  58     return StmtError();
  59
  60   // C99 6.8.3p2: The expression in an expression statement is evaluated as a
  61   // void expression for its side effects.  Conversion to void allows any
  62   // operand, even incomplete types.
  63
  64   // Same thing in for stmt first clause (when expr) and third clause.
  65   return Owned(static_cast<Stmt*>(E));
  66 }
  67
  68
  69 StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
  70                                bool HasLeadingEmptyMacro) {
  71   return Owned(new (Context) NullStmt(SemiLoc, HasLeadingEmptyMacro));
  72 }
  73
  74 StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
  75                                SourceLocation EndLoc) {
  76   DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
  77
  78   // If we have an invalid decl, just return an error.
  79   if (DG.isNull()) return StmtError();
  80
  81   return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
  82 }
  83
  84 void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
  85   DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
  86
  87   // If we have an invalid decl, just return.
  88   if (DG.isNull() || !DG.isSingleDecl()) return;
  89   VarDecl *var = cast<VarDecl>(DG.getSingleDecl());
  90
  91   // suppress any potential 'unused variable' warning.
  92   var->setUsed();
  93
  94   // foreach variables are never actually initialized in the way that
  95   // the parser came up with.
  96   var->setInit(0);
  97
  98   // In ARC, we don't need to retain the iteration variable of a fast
  99   // enumeration loop.  Rather than actually trying to catch that
 100   // during declaration processing, we remove the consequences here.
 101   if (getLangOpts().ObjCAutoRefCount) {
 102     QualType type = var->getType();
 103
 104     // Only do this if we inferred the lifetime.  Inferred lifetime
 105     // will show up as a local qualifier because explicit lifetime
 106     // should have shown up as an AttributedType instead.
 107     if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) {
 108       // Add 'const' and mark the variable as pseudo-strong.
 109       var->setType(type.withConst());
 110       var->setARCPseudoStrong(true);
 111     }
 112   }
 113 }
 114
 115 /// \brief Diagnose unused '==' and '!=' as likely typos for '=' or '|='.
 116 ///
 117 /// Adding a cast to void (or other expression wrappers) will prevent the
 118 /// warning from firing.
 119 static bool DiagnoseUnusedComparison(Sema &S, const Expr *E) {
 120   SourceLocation Loc;
 121   bool IsNotEqual, CanAssign;
 122
 123   if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
 124     if (Op->getOpcode() != BO_EQ && Op->getOpcode() != BO_NE)
 125       return false;
 126
 127     Loc = Op->getOperatorLoc();
 128     IsNotEqual = Op->getOpcode() == BO_NE;
 129     CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();
 130   } else if (const CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
 131     if (Op->getOperator() != OO_EqualEqual &&
 132         Op->getOperator() != OO_ExclaimEqual)
 133       return false;
 134
 135     Loc = Op->getOperatorLoc();
 136     IsNotEqual = Op->getOperator() == OO_ExclaimEqual;
 137     CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
 138   } else {
 139     // Not a typo-prone comparison.
 140     return false;
 141   }
 142
 143   // Suppress warnings when the operator, suspicious as it may be, comes from
 144   // a macro expansion.
 145   if (Loc.isMacroID())
 146     return false;
 147
 148   S.Diag(Loc, diag::warn_unused_comparison)
 149     << (unsigned)IsNotEqual << E->getSourceRange();
 150
 151   // If the LHS is a plausible entity to assign to, provide a fixit hint to
 152   // correct common typos.
 153   if (CanAssign) {
 154     if (IsNotEqual)
 155       S.Diag(Loc, diag::note_inequality_comparison_to_or_assign)
 156         << FixItHint::CreateReplacement(Loc, "|=");
 157     else
 158       S.Diag(Loc, diag::note_equality_comparison_to_assign)
 159         << FixItHint::CreateReplacement(Loc, "=");
 160   }
 161
 162   return true;
 163 }
 164
 165 void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
 166   if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
 167     return DiagnoseUnusedExprResult(Label->getSubStmt());
 168
 169   const Expr *E = dyn_cast_or_null<Expr>(S);
 170   if (!E)
 171     return;
 172
 173   const Expr *WarnExpr;
 174   SourceLocation Loc;
 175   SourceRange R1, R2;
 176   if (SourceMgr.isInSystemMacro(E->getExprLoc()) ||
 177       !E->isUnusedResultAWarning(WarnExpr, Loc, R1, R2, Context))
 178     return;
 179
 180   // Okay, we have an unused result.  Depending on what the base expression is,
 181   // we might want to make a more specific diagnostic.  Check for one of these
 182   // cases now.
 183   unsigned DiagID = diag::warn_unused_expr;
 184   if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E))
 185     E = Temps->getSubExpr();
 186   if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
 187     E = TempExpr->getSubExpr();
 188
 189   if (DiagnoseUnusedComparison(*this, E))
 190     return;
 191
 192   E = WarnExpr;
 193   if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
 194     if (E->getType()->isVoidType())
 195       return;
 196
 197     // If the callee has attribute pure, const, or warn_unused_result, warn with
 198     // a more specific message to make it clear what is happening.
 199     if (const Decl *FD = CE->getCalleeDecl()) {
 200       if (FD->getAttr<WarnUnusedResultAttr>()) {
 201         Diag(Loc, diag::warn_unused_result) << R1 << R2;
 202         return;
 203       }
 204       if (FD->getAttr<PureAttr>()) {
 205         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
 206         return;
 207       }
 208       if (FD->getAttr<ConstAttr>()) {
 209         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
 210         return;
 211       }
 212     }
 213   } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
 214     if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
 215       Diag(Loc, diag::err_arc_unused_init_message) << R1;
 216       return;
 217     }
 218     const ObjCMethodDecl *MD = ME->getMethodDecl();
 219     if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
 220       Diag(Loc, diag::warn_unused_result) << R1 << R2;
 221       return;
 222     }
 223   } else if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
 224     const Expr *Source = POE->getSyntacticForm();
 225     if (isa<ObjCSubscriptRefExpr>(Source))
 226       DiagID = diag::warn_unused_container_subscript_expr;
 227     else
 228       DiagID = diag::warn_unused_property_expr;
 229   } else if (const CXXFunctionalCastExpr *FC
 230                                        = dyn_cast<CXXFunctionalCastExpr>(E)) {
 231     if (isa<CXXConstructExpr>(FC->getSubExpr()) ||
 232         isa<CXXTemporaryObjectExpr>(FC->getSubExpr()))
 233       return;
 234   }
 235   // Diagnose "(void*) blah" as a typo for "(void) blah".
 236   else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
 237     TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
 238     QualType T = TI->getType();
 239
 240     // We really do want to use the non-canonical type here.
 241     if (T == Context.VoidPtrTy) {
 242       PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
 243
 244       Diag(Loc, diag::warn_unused_voidptr)
 245         << FixItHint::CreateRemoval(TL.getStarLoc());
 246       return;
 247     }
 248   }
 249
 250   if (E->isGLValue() && E->getType().isVolatileQualified()) {
 251     Diag(Loc, diag::warn_unused_volatile) << R1 << R2;
 252     return;
 253   }
 254
 255   DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
 256 }
 257
 258 void Sema::ActOnStartOfCompoundStmt() {
 259   PushCompoundScope();
 260 }
 261
 262 void Sema::ActOnFinishOfCompoundStmt() {
 263   PopCompoundScope();
 264 }
 265
 266 sema::CompoundScopeInfo &Sema::getCurCompoundScope() const {
 267   return getCurFunction()->CompoundScopes.back();
 268 }
 269
 270 StmtResult
 271 Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
 272                         MultiStmtArg elts, bool isStmtExpr) {
 273   unsigned NumElts = elts.size();
 274   Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
 275   // If we're in C89 mode, check that we don't have any decls after stmts.  If
 276   // so, emit an extension diagnostic.
 277   if (!getLangOpts().C99 && !getLangOpts().CPlusPlus) {
 278     // Note that __extension__ can be around a decl.
 279     unsigned i = 0;
 280     // Skip over all declarations.
 281     for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
 282       /*empty*/;
 283
 284     // We found the end of the list or a statement.  Scan for another declstmt.
 285     for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
 286       /*empty*/;
 287
 288     if (i != NumElts) {
 289       Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
 290       Diag(D->getLocation(), diag::ext_mixed_decls_code);
 291     }
 292   }
 293   // Warn about unused expressions in statements.
 294   for (unsigned i = 0; i != NumElts; ++i) {
 295     // Ignore statements that are last in a statement expression.
 296     if (isStmtExpr && i == NumElts - 1)
 297       continue;
 298
 299     DiagnoseUnusedExprResult(Elts[i]);
 300   }
 301
 302   // Check for suspicious empty body (null statement) in `for' and `while'
 303   // statements.  Don't do anything for template instantiations, this just adds
 304   // noise.
 305   if (NumElts != 0 && !CurrentInstantiationScope &&
 306       getCurCompoundScope().HasEmptyLoopBodies) {
 307     for (unsigned i = 0; i != NumElts - 1; ++i)
 308       DiagnoseEmptyLoopBody(Elts[i], Elts[i + 1]);
 309   }
 310
 311   return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
 312 }
 313
 314 StmtResult
 315 Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
 316                     SourceLocation DotDotDotLoc, Expr *RHSVal,
 317                     SourceLocation ColonLoc) {
 318   assert((LHSVal != 0) && "missing expression in case statement");
 319
 320   if (getCurFunction()->SwitchStack.empty()) {
 321     Diag(CaseLoc, diag::err_case_not_in_switch);
 322     return StmtError();
 323   }
 324
 325   if (!getLangOpts().CPlusPlus0x) {
 326     // C99 6.8.4.2p3: The expression shall be an integer constant.
 327     // However, GCC allows any evaluatable integer expression.
 328     if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent()) {
 329       LHSVal = VerifyIntegerConstantExpression(LHSVal).take();
 330       if (!LHSVal)
 331         return StmtError();
 332     }
 333
 334     // GCC extension: The expression shall be an integer constant.
 335
 336     if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent()) {
 337       RHSVal = VerifyIntegerConstantExpression(RHSVal).take();
 338       // Recover from an error by just forgetting about it.
 339     }
 340   }
 341
 342   CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
 343                                         ColonLoc);
 344   getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
 345   return Owned(CS);
 346 }
 347
 348 /// ActOnCaseStmtBody - This installs a statement as the body of a case.
 349 void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
 350   DiagnoseUnusedExprResult(SubStmt);
 351
 352   CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
 353   CS->setSubStmt(SubStmt);
 354 }
 355
 356 StmtResult
 357 Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
 358                        Stmt *SubStmt, Scope *CurScope) {
 359   DiagnoseUnusedExprResult(SubStmt);
 360
 361   if (getCurFunction()->SwitchStack.empty()) {
 362     Diag(DefaultLoc, diag::err_default_not_in_switch);
 363     return Owned(SubStmt);
 364   }
 365
 366   DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
 367   getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
 368   return Owned(DS);
 369 }
 370
 371 StmtResult
 372 Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
 373                      SourceLocation ColonLoc, Stmt *SubStmt) {
 374   // If the label was multiply defined, reject it now.
 375   if (TheDecl->getStmt()) {
 376     Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
 377     Diag(TheDecl->getLocation(), diag::note_previous_definition);
 378     return Owned(SubStmt);
 379   }
 380
 381   // Otherwise, things are good.  Fill in the declaration and return it.
 382   LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
 383   TheDecl->setStmt(LS);
 384   if (!TheDecl->isGnuLocal())
 385     TheDecl->setLocation(IdentLoc);
 386   return Owned(LS);
 387 }
 388
 389 StmtResult Sema::ActOnAttributedStmt(SourceLocation AttrLoc,
 390                                      ArrayRef<const Attr*> Attrs,
 391                                      Stmt *SubStmt) {
 392   // Fill in the declaration and return it.
 393   AttributedStmt *LS = AttributedStmt::Create(Context, AttrLoc, Attrs, SubStmt);
 394   return Owned(LS);
 395 }
 396
 397 StmtResult
 398 Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
 399                   Stmt *thenStmt, SourceLocation ElseLoc,
 400                   Stmt *elseStmt) {
 401   ExprResult CondResult(CondVal.release());
 402
 403   VarDecl *ConditionVar = 0;
 404   if (CondVar) {
 405     ConditionVar = cast<VarDecl>(CondVar);
 406     CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
 407     if (CondResult.isInvalid())
 408       return StmtError();
 409   }
 410   Expr *ConditionExpr = CondResult.takeAs<Expr>();
 411   if (!ConditionExpr)
 412     return StmtError();
 413
 414   DiagnoseUnusedExprResult(thenStmt);
 415
 416   if (!elseStmt) {
 417     DiagnoseEmptyStmtBody(ConditionExpr->getLocEnd(), thenStmt,
 418                           diag::warn_empty_if_body);
 419   }
 420
 421   DiagnoseUnusedExprResult(elseStmt);
 422
 423   return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
 424                                     thenStmt, ElseLoc, elseStmt));
 425 }
 426
 427 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
 428 /// the specified width and sign.  If an overflow occurs, detect it and emit
 429 /// the specified diagnostic.
 430 void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
 431                                               unsigned NewWidth, bool NewSign,
 432                                               SourceLocation Loc,
 433                                               unsigned DiagID) {
 434   // Perform a conversion to the promoted condition type if needed.
 435   if (NewWidth > Val.getBitWidth()) {
 436     // If this is an extension, just do it.
 437     Val = Val.extend(NewWidth);
 438     Val.setIsSigned(NewSign);
 439
 440     // If the input was signed and negative and the output is
 441     // unsigned, don't bother to warn: this is implementation-defined
 442     // behavior.
 443     // FIXME: Introduce a second, default-ignored warning for this case?
 444   } else if (NewWidth < Val.getBitWidth()) {
 445     // If this is a truncation, check for overflow.
 446     llvm::APSInt ConvVal(Val);
 447     ConvVal = ConvVal.trunc(NewWidth);
 448     ConvVal.setIsSigned(NewSign);
 449     ConvVal = ConvVal.extend(Val.getBitWidth());
 450     ConvVal.setIsSigned(Val.isSigned());
 451     if (ConvVal != Val)
 452       Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
 453
 454     // Regardless of whether a diagnostic was emitted, really do the
 455     // truncation.
 456     Val = Val.trunc(NewWidth);
 457     Val.setIsSigned(NewSign);
 458   } else if (NewSign != Val.isSigned()) {
 459     // Convert the sign to match the sign of the condition.  This can cause
 460     // overflow as well: unsigned(INTMIN)
 461     // We don't diagnose this overflow, because it is implementation-defined
 462     // behavior.
 463     // FIXME: Introduce a second, default-ignored warning for this case?
 464     llvm::APSInt OldVal(Val);
 465     Val.setIsSigned(NewSign);
 466   }
 467 }
 468
 469 namespace {
 470   struct CaseCompareFunctor {
 471     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
 472                     const llvm::APSInt &RHS) {
 473       return LHS.first < RHS;
 474     }
 475     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
 476                     const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
 477       return LHS.first < RHS.first;
 478     }
 479     bool operator()(const llvm::APSInt &LHS,
 480                     const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
 481       return LHS < RHS.first;
 482     }
 483   };
 484 }
 485
 486 /// CmpCaseVals - Comparison predicate for sorting case values.
 487 ///
 488 static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
 489                         const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
 490   if (lhs.first < rhs.first)
 491     return true;
 492
 493   if (lhs.first == rhs.first &&
 494       lhs.second->getCaseLoc().getRawEncoding()
 495        < rhs.second->getCaseLoc().getRawEncoding())
 496     return true;
 497   return false;
 498 }
 499
 500 /// CmpEnumVals - Comparison predicate for sorting enumeration values.
 501 ///
 502 static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
 503                         const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
 504 {
 505   return lhs.first < rhs.first;
 506 }
 507
 508 /// EqEnumVals - Comparison preficate for uniqing enumeration values.
 509 ///
 510 static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
 511                        const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
 512 {
 513   return lhs.first == rhs.first;
 514 }
 515
 516 /// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
 517 /// potentially integral-promoted expression @p expr.
 518 static QualType GetTypeBeforeIntegralPromotion(Expr *&expr) {
 519   if (ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(expr))
 520     expr = cleanups->getSubExpr();
 521   while (ImplicitCastExpr *impcast = dyn_cast<ImplicitCastExpr>(expr)) {
 522     if (impcast->getCastKind() != CK_IntegralCast) break;
 523     expr = impcast->getSubExpr();
 524   }
 525   return expr->getType();
 526 }
 527
 528 StmtResult
 529 Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
 530                              Decl *CondVar) {
 531   ExprResult CondResult;
 532
 533   VarDecl *ConditionVar = 0;
 534   if (CondVar) {
 535     ConditionVar = cast<VarDecl>(CondVar);
 536     CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
 537     if (CondResult.isInvalid())
 538       return StmtError();
 539
 540     Cond = CondResult.release();
 541   }
 542
 543   if (!Cond)
 544     return StmtError();
 545
 546   class SwitchConvertDiagnoser : public ICEConvertDiagnoser {
 547     Expr *Cond;
 548
 549   public:
 550     SwitchConvertDiagnoser(Expr *Cond)
 551       : ICEConvertDiagnoser(false, true), Cond(Cond) { }
 552
 553     virtual DiagnosticBuilder diagnoseNotInt(Sema &S, SourceLocation Loc,
 554                                              QualType T) {
 555       return S.Diag(Loc, diag::err_typecheck_statement_requires_integer) << T;
 556     }
 557
 558     virtual DiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
 559                                                  QualType T) {
 560       return S.Diag(Loc, diag::err_switch_incomplete_class_type)
 561                << T << Cond->getSourceRange();
 562     }
 563
 564     virtual DiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
 565                                                    QualType T,
 566                                                    QualType ConvTy) {
 567       return S.Diag(Loc, diag::err_switch_explicit_conversion) << T << ConvTy;
 568     }
 569
 570     virtual DiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
 571                                                QualType ConvTy) {
 572       return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
 573         << ConvTy->isEnumeralType() << ConvTy;
 574     }
 575
 576     virtual DiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
 577                                                 QualType T) {
 578       return S.Diag(Loc, diag::err_switch_multiple_conversions) << T;
 579     }
 580
 581     virtual DiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
 582                                             QualType ConvTy) {
 583       return S.Diag(Conv->getLocation(), diag::note_switch_conversion)
 584       << ConvTy->isEnumeralType() << ConvTy;
 585     }
 586
 587     virtual DiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
 588                                                  QualType T,
 589                                                  QualType ConvTy) {
 590       return DiagnosticBuilder::getEmpty();
 591     }
 592   } SwitchDiagnoser(Cond);
 593
 594   CondResult
 595     = ConvertToIntegralOrEnumerationType(SwitchLoc, Cond, SwitchDiagnoser,
 596                                          /*AllowScopedEnumerations*/ true);
 597   if (CondResult.isInvalid()) return StmtError();
 598   Cond = CondResult.take();
 599
 600   // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
 601   CondResult = UsualUnaryConversions(Cond);
 602   if (CondResult.isInvalid()) return StmtError();
 603   Cond = CondResult.take();
 604
 605   if (!CondVar) {
 606     CheckImplicitConversions(Cond, SwitchLoc);
 607     CondResult = MaybeCreateExprWithCleanups(Cond);
 608     if (CondResult.isInvalid())
 609       return StmtError();
 610     Cond = CondResult.take();
 611   }
 612
 613   getCurFunction()->setHasBranchIntoScope();
 614
 615   SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
 616   getCurFunction()->SwitchStack.push_back(SS);
 617   return Owned(SS);
 618 }
 619
 620 static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
 621   if (Val.getBitWidth() < BitWidth)
 622     Val = Val.extend(BitWidth);
 623   else if (Val.getBitWidth() > BitWidth)
 624     Val = Val.trunc(BitWidth);
 625   Val.setIsSigned(IsSigned);
 626 }
 627
 628 StmtResult
 629 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
 630                             Stmt *BodyStmt) {
 631   SwitchStmt *SS = cast<SwitchStmt>(Switch);
 632   assert(SS == getCurFunction()->SwitchStack.back() &&
 633          "switch stack missing push/pop!");
 634
 635   SS->setBody(BodyStmt, SwitchLoc);
 636   getCurFunction()->SwitchStack.pop_back();
 637
 638   Expr *CondExpr = SS->getCond();
 639   if (!CondExpr) return StmtError();
 640
 641   QualType CondType = CondExpr->getType();
 642
 643   Expr *CondExprBeforePromotion = CondExpr;
 644   QualType CondTypeBeforePromotion =
 645       GetTypeBeforeIntegralPromotion(CondExprBeforePromotion);
 646
 647   // C++ 6.4.2.p2:
 648   // Integral promotions are performed (on the switch condition).
 649   //
 650   // A case value unrepresentable by the original switch condition
 651   // type (before the promotion) doesn't make sense, even when it can
 652   // be represented by the promoted type.  Therefore we need to find
 653   // the pre-promotion type of the switch condition.
 654   if (!CondExpr->isTypeDependent()) {
 655     // We have already converted the expression to an integral or enumeration
 656     // type, when we started the switch statement. If we don't have an
 657     // appropriate type now, just return an error.
 658     if (!CondType->isIntegralOrEnumerationType())
 659       return StmtError();
 660
 661     if (CondExpr->isKnownToHaveBooleanValue()) {
 662       // switch(bool_expr) {...} is often a programmer error, e.g.
 663       //   switch(n && mask) { ... }  // Doh - should be "n & mask".
 664       // One can always use an if statement instead of switch(bool_expr).
 665       Diag(SwitchLoc, diag::warn_bool_switch_condition)
 666           << CondExpr->getSourceRange();
 667     }
 668   }
 669
 670   // Get the bitwidth of the switched-on value before promotions.  We must
 671   // convert the integer case values to this width before comparison.
 672   bool HasDependentValue
 673     = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
 674   unsigned CondWidth
 675     = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
 676   bool CondIsSigned
 677     = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
 678
 679   // Accumulate all of the case values in a vector so that we can sort them
 680   // and detect duplicates.  This vector contains the APInt for the case after
 681   // it has been converted to the condition type.
 682   typedef SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
 683   CaseValsTy CaseVals;
 684
 685   // Keep track of any GNU case ranges we see.  The APSInt is the low value.
 686   typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
 687   CaseRangesTy CaseRanges;
 688
 689   DefaultStmt *TheDefaultStmt = 0;
 690
 691   bool CaseListIsErroneous = false;
 692
 693   for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
 694        SC = SC->getNextSwitchCase()) {
 695
 696     if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
 697       if (TheDefaultStmt) {
 698         Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
 699         Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
 700
 701         // FIXME: Remove the default statement from the switch block so that
 702         // we'll return a valid AST.  This requires recursing down the AST and
 703         // finding it, not something we are set up to do right now.  For now,
 704         // just lop the entire switch stmt out of the AST.
 705         CaseListIsErroneous = true;
 706       }
 707       TheDefaultStmt = DS;
 708
 709     } else {
 710       CaseStmt *CS = cast<CaseStmt>(SC);
 711
 712       Expr *Lo = CS->getLHS();
 713
 714       if (Lo->isTypeDependent() || Lo->isValueDependent()) {
 715         HasDependentValue = true;
 716         break;
 717       }
 718
 719       llvm::APSInt LoVal;
 720
 721       if (getLangOpts().CPlusPlus0x) {
 722         // C++11 [stmt.switch]p2: the constant-expression shall be a converted
 723         // constant expression of the promoted type of the switch condition.
 724         ExprResult ConvLo =
 725           CheckConvertedConstantExpression(Lo, CondType, LoVal, CCEK_CaseValue);
 726         if (ConvLo.isInvalid()) {
 727           CaseListIsErroneous = true;
 728           continue;
 729         }
 730         Lo = ConvLo.take();
 731       } else {
 732         // We already verified that the expression has a i-c-e value (C99
 733         // 6.8.4.2p3) - get that value now.
 734         LoVal = Lo->EvaluateKnownConstInt(Context);
 735
 736         // If the LHS is not the same type as the condition, insert an implicit
 737         // cast.
 738         Lo = DefaultLvalueConversion(Lo).take();
 739         Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
 740       }
 741
 742       // Convert the value to the same width/sign as the condition had prior to
 743       // integral promotions.
 744       //
 745       // FIXME: This causes us to reject valid code:
 746       //   switch ((char)c) { case 256: case 0: return 0; }
 747       // Here we claim there is a duplicated condition value, but there is not.
 748       ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
 749                                          Lo->getLocStart(),
 750                                          diag::warn_case_value_overflow);
 751
 752       CS->setLHS(Lo);
 753
 754       // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
 755       if (CS->getRHS()) {
 756         if (CS->getRHS()->isTypeDependent() ||
 757             CS->getRHS()->isValueDependent()) {
 758           HasDependentValue = true;
 759           break;
 760         }
 761         CaseRanges.push_back(std::make_pair(LoVal, CS));
 762       } else
 763         CaseVals.push_back(std::make_pair(LoVal, CS));
 764     }
 765   }
 766
 767   if (!HasDependentValue) {
 768     // If we don't have a default statement, check whether the
 769     // condition is constant.
 770     llvm::APSInt ConstantCondValue;
 771     bool HasConstantCond = false;
 772     if (!HasDependentValue && !TheDefaultStmt) {
 773       HasConstantCond
 774         = CondExprBeforePromotion->EvaluateAsInt(ConstantCondValue, Context,
 775                                                  Expr::SE_AllowSideEffects);
 776       assert(!HasConstantCond ||
 777              (ConstantCondValue.getBitWidth() == CondWidth &&
 778               ConstantCondValue.isSigned() == CondIsSigned));
 779     }
 780     bool ShouldCheckConstantCond = HasConstantCond;
 781
 782     // Sort all the scalar case values so we can easily detect duplicates.
 783     std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
 784
 785     if (!CaseVals.empty()) {
 786       for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
 787         if (ShouldCheckConstantCond &&
 788             CaseVals[i].first == ConstantCondValue)
 789           ShouldCheckConstantCond = false;
 790
 791         if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
 792           // If we have a duplicate, report it.
 793           // First, determine if either case value has a name
 794           StringRef PrevString, CurrString;
 795           Expr *PrevCase = CaseVals[i-1].second->getLHS()->IgnoreParenCasts();
 796           Expr *CurrCase = CaseVals[i].second->getLHS()->IgnoreParenCasts();
 797           if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(PrevCase)) {
 798             PrevString = DeclRef->getDecl()->getName();
 799           }
 800           if (DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(CurrCase)) {
 801             CurrString = DeclRef->getDecl()->getName();
 802           }
 803           llvm::SmallString<16> CaseValStr;
 804           CaseVals[i-1].first.toString(CaseValStr);
 805
 806           if (PrevString == CurrString)
 807             Diag(CaseVals[i].second->getLHS()->getLocStart(),
 808                  diag::err_duplicate_case) <<
 809                  (PrevString.empty() ? CaseValStr.str() : PrevString);
 810           else
 811             Diag(CaseVals[i].second->getLHS()->getLocStart(),
 812                  diag::err_duplicate_case_differing_expr) <<
 813                  (PrevString.empty() ? CaseValStr.str() : PrevString) <<
 814                  (CurrString.empty() ? CaseValStr.str() : CurrString) <<
 815                  CaseValStr;
 816
 817           Diag(CaseVals[i-1].second->getLHS()->getLocStart(),
 818                diag::note_duplicate_case_prev);
 819           // FIXME: We really want to remove the bogus case stmt from the
 820           // substmt, but we have no way to do this right now.
 821           CaseListIsErroneous = true;
 822         }
 823       }
 824     }
 825
 826     // Detect duplicate case ranges, which usually don't exist at all in
 827     // the first place.
 828     if (!CaseRanges.empty()) {
 829       // Sort all the case ranges by their low value so we can easily detect
 830       // overlaps between ranges.
 831       std::stable_sort(CaseRanges.begin(), CaseRanges.end());
 832
 833       // Scan the ranges, computing the high values and removing empty ranges.
 834       std::vector<llvm::APSInt> HiVals;
 835       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
 836         llvm::APSInt &LoVal = CaseRanges[i].first;
 837         CaseStmt *CR = CaseRanges[i].second;
 838         Expr *Hi = CR->getRHS();
 839         llvm::APSInt HiVal;
 840
 841         if (getLangOpts().CPlusPlus0x) {
 842           // C++11 [stmt.switch]p2: the constant-expression shall be a converted
 843           // constant expression of the promoted type of the switch condition.
 844           ExprResult ConvHi =
 845             CheckConvertedConstantExpression(Hi, CondType, HiVal,
 846                                              CCEK_CaseValue);
 847           if (ConvHi.isInvalid()) {
 848             CaseListIsErroneous = true;
 849             continue;
 850           }
 851           Hi = ConvHi.take();
 852         } else {
 853           HiVal = Hi->EvaluateKnownConstInt(Context);
 854
 855           // If the RHS is not the same type as the condition, insert an
 856           // implicit cast.
 857           Hi = DefaultLvalueConversion(Hi).take();
 858           Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
 859         }
 860
 861         // Convert the value to the same width/sign as the condition.
 862         ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
 863                                            Hi->getLocStart(),
 864                                            diag::warn_case_value_overflow);
 865
 866         CR->setRHS(Hi);
 867
 868         // If the low value is bigger than the high value, the case is empty.
 869         if (LoVal > HiVal) {
 870           Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
 871             << SourceRange(CR->getLHS()->getLocStart(),
 872                            Hi->getLocEnd());
 873           CaseRanges.erase(CaseRanges.begin()+i);
 874           --i, --e;
 875           continue;
 876         }
 877
 878         if (ShouldCheckConstantCond &&
 879             LoVal <= ConstantCondValue &&
 880             ConstantCondValue <= HiVal)
 881           ShouldCheckConstantCond = false;
 882
 883         HiVals.push_back(HiVal);
 884       }
 885
 886       // Rescan the ranges, looking for overlap with singleton values and other
 887       // ranges.  Since the range list is sorted, we only need to compare case
 888       // ranges with their neighbors.
 889       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
 890         llvm::APSInt &CRLo = CaseRanges[i].first;
 891         llvm::APSInt &CRHi = HiVals[i];
 892         CaseStmt *CR = CaseRanges[i].second;
 893
 894         // Check to see whether the case range overlaps with any
 895         // singleton cases.
 896         CaseStmt *OverlapStmt = 0;
 897         llvm::APSInt OverlapVal(32);
 898
 899         // Find the smallest value >= the lower bound.  If I is in the
 900         // case range, then we have overlap.
 901         CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
 902                                                   CaseVals.end(), CRLo,
 903                                                   CaseCompareFunctor());
 904         if (I != CaseVals.end() && I->first < CRHi) {
 905           OverlapVal  = I->first;   // Found overlap with scalar.
 906           OverlapStmt = I->second;
 907         }
 908
 909         // Find the smallest value bigger than the upper bound.
 910         I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
 911         if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
 912           OverlapVal  = (I-1)->first;      // Found overlap with scalar.
 913           OverlapStmt = (I-1)->second;
 914         }
 915
 916         // Check to see if this case stmt overlaps with the subsequent
 917         // case range.
 918         if (i && CRLo <= HiVals[i-1]) {
 919           OverlapVal  = HiVals[i-1];       // Found overlap with range.
 920           OverlapStmt = CaseRanges[i-1].second;
 921         }
 922
 923         if (OverlapStmt) {
 924           // If we have a duplicate, report it.
 925           Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
 926             << OverlapVal.toString(10);
 927           Diag(OverlapStmt->getLHS()->getLocStart(),
 928                diag::note_duplicate_case_prev);
 929           // FIXME: We really want to remove the bogus case stmt from the
 930           // substmt, but we have no way to do this right now.
 931           CaseListIsErroneous = true;
 932         }
 933       }
 934     }
 935
 936     // Complain if we have a constant condition and we didn't find a match.
 937     if (!CaseListIsErroneous && ShouldCheckConstantCond) {
 938       // TODO: it would be nice if we printed enums as enums, chars as
 939       // chars, etc.
 940       Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
 941         << ConstantCondValue.toString(10)
 942         << CondExpr->getSourceRange();
 943     }
 944
 945     // Check to see if switch is over an Enum and handles all of its
 946     // values.  We only issue a warning if there is not 'default:', but
 947     // we still do the analysis to preserve this information in the AST
 948     // (which can be used by flow-based analyes).
 949     //
 950     const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
 951
 952     // If switch has default case, then ignore it.
 953     if (!CaseListIsErroneous  && !HasConstantCond && ET) {
 954       const EnumDecl *ED = ET->getDecl();
 955       typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
 956         EnumValsTy;
 957       EnumValsTy EnumVals;
 958
 959       // Gather all enum values, set their type and sort them,
 960       // allowing easier comparison with CaseVals.
 961       for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
 962            EDI != ED->enumerator_end(); ++EDI) {
 963         llvm::APSInt Val = EDI->getInitVal();
 964         AdjustAPSInt(Val, CondWidth, CondIsSigned);
 965         EnumVals.push_back(std::make_pair(Val, *EDI));
 966       }
 967       std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
 968       EnumValsTy::iterator EIend =
 969         std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
 970
 971       // See which case values aren't in enum.
 972       EnumValsTy::const_iterator EI = EnumVals.begin();
 973       for (CaseValsTy::const_iterator CI = CaseVals.begin();
 974            CI != CaseVals.end(); CI++) {
 975         while (EI != EIend && EI->first < CI->first)
 976           EI++;
 977         if (EI == EIend || EI->first > CI->first)
 978           Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
 979             << CondTypeBeforePromotion;
 980       }
 981       // See which of case ranges aren't in enum
 982       EI = EnumVals.begin();
 983       for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
 984            RI != CaseRanges.end() && EI != EIend; RI++) {
 985         while (EI != EIend && EI->first < RI->first)
 986           EI++;
 987
 988         if (EI == EIend || EI->first != RI->first) {
 989           Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
 990             << CondTypeBeforePromotion;
 991         }
 992
 993         llvm::APSInt Hi =
 994           RI->second->getRHS()->EvaluateKnownConstInt(Context);
 995         AdjustAPSInt(Hi, CondWidth, CondIsSigned);
 996         while (EI != EIend && EI->first < Hi)
 997           EI++;
 998         if (EI == EIend || EI->first != Hi)
 999           Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
1000             << CondTypeBeforePromotion;
1001       }
1002
1003       // Check which enum vals aren't in switch
1004       CaseValsTy::const_iterator CI = CaseVals.begin();
1005       CaseRangesTy::const_iterator RI = CaseRanges.begin();
1006       bool hasCasesNotInSwitch = false;
1007
1008       SmallVector<DeclarationName,8> UnhandledNames;
1009
1010       for (EI = EnumVals.begin(); EI != EIend; EI++){
1011         // Drop unneeded case values
1012         llvm::APSInt CIVal;
1013         while (CI != CaseVals.end() && CI->first < EI->first)
1014           CI++;
1015
1016         if (CI != CaseVals.end() && CI->first == EI->first)
1017           continue;
1018
1019         // Drop unneeded case ranges
1020         for (; RI != CaseRanges.end(); RI++) {
1021           llvm::APSInt Hi =
1022             RI->second->getRHS()->EvaluateKnownConstInt(Context);
1023           AdjustAPSInt(Hi, CondWidth, CondIsSigned);
1024           if (EI->first <= Hi)
1025             break;
1026         }
1027
1028         if (RI == CaseRanges.end() || EI->first < RI->first) {
1029           hasCasesNotInSwitch = true;
1030           UnhandledNames.push_back(EI->second->getDeclName());
1031         }
1032       }
1033
1034       if (TheDefaultStmt && UnhandledNames.empty())
1035         Diag(TheDefaultStmt->getDefaultLoc(), diag::warn_unreachable_default);
1036
1037       // Produce a nice diagnostic if multiple values aren't handled.
1038       switch (UnhandledNames.size()) {
1039       case 0: break;
1040       case 1:
1041         Diag(CondExpr->getExprLoc(), TheDefaultStmt
1042           ? diag::warn_def_missing_case1 : diag::warn_missing_case1)
1043           << UnhandledNames[0];
1044         break;
1045       case 2:
1046         Diag(CondExpr->getExprLoc(), TheDefaultStmt
1047           ? diag::warn_def_missing_case2 : diag::warn_missing_case2)
1048           << UnhandledNames[0] << UnhandledNames[1];
1049         break;
1050       case 3:
1051         Diag(CondExpr->getExprLoc(), TheDefaultStmt
1052           ? diag::warn_def_missing_case3 : diag::warn_missing_case3)
1053           << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
1054         break;
1055       default:
1056         Diag(CondExpr->getExprLoc(), TheDefaultStmt
1057           ? diag::warn_def_missing_cases : diag::warn_missing_cases)
1058           << (unsigned)UnhandledNames.size()
1059           << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
1060         break;
1061       }
1062
1063       if (!hasCasesNotInSwitch)
1064         SS->setAllEnumCasesCovered();
1065     }
1066   }
1067
1068   DiagnoseEmptyStmtBody(CondExpr->getLocEnd(), BodyStmt,
1069                         diag::warn_empty_switch_body);
1070
1071   // FIXME: If the case list was broken is some way, we don't have a good system
1072   // to patch it up.  Instead, just return the whole substmt as broken.
1073   if (CaseListIsErroneous)
1074     return StmtError();
1075
1076   return Owned(SS);
1077 }
1078
1079 void
1080 Sema::DiagnoseAssignmentEnum(QualType DstType, QualType SrcType,
1081                              Expr *SrcExpr) {
1082   unsigned DIAG = diag::warn_not_in_enum_assignement;
1083   if (Diags.getDiagnosticLevel(DIAG, SrcExpr->getExprLoc())
1084       == DiagnosticsEngine::Ignored)
1085     return;
1086
1087   if (const EnumType *ET = DstType->getAs<EnumType>())
1088     if (!Context.hasSameType(SrcType, DstType) &&
1089         SrcType->isIntegerType()) {
1090       if (!SrcExpr->isTypeDependent() && !SrcExpr->isValueDependent() &&
1091           SrcExpr->isIntegerConstantExpr(Context)) {
1092         // Get the bitwidth of the enum value before promotions.
1093         unsigned DstWith = Context.getIntWidth(DstType);
1094         bool DstIsSigned = DstType->isSignedIntegerOrEnumerationType();
1095
1096         llvm::APSInt RhsVal = SrcExpr->EvaluateKnownConstInt(Context);
1097         const EnumDecl *ED = ET->getDecl();
1098         typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
1099         EnumValsTy;
1100         EnumValsTy EnumVals;
1101
1102         // Gather all enum values, set their type and sort them,
1103         // allowing easier comparison with rhs constant.
1104         for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
1105              EDI != ED->enumerator_end(); ++EDI) {
1106           llvm::APSInt Val = EDI->getInitVal();
1107           AdjustAPSInt(Val, DstWith, DstIsSigned);
1108           EnumVals.push_back(std::make_pair(Val, *EDI));
1109         }
1110         if (EnumVals.empty())
1111           return;
1112         std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
1113         EnumValsTy::iterator EIend =
1114         std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
1115
1116         // See which case values aren't in enum.
1117         EnumValsTy::const_iterator EI = EnumVals.begin();
1118         while (EI != EIend && EI->first < RhsVal)
1119           EI++;
1120         if (EI == EIend || EI->first != RhsVal) {
1121           Diag(SrcExpr->getExprLoc(), diag::warn_not_in_enum_assignement)
1122           << DstType;
1123         }
1124       }
1125     }
1126 }
1127
1128 StmtResult
1129 Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
1130                      Decl *CondVar, Stmt *Body) {
1131   ExprResult CondResult(Cond.release());
1132
1133   VarDecl *ConditionVar = 0;
1134   if (CondVar) {
1135     ConditionVar = cast<VarDecl>(CondVar);
1136     CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
1137     if (CondResult.isInvalid())
1138       return StmtError();
1139   }
1140   Expr *ConditionExpr = CondResult.take();
1141   if (!ConditionExpr)
1142     return StmtError();
1143
1144   DiagnoseUnusedExprResult(Body);
1145
1146   if (isa<NullStmt>(Body))
1147     getCurCompoundScope().setHasEmptyLoopBodies();
1148
1149   return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
1150                                        Body, WhileLoc));
1151 }
1152
1153 StmtResult
1154 Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
1155                   SourceLocation WhileLoc, SourceLocation CondLParen,
1156                   Expr *Cond, SourceLocation CondRParen) {
1157   assert(Cond && "ActOnDoStmt(): missing expression");
1158
1159   ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
1160   if (CondResult.isInvalid() || CondResult.isInvalid())
1161     return StmtError();
1162   Cond = CondResult.take();
1163
1164   CheckImplicitConversions(Cond, DoLoc);
1165   CondResult = MaybeCreateExprWithCleanups(Cond);
1166   if (CondResult.isInvalid())
1167     return StmtError();
1168   Cond = CondResult.take();
1169
1170   DiagnoseUnusedExprResult(Body);
1171
1172   return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
1173 }
1174
1175 namespace {
1176   // This visitor will traverse a conditional statement and store all
1177   // the evaluated decls into a vector.  Simple is set to true if none
1178   // of the excluded constructs are used.
1179   class DeclExtractor : public EvaluatedExprVisitor<DeclExtractor> {
1180     llvm::SmallPtrSet<VarDecl*, 8> &Decls;
1181     llvm::SmallVector<SourceRange, 10> &Ranges;
1182     bool Simple;
1183 public:
1184   typedef EvaluatedExprVisitor<DeclExtractor> Inherited;
1185
1186   DeclExtractor(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls,
1187                 llvm::SmallVector<SourceRange, 10> &Ranges) :
1188       Inherited(S.Context),
1189       Decls(Decls),
1190       Ranges(Ranges),
1191       Simple(true) {}
1192
1193   bool isSimple() { return Simple; }
1194
1195   // Replaces the method in EvaluatedExprVisitor.
1196   void VisitMemberExpr(MemberExpr* E) {
1197     Simple = false;
1198   }
1199
1200   // Any Stmt not whitelisted will cause the condition to be marked complex.
1201   void VisitStmt(Stmt *S) {
1202     Simple = false;
1203   }
1204
1205   void VisitBinaryOperator(BinaryOperator *E) {
1206     Visit(E->getLHS());
1207     Visit(E->getRHS());
1208   }
1209
1210   void VisitCastExpr(CastExpr *E) {
1211     Visit(E->getSubExpr());
1212   }
1213
1214   void VisitUnaryOperator(UnaryOperator *E) {
1215     // Skip checking conditionals with derefernces.
1216     if (E->getOpcode() == UO_Deref)
1217       Simple = false;
1218     else
1219       Visit(E->getSubExpr());
1220   }
1221
1222   void VisitConditionalOperator(ConditionalOperator *E) {
1223     Visit(E->getCond());
1224     Visit(E->getTrueExpr());
1225     Visit(E->getFalseExpr());
1226   }
1227
1228   void VisitParenExpr(ParenExpr *E) {
1229     Visit(E->getSubExpr());
1230   }
1231
1232   void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1233     Visit(E->getOpaqueValue()->getSourceExpr());
1234     Visit(E->getFalseExpr());
1235   }
1236
1237   void VisitIntegerLiteral(IntegerLiteral *E) { }
1238   void VisitFloatingLiteral(FloatingLiteral *E) { }
1239   void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) { }
1240   void VisitCharacterLiteral(CharacterLiteral *E) { }
1241   void VisitGNUNullExpr(GNUNullExpr *E) { }
1242   void VisitImaginaryLiteral(ImaginaryLiteral *E) { }
1243
1244   void VisitDeclRefExpr(DeclRefExpr *E) {
1245     VarDecl *VD = dyn_cast<VarDecl>(E->getDecl());
1246     if (!VD) return;
1247
1248     Ranges.push_back(E->getSourceRange());
1249
1250     Decls.insert(VD);
1251   }
1252
1253   }; // end class DeclExtractor
1254
1255   // DeclMatcher checks to see if the decls are used in a non-evauluated
1256   // context.
1257   class DeclMatcher : public EvaluatedExprVisitor<DeclMatcher> {
1258     llvm::SmallPtrSet<VarDecl*, 8> &Decls;
1259     bool FoundDecl;
1260
1261 public:
1262   typedef EvaluatedExprVisitor<DeclMatcher> Inherited;
1263
1264   DeclMatcher(Sema &S, llvm::SmallPtrSet<VarDecl*, 8> &Decls, Stmt *Statement) :
1265       Inherited(S.Context), Decls(Decls), FoundDecl(false) {
1266     if (!Statement) return;
1267
1268     Visit(Statement);
1269   }
1270
1271   void VisitReturnStmt(ReturnStmt *S) {
1272     FoundDecl = true;
1273   }
1274
1275   void VisitBreakStmt(BreakStmt *S) {
1276     FoundDecl = true;
1277   }
1278
1279   void VisitGotoStmt(GotoStmt *S) {
1280     FoundDecl = true;
1281   }
1282
1283   void VisitCastExpr(CastExpr *E) {
1284     if (E->getCastKind() == CK_LValueToRValue)
1285       CheckLValueToRValueCast(E->getSubExpr());
1286     else
1287       Visit(E->getSubExpr());
1288   }
1289
1290   void CheckLValueToRValueCast(Expr *E) {
1291     E = E->IgnoreParenImpCasts();
1292
1293     if (isa<DeclRefExpr>(E)) {
1294       return;
1295     }
1296
1297     if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
1298       Visit(CO->getCond());
1299       CheckLValueToRValueCast(CO->getTrueExpr());
1300       CheckLValueToRValueCast(CO->getFalseExpr());
1301       return;
1302     }
1303
1304     if (BinaryConditionalOperator *BCO =
1305             dyn_cast<BinaryConditionalOperator>(E)) {
1306       CheckLValueToRValueCast(BCO->getOpaqueValue()->getSourceExpr());
1307       CheckLValueToRValueCast(BCO->getFalseExpr());
1308       return;
1309     }
1310
1311     Visit(E);
1312   }
1313
1314   void VisitDeclRefExpr(DeclRefExpr *E) {
1315     if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()))
1316       if (Decls.count(VD))
1317         FoundDecl = true;
1318   }
1319
1320   bool FoundDeclInUse() { return FoundDecl; }
1321
1322   };  // end class DeclMatcher
1323
1324   void CheckForLoopConditionalStatement(Sema &S, Expr *Second,
1325                                         Expr *Third, Stmt *Body) {
1326     // Condition is empty
1327     if (!Second) return;
1328
1329     if (S.Diags.getDiagnosticLevel(diag::warn_variables_not_in_loop_body,
1330                                    Second->getLocStart())
1331         == DiagnosticsEngine::Ignored)
1332       return;
1333
1334     PartialDiagnostic PDiag = S.PDiag(diag::warn_variables_not_in_loop_body);
1335     llvm::SmallPtrSet<VarDecl*, 8> Decls;
1336     llvm::SmallVector<SourceRange, 10> Ranges;
1337     DeclExtractor DE(S, Decls, Ranges);
1338     DE.Visit(Second);
1339
1340     // Don't analyze complex conditionals.
1341     if (!DE.isSimple()) return;
1342
1343     // No decls found.
1344     if (Decls.size() == 0) return;
1345
1346     // Don't warn on volatile, static, or global variables.
1347     for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(),
1348                                                   E = Decls.end();
1349          I != E; ++I)
1350       if ((*I)->getType().isVolatileQualified() ||
1351           (*I)->hasGlobalStorage()) return;
1352
1353     if (DeclMatcher(S, Decls, Second).FoundDeclInUse() ||
1354         DeclMatcher(S, Decls, Third).FoundDeclInUse() ||
1355         DeclMatcher(S, Decls, Body).FoundDeclInUse())
1356       return;
1357
1358     // Load decl names into diagnostic.
1359     if (Decls.size() > 4)
1360       PDiag << 0;
1361     else {
1362       PDiag << Decls.size();
1363       for (llvm::SmallPtrSet<VarDecl*, 8>::iterator I = Decls.begin(),
1364                                                     E = Decls.end();
1365            I != E; ++I)
1366         PDiag << (*I)->getDeclName();
1367     }
1368
1369     // Load SourceRanges into diagnostic if there is room.
1370     // Otherwise, load the SourceRange of the conditional expression.
1371     if (Ranges.size() <= PartialDiagnostic::MaxArguments)
1372       for (llvm::SmallVector<SourceRange, 10>::iterator I = Ranges.begin(),
1373                                                         E = Ranges.end();
1374            I != E; ++I)
1375         PDiag << *I;
1376     else
1377       PDiag << Second->getSourceRange();
1378
1379     S.Diag(Ranges.begin()->getBegin(), PDiag);
1380   }
1381
1382 } // end namespace
1383
1384 StmtResult
1385 Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1386                    Stmt *First, FullExprArg second, Decl *secondVar,
1387                    FullExprArg third,
1388                    SourceLocation RParenLoc, Stmt *Body) {
1389   if (!getLangOpts().CPlusPlus) {
1390     if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
1391       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
1392       // declare identifiers for objects having storage class 'auto' or
1393       // 'register'.
1394       for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
1395            DI!=DE; ++DI) {
1396         VarDecl *VD = dyn_cast<VarDecl>(*DI);
1397         if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
1398           VD = 0;
1399         if (VD == 0)
1400           Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
1401         // FIXME: mark decl erroneous!
1402       }
1403     }
1404   }
1405
1406   CheckForLoopConditionalStatement(*this, second.get(), third.get(), Body);
1407
1408   ExprResult SecondResult(second.release());
1409   VarDecl *ConditionVar = 0;
1410   if (secondVar) {
1411     ConditionVar = cast<VarDecl>(secondVar);
1412     SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
1413     if (SecondResult.isInvalid())
1414       return StmtError();
1415   }
1416
1417   Expr *Third  = third.release().takeAs<Expr>();
1418
1419   DiagnoseUnusedExprResult(First);
1420   DiagnoseUnusedExprResult(Third);
1421   DiagnoseUnusedExprResult(Body);
1422
1423   if (isa<NullStmt>(Body))
1424     getCurCompoundScope().setHasEmptyLoopBodies();
1425
1426   return Owned(new (Context) ForStmt(Context, First,
1427                                      SecondResult.take(), ConditionVar,
1428                                      Third, Body, ForLoc, LParenLoc,
1429                                      RParenLoc));
1430 }
1431
1432 /// In an Objective C collection iteration statement:
1433 ///   for (x in y)
1434 /// x can be an arbitrary l-value expression.  Bind it up as a
1435 /// full-expression.
1436 StmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
1437   // Reduce placeholder expressions here.  Note that this rejects the
1438   // use of pseudo-object l-values in this position.
1439   ExprResult result = CheckPlaceholderExpr(E);
1440   if (result.isInvalid()) return StmtError();
1441   E = result.take();
1442
1443   CheckImplicitConversions(E);
1444
1445   result = MaybeCreateExprWithCleanups(E);
1446   if (result.isInvalid()) return StmtError();
1447
1448   return Owned(static_cast<Stmt*>(result.take()));
1449 }
1450
1451 ExprResult
1452 Sema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {
1453   if (!collection)
1454     return ExprError();
1455
1456   // Bail out early if we've got a type-dependent expression.
1457   if (collection->isTypeDependent()) return Owned(collection);
1458
1459   // Perform normal l-value conversion.
1460   ExprResult result = DefaultFunctionArrayLvalueConversion(collection);
1461   if (result.isInvalid())
1462     return ExprError();
1463   collection = result.take();
1464
1465   // The operand needs to have object-pointer type.
1466   // TODO: should we do a contextual conversion?
1467   const ObjCObjectPointerType *pointerType =
1468     collection->getType()->getAs<ObjCObjectPointerType>();
1469   if (!pointerType)
1470     return Diag(forLoc, diag::err_collection_expr_type)
1471              << collection->getType() << collection->getSourceRange();
1472
1473   // Check that the operand provides
1474   //   - countByEnumeratingWithState:objects:count:
1475   const ObjCObjectType *objectType = pointerType->getObjectType();
1476   ObjCInterfaceDecl *iface = objectType->getInterface();
1477
1478   // If we have a forward-declared type, we can't do this check.
1479   // Under ARC, it is an error not to have a forward-declared class.
1480   if (iface &&
1481       RequireCompleteType(forLoc, QualType(objectType, 0),
1482                           getLangOpts().ObjCAutoRefCount
1483                             ? diag::err_arc_collection_forward
1484                             : 0,
1485                           collection)) {
1486     // Otherwise, if we have any useful type information, check that
1487     // the type declares the appropriate method.
1488   } else if (iface || !objectType->qual_empty()) {
1489     IdentifierInfo *selectorIdents[] = {
1490       &Context.Idents.get("countByEnumeratingWithState"),
1491       &Context.Idents.get("objects"),
1492       &Context.Idents.get("count")
1493     };
1494     Selector selector = Context.Selectors.getSelector(3, &selectorIdents[0]);
1495
1496     ObjCMethodDecl *method = 0;
1497
1498     // If there's an interface, look in both the public and private APIs.
1499     if (iface) {
1500       method = iface->lookupInstanceMethod(selector);
1501       if (!method) method = iface->lookupPrivateMethod(selector);
1502     }
1503
1504     // Also check protocol qualifiers.
1505     if (!method)
1506       method = LookupMethodInQualifiedType(selector, pointerType,
1507                                            /*instance*/ true);
1508
1509     // If we didn't find it anywhere, give up.
1510     if (!method) {
1511       Diag(forLoc, diag::warn_collection_expr_type)
1512         << collection->getType() << selector << collection->getSourceRange();
1513     }
1514
1515     // TODO: check for an incompatible signature?
1516   }
1517
1518   // Wrap up any cleanups in the expression.
1519   return Owned(MaybeCreateExprWithCleanups(collection));
1520 }
1521
1522 StmtResult
1523 Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
1524                                  Stmt *First, Expr *collection,
1525                                  SourceLocation RParenLoc) {
1526
1527   ExprResult CollectionExprResult =
1528     CheckObjCForCollectionOperand(ForLoc, collection);
1529
1530   if (First) {
1531     QualType FirstType;
1532     if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
1533       if (!DS->isSingleDecl())
1534         return StmtError(Diag((*DS->decl_begin())->getLocation(),
1535                          diag::err_toomany_element_decls));
1536
1537       VarDecl *D = cast<VarDecl>(DS->getSingleDecl());
1538       FirstType = D->getType();
1539       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
1540       // declare identifiers for objects having storage class 'auto' or
1541       // 'register'.
1542       if (!D->hasLocalStorage())
1543         return StmtError(Diag(D->getLocation(),
1544                               diag::err_non_variable_decl_in_for));
1545     } else {
1546       Expr *FirstE = cast<Expr>(First);
1547       if (!FirstE->isTypeDependent() && !FirstE->isLValue())
1548         return StmtError(Diag(First->getLocStart(),
1549                    diag::err_selector_element_not_lvalue)
1550           << First->getSourceRange());
1551
1552       FirstType = static_cast<Expr*>(First)->getType();
1553     }
1554     if (!FirstType->isDependentType() &&
1555         !FirstType->isObjCObjectPointerType() &&
1556         !FirstType->isBlockPointerType())
1557         return StmtError(Diag(ForLoc, diag::err_selector_element_type)
1558                            << FirstType << First->getSourceRange());
1559   }
1560
1561   if (CollectionExprResult.isInvalid())
1562     return StmtError();
1563
1564   return Owned(new (Context) ObjCForCollectionStmt(First,
1565                                                    CollectionExprResult.take(), 0,
1566                                                    ForLoc, RParenLoc));
1567 }
1568
1569 namespace {
1570
1571 enum BeginEndFunction {
1572   BEF_begin,
1573   BEF_end
1574 };
1575
1576 /// Build a variable declaration for a for-range statement.
1577 static VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
1578                                      QualType Type, const char *Name) {
1579   DeclContext *DC = SemaRef.CurContext;
1580   IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1581   TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1582   VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
1583                                   TInfo, SC_Auto, SC_None);
1584   Decl->setImplicit();
1585   return Decl;
1586 }
1587
1588 /// Finish building a variable declaration for a for-range statement.
1589 /// \return true if an error occurs.
1590 static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
1591                                   SourceLocation Loc, int diag) {
1592   // Deduce the type for the iterator variable now rather than leaving it to
1593   // AddInitializerToDecl, so we can produce a more suitable diagnostic.
1594   TypeSourceInfo *InitTSI = 0;
1595   if ((!isa<InitListExpr>(Init) && Init->getType()->isVoidType()) ||
1596       SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTSI) ==
1597           Sema::DAR_Failed)
1598     SemaRef.Diag(Loc, diag) << Init->getType();
1599   if (!InitTSI) {
1600     Decl->setInvalidDecl();
1601     return true;
1602   }
1603   Decl->setTypeSourceInfo(InitTSI);
1604   Decl->setType(InitTSI->getType());
1605
1606   // In ARC, infer lifetime.
1607   // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if
1608   // we're doing the equivalent of fast iteration.
1609   if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1610       SemaRef.inferObjCARCLifetime(Decl))
1611     Decl->setInvalidDecl();
1612
1613   SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1614                                /*TypeMayContainAuto=*/false);
1615   SemaRef.FinalizeDeclaration(Decl);
1616   SemaRef.CurContext->addHiddenDecl(Decl);
1617   return false;
1618 }
1619
1620 /// Produce a note indicating which begin/end function was implicitly called
1621 /// by a C++0x for-range statement. This is often not obvious from the code,
1622 /// nor from the diagnostics produced when analysing the implicit expressions
1623 /// required in a for-range statement.
1624 void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1625                                   BeginEndFunction BEF) {
1626   CallExpr *CE = dyn_cast<CallExpr>(E);
1627   if (!CE)
1628     return;
1629   FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1630   if (!D)
1631     return;
1632   SourceLocation Loc = D->getLocation();
1633
1634   std::string Description;
1635   bool IsTemplate = false;
1636   if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1637     Description = SemaRef.getTemplateArgumentBindingsText(
1638       FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1639     IsTemplate = true;
1640   }
1641
1642   SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1643     << BEF << IsTemplate << Description << E->getType();
1644 }
1645
1646 /// Build a call to 'begin' or 'end' for a C++0x for-range statement. If the
1647 /// given LookupResult is non-empty, it is assumed to describe a member which
1648 /// will be invoked. Otherwise, the function will be found via argument
1649 /// dependent lookup.
1650 static ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1651                                             SourceLocation Loc,
1652                                             VarDecl *Decl,
1653                                             BeginEndFunction BEF,
1654                                             const DeclarationNameInfo &NameInfo,
1655                                             LookupResult &MemberLookup,
1656                                             Expr *Range) {
1657   ExprResult CallExpr;
1658   if (!MemberLookup.empty()) {
1659     ExprResult MemberRef =
1660       SemaRef.BuildMemberReferenceExpr(Range, Range->getType(), Loc,
1661                                        /*IsPtr=*/false, CXXScopeSpec(),
1662                                        /*TemplateKWLoc=*/SourceLocation(),
1663                                        /*FirstQualifierInScope=*/0,
1664                                        MemberLookup,
1665                                        /*TemplateArgs=*/0);
1666     if (MemberRef.isInvalid())
1667       return ExprError();
1668     CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1669                                      Loc, 0);
1670     if (CallExpr.isInvalid())
1671       return ExprError();
1672   } else {
1673     UnresolvedSet<0> FoundNames;
1674     // C++0x [stmt.ranged]p1: For the purposes of this name lookup, namespace
1675     // std is an associated namespace.
1676     UnresolvedLookupExpr *Fn =
1677       UnresolvedLookupExpr::Create(SemaRef.Context, /*NamingClass=*/0,
1678                                    NestedNameSpecifierLoc(), NameInfo,
1679                                    /*NeedsADL=*/true, /*Overloaded=*/false,
1680                                    FoundNames.begin(), FoundNames.end(),
1681                                    /*LookInStdNamespace=*/true);
1682     CallExpr = SemaRef.BuildOverloadedCallExpr(S, Fn, Fn, Loc, &Range, 1, Loc,
1683                                                0, /*AllowTypoCorrection=*/false);
1684     if (CallExpr.isInvalid()) {
1685       SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1686         << Range->getType();
1687       return ExprError();
1688     }
1689   }
1690   if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1691                             diag::err_for_range_iter_deduction_failure)) {
1692     NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1693     return ExprError();
1694   }
1695   return CallExpr;
1696 }
1697
1698 }
1699
1700 static bool ObjCEnumerationCollection(Expr *Collection) {
1701   return !Collection->isTypeDependent()
1702           && Collection->getType()->getAs<ObjCObjectPointerType>() != 0;
1703 }
1704
1705 /// ActOnCXXForRangeStmt - Check and build a C++11 for-range statement.
1706 ///
1707 /// C++11 [stmt.ranged]:
1708 ///   A range-based for statement is equivalent to
1709 ///
1710 ///   {
1711 ///     auto && __range = range-init;
1712 ///     for ( auto __begin = begin-expr,
1713 ///           __end = end-expr;
1714 ///           __begin != __end;
1715 ///           ++__begin ) {
1716 ///       for-range-declaration = *__begin;
1717 ///       statement
1718 ///     }
1719 ///   }
1720 ///
1721 /// The body of the loop is not available yet, since it cannot be analysed until
1722 /// we have determined the type of the for-range-declaration.
1723 StmtResult
1724 Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc,
1725                            Stmt *First, SourceLocation ColonLoc, Expr *Range,
1726                            SourceLocation RParenLoc) {
1727   if (!First || !Range)
1728     return StmtError();
1729
1730   if (ObjCEnumerationCollection(Range))
1731     return ActOnObjCForCollectionStmt(ForLoc, First, Range, RParenLoc);
1732
1733   DeclStmt *DS = dyn_cast<DeclStmt>(First);
1734   assert(DS && "first part of for range not a decl stmt");
1735
1736   if (!DS->isSingleDecl()) {
1737     Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1738     return StmtError();
1739   }
1740   if (DS->getSingleDecl()->isInvalidDecl())
1741     return StmtError();
1742
1743   if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1744     return StmtError();
1745
1746   // Build  auto && __range = range-init
1747   SourceLocation RangeLoc = Range->getLocStart();
1748   VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1749                                            Context.getAutoRRefDeductType(),
1750                                            "__range");
1751   if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1752                             diag::err_for_range_deduction_failure))
1753     return StmtError();
1754
1755   // Claim the type doesn't contain auto: we've already done the checking.
1756   DeclGroupPtrTy RangeGroup =
1757     BuildDeclaratorGroup((Decl**)&RangeVar, 1, /*TypeMayContainAuto=*/false);
1758   StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
1759   if (RangeDecl.isInvalid())
1760     return StmtError();
1761
1762   return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1763                               /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1764                               RParenLoc);
1765 }
1766
1767 /// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1768 StmtResult
1769 Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1770                            Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1771                            Expr *Inc, Stmt *LoopVarDecl,
1772                            SourceLocation RParenLoc) {
1773   Scope *S = getCurScope();
1774
1775   DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1776   VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1777   QualType RangeVarType = RangeVar->getType();
1778
1779   DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1780   VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1781
1782   StmtResult BeginEndDecl = BeginEnd;
1783   ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1784
1785   if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1786     SourceLocation RangeLoc = RangeVar->getLocation();
1787
1788     const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType();
1789
1790     ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1791                                                 VK_LValue, ColonLoc);
1792     if (BeginRangeRef.isInvalid())
1793       return StmtError();
1794
1795     ExprResult EndRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1796                                               VK_LValue, ColonLoc);
1797     if (EndRangeRef.isInvalid())
1798       return StmtError();
1799
1800     QualType AutoType = Context.getAutoDeductType();
1801     Expr *Range = RangeVar->getInit();
1802     if (!Range)
1803       return StmtError();
1804     QualType RangeType = Range->getType();
1805
1806     if (RequireCompleteType(RangeLoc, RangeType,
1807                             diag::err_for_range_incomplete_type))
1808       return StmtError();
1809
1810     // Build auto __begin = begin-expr, __end = end-expr.
1811     VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1812                                              "__begin");
1813     VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1814                                            "__end");
1815
1816     // Build begin-expr and end-expr and attach to __begin and __end variables.
1817     ExprResult BeginExpr, EndExpr;
1818     if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
1819       // - if _RangeT is an array type, begin-expr and end-expr are __range and
1820       //   __range + __bound, respectively, where __bound is the array bound. If
1821       //   _RangeT is an array of unknown size or an array of incomplete type,
1822       //   the program is ill-formed;
1823
1824       // begin-expr is __range.
1825       BeginExpr = BeginRangeRef;
1826       if (FinishForRangeVarDecl(*this, BeginVar, BeginRangeRef.get(), ColonLoc,
1827                                 diag::err_for_range_iter_deduction_failure)) {
1828         NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1829         return StmtError();
1830       }
1831
1832       // Find the array bound.
1833       ExprResult BoundExpr;
1834       if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
1835         BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(),
1836                                                  Context.getPointerDiffType(),
1837                                                  RangeLoc));
1838       else if (const VariableArrayType *VAT =
1839                dyn_cast<VariableArrayType>(UnqAT))
1840         BoundExpr = VAT->getSizeExpr();
1841       else {
1842         // Can't be a DependentSizedArrayType or an IncompleteArrayType since
1843         // UnqAT is not incomplete and Range is not type-dependent.
1844         llvm_unreachable("Unexpected array type in for-range");
1845       }
1846
1847       // end-expr is __range + __bound.
1848       EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.get(),
1849                            BoundExpr.get());
1850       if (EndExpr.isInvalid())
1851         return StmtError();
1852       if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1853                                 diag::err_for_range_iter_deduction_failure)) {
1854         NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1855         return StmtError();
1856       }
1857     } else {
1858       DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1859                                         ColonLoc);
1860       DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1861                                       ColonLoc);
1862
1863       LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1864       LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1865
1866       if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
1867         // - if _RangeT is a class type, the unqualified-ids begin and end are
1868         //   looked up in the scope of class _RangeT as if by class member access
1869         //   lookup (3.4.5), and if either (or both) finds at least one
1870         //   declaration, begin-expr and end-expr are __range.begin() and
1871         //   __range.end(), respectively;
1872         LookupQualifiedName(BeginMemberLookup, D);
1873         LookupQualifiedName(EndMemberLookup, D);
1874
1875         if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1876           Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1877             << RangeType << BeginMemberLookup.empty();
1878           return StmtError();
1879         }
1880       } else {
1881         // - otherwise, begin-expr and end-expr are begin(__range) and
1882         //   end(__range), respectively, where begin and end are looked up with
1883         //   argument-dependent lookup (3.4.2). For the purposes of this name
1884         //   lookup, namespace std is an associated namespace.
1885       }
1886
1887       BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1888                                             BEF_begin, BeginNameInfo,
1889                                             BeginMemberLookup,
1890                                             BeginRangeRef.get());
1891       if (BeginExpr.isInvalid())
1892         return StmtError();
1893
1894       EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1895                                           BEF_end, EndNameInfo,
1896                                           EndMemberLookup, EndRangeRef.get());
1897       if (EndExpr.isInvalid())
1898         return StmtError();
1899     }
1900
1901     // C++0x [decl.spec.auto]p6: BeginType and EndType must be the same.
1902     QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
1903     if (!Context.hasSameType(BeginType, EndType)) {
1904       Diag(RangeLoc, diag::err_for_range_begin_end_types_differ)
1905         << BeginType << EndType;
1906       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1907       NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1908     }
1909
1910     Decl *BeginEndDecls[] = { BeginVar, EndVar };
1911     // Claim the type doesn't contain auto: we've already done the checking.
1912     DeclGroupPtrTy BeginEndGroup =
1913       BuildDeclaratorGroup(BeginEndDecls, 2, /*TypeMayContainAuto=*/false);
1914     BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc);
1915
1916     const QualType BeginRefNonRefType = BeginType.getNonReferenceType();
1917     ExprResult BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1918                                            VK_LValue, ColonLoc);
1919     if (BeginRef.isInvalid())
1920       return StmtError();
1921
1922     ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1923                                          VK_LValue, ColonLoc);
1924     if (EndRef.isInvalid())
1925       return StmtError();
1926
1927     // Build and check __begin != __end expression.
1928     NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
1929                            BeginRef.get(), EndRef.get());
1930     NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get());
1931     NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get());
1932     if (NotEqExpr.isInvalid()) {
1933       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1934       if (!Context.hasSameType(BeginType, EndType))
1935         NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1936       return StmtError();
1937     }
1938
1939     // Build and check ++__begin expression.
1940     BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1941                                 VK_LValue, ColonLoc);
1942     if (BeginRef.isInvalid())
1943       return StmtError();
1944
1945     IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
1946     IncrExpr = ActOnFinishFullExpr(IncrExpr.get());
1947     if (IncrExpr.isInvalid()) {
1948       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1949       return StmtError();
1950     }
1951
1952     // Build and check *__begin  expression.
1953     BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1954                                 VK_LValue, ColonLoc);
1955     if (BeginRef.isInvalid())
1956       return StmtError();
1957
1958     ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
1959     if (DerefExpr.isInvalid()) {
1960       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1961       return StmtError();
1962     }
1963
1964     // Attach  *__begin  as initializer for VD.
1965     if (!LoopVar->isInvalidDecl()) {
1966       AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false,
1967                            /*TypeMayContainAuto=*/true);
1968       if (LoopVar->isInvalidDecl())
1969         NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1970     }
1971   } else {
1972     // The range is implicitly used as a placeholder when it is dependent.
1973     RangeVar->setUsed();
1974   }
1975
1976   return Owned(new (Context) CXXForRangeStmt(RangeDS,
1977                                      cast_or_null<DeclStmt>(BeginEndDecl.get()),
1978                                              NotEqExpr.take(), IncrExpr.take(),
1979                                              LoopVarDS, /*Body=*/0, ForLoc,
1980                                              ColonLoc, RParenLoc));
1981 }
1982
1983 /// FinishObjCForCollectionStmt - Attach the body to a objective-C foreach
1984 /// statement.
1985 StmtResult Sema::FinishObjCForCollectionStmt(Stmt *S, Stmt *B) {
1986   if (!S || !B)
1987     return StmtError();
1988   ObjCForCollectionStmt * ForStmt = cast<ObjCForCollectionStmt>(S);
1989
1990   ForStmt->setBody(B);
1991   return S;
1992 }
1993
1994 /// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
1995 /// This is a separate step from ActOnCXXForRangeStmt because analysis of the
1996 /// body cannot be performed until after the type of the range variable is
1997 /// determined.
1998 StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
1999   if (!S || !B)
2000     return StmtError();
2001
2002   if (isa<ObjCForCollectionStmt>(S))
2003     return FinishObjCForCollectionStmt(S, B);
2004
2005   CXXForRangeStmt *ForStmt = cast<CXXForRangeStmt>(S);
2006   ForStmt->setBody(B);
2007
2008   DiagnoseEmptyStmtBody(ForStmt->getRParenLoc(), B,
2009                         diag::warn_empty_range_based_for_body);
2010
2011   return S;
2012 }
2013
2014 StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
2015                                SourceLocation LabelLoc,
2016                                LabelDecl *TheDecl) {
2017   getCurFunction()->setHasBranchIntoScope();
2018   TheDecl->setUsed();
2019   return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
2020 }
2021
2022 StmtResult
2023 Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
2024                             Expr *E) {
2025   // Convert operand to void*
2026   if (!E->isTypeDependent()) {
2027     QualType ETy = E->getType();
2028     QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
2029     ExprResult ExprRes = Owned(E);
2030     AssignConvertType ConvTy =
2031       CheckSingleAssignmentConstraints(DestTy, ExprRes);
2032     if (ExprRes.isInvalid())
2033       return StmtError();
2034     E = ExprRes.take();
2035     if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
2036       return StmtError();
2037     E = MaybeCreateExprWithCleanups(E);
2038   }
2039
2040   getCurFunction()->setHasIndirectGoto();
2041
2042   return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
2043 }
2044
2045 StmtResult
2046 Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
2047   Scope *S = CurScope->getContinueParent();
2048   if (!S) {
2049     // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
2050     return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
2051   }
2052
2053   return Owned(new (Context) ContinueStmt(ContinueLoc));
2054 }
2055
2056 StmtResult
2057 Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
2058   Scope *S = CurScope->getBreakParent();
2059   if (!S) {
2060     // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
2061     return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
2062   }
2063
2064   return Owned(new (Context) BreakStmt(BreakLoc));
2065 }
2066
2067 /// \brief Determine whether the given expression is a candidate for
2068 /// copy elision in either a return statement or a throw expression.
2069 ///
2070 /// \param ReturnType If we're determining the copy elision candidate for
2071 /// a return statement, this is the return type of the function. If we're
2072 /// determining the copy elision candidate for a throw expression, this will
2073 /// be a NULL type.
2074 ///
2075 /// \param E The expression being returned from the function or block, or
2076 /// being thrown.
2077 ///
2078 /// \param AllowFunctionParameter Whether we allow function parameters to
2079 /// be considered NRVO candidates. C++ prohibits this for NRVO itself, but
2080 /// we re-use this logic to determine whether we should try to move as part of
2081 /// a return or throw (which does allow function parameters).
2082 ///
2083 /// \returns The NRVO candidate variable, if the return statement may use the
2084 /// NRVO, or NULL if there is no such candidate.
2085 const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
2086                                              Expr *E,
2087                                              bool AllowFunctionParameter) {
2088   QualType ExprType = E->getType();
2089   // - in a return statement in a function with ...
2090   // ... a class return type ...
2091   if (!ReturnType.isNull()) {
2092     if (!ReturnType->isRecordType())
2093       return 0;
2094     // ... the same cv-unqualified type as the function return type ...
2095     if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
2096       return 0;
2097   }
2098
2099   // ... the expression is the name of a non-volatile automatic object
2100   // (other than a function or catch-clause parameter)) ...
2101   const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
2102   if (!DR || DR->refersToEnclosingLocal())
2103     return 0;
2104   const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
2105   if (!VD)
2106     return 0;
2107
2108   // ...object (other than a function or catch-clause parameter)...
2109   if (VD->getKind() != Decl::Var &&
2110       !(AllowFunctionParameter && VD->getKind() == Decl::ParmVar))
2111     return 0;
2112   if (VD->isExceptionVariable()) return 0;
2113
2114   // ...automatic...
2115   if (!VD->hasLocalStorage()) return 0;
2116
2117   // ...non-volatile...
2118   if (VD->getType().isVolatileQualified()) return 0;
2119   if (VD->getType()->isReferenceType()) return 0;
2120
2121   // __block variables can't be allocated in a way that permits NRVO.
2122   if (VD->hasAttr<BlocksAttr>()) return 0;
2123
2124   // Variables with higher required alignment than their type's ABI
2125   // alignment cannot use NRVO.
2126   if (VD->hasAttr<AlignedAttr>() &&
2127       Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VD->getType()))
2128     return 0;
2129
2130   return VD;
2131 }
2132
2133 /// \brief Perform the initialization of a potentially-movable value, which
2134 /// is the result of return value.
2135 ///
2136 /// This routine implements C++0x [class.copy]p33, which attempts to treat
2137 /// returned lvalues as rvalues in certain cases (to prefer move construction),
2138 /// then falls back to treating them as lvalues if that failed.
2139 ExprResult
2140 Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
2141                                       const VarDecl *NRVOCandidate,
2142                                       QualType ResultType,
2143                                       Expr *Value,
2144                                       bool AllowNRVO) {
2145   // C++0x [class.copy]p33:
2146   //   When the criteria for elision of a copy operation are met or would
2147   //   be met save for the fact that the source object is a function
2148   //   parameter, and the object to be copied is designated by an lvalue,
2149   //   overload resolution to select the constructor for the copy is first
2150   //   performed as if the object were designated by an rvalue.
2151   ExprResult Res = ExprError();
2152   if (AllowNRVO &&
2153       (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true))) {
2154     ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
2155                               Value->getType(), CK_NoOp, Value, VK_XValue);
2156
2157     Expr *InitExpr = &AsRvalue;
2158     InitializationKind Kind
2159       = InitializationKind::CreateCopy(Value->getLocStart(),
2160                                        Value->getLocStart());
2161     InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
2162
2163     //   [...] If overload resolution fails, or if the type of the first
2164     //   parameter of the selected constructor is not an rvalue reference
2165     //   to the object's type (possibly cv-qualified), overload resolution
2166     //   is performed again, considering the object as an lvalue.
2167     if (Seq) {
2168       for (InitializationSequence::step_iterator Step = Seq.step_begin(),
2169            StepEnd = Seq.step_end();
2170            Step != StepEnd; ++Step) {
2171         if (Step->Kind != InitializationSequence::SK_ConstructorInitialization)
2172           continue;
2173
2174         CXXConstructorDecl *Constructor
2175         = cast<CXXConstructorDecl>(Step->Function.Function);
2176
2177         const RValueReferenceType *RRefType
2178           = Constructor->getParamDecl(0)->getType()
2179                                                  ->getAs<RValueReferenceType>();
2180
2181         // If we don't meet the criteria, break out now.
2182         if (!RRefType ||
2183             !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
2184                             Context.getTypeDeclType(Constructor->getParent())))
2185           break;
2186
2187         // Promote "AsRvalue" to the heap, since we now need this
2188         // expression node to persist.
2189         Value = ImplicitCastExpr::Create(Context, Value->getType(),
2190                                          CK_NoOp, Value, 0, VK_XValue);
2191
2192         // Complete type-checking the initialization of the return type
2193         // using the constructor we found.
2194         Res = Seq.Perform(*this, Entity, Kind, MultiExprArg(&Value, 1));
2195       }
2196     }
2197   }
2198
2199   // Either we didn't meet the criteria for treating an lvalue as an rvalue,
2200   // above, or overload resolution failed. Either way, we need to try
2201   // (again) now with the return value expression as written.
2202   if (Res.isInvalid())
2203     Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
2204
2205   return Res;
2206 }
2207
2208 /// ActOnCapScopeReturnStmt - Utility routine to type-check return statements
2209 /// for capturing scopes.
2210 ///
2211 StmtResult
2212 Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
2213   // If this is the first return we've seen, infer the return type.
2214   // [expr.prim.lambda]p4 in C++11; block literals follow a superset of those
2215   // rules which allows multiple return statements.
2216   CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
2217   QualType FnRetType = CurCap->ReturnType;
2218
2219   // For blocks/lambdas with implicit return types, we check each return
2220   // statement individually, and deduce the common return type when the block
2221   // or lambda is completed.
2222   if (CurCap->HasImplicitReturnType) {
2223     if (RetValExp && !isa<InitListExpr>(RetValExp)) {
2224       ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
2225       if (Result.isInvalid())
2226         return StmtError();
2227       RetValExp = Result.take();
2228
2229       if (!RetValExp->isTypeDependent())
2230         FnRetType = RetValExp->getType();
2231       else
2232         FnRetType = CurCap->ReturnType = Context.DependentTy;
2233     } else {
2234       if (RetValExp) {
2235         // C++11 [expr.lambda.prim]p4 bans inferring the result from an
2236         // initializer list, because it is not an expression (even
2237         // though we represent it as one). We still deduce 'void'.
2238         Diag(ReturnLoc, diag::err_lambda_return_init_list)
2239           << RetValExp->getSourceRange();
2240       }
2241
2242       FnRetType = Context.VoidTy;
2243     }
2244
2245     // Although we'll properly infer the type of the block once it's completed,
2246     // make sure we provide a return type now for better error recovery.
2247     if (CurCap->ReturnType.isNull())
2248       CurCap->ReturnType = FnRetType;
2249   }
2250   assert(!FnRetType.isNull());
2251
2252   if (BlockScopeInfo *CurBlock = dyn_cast<BlockScopeInfo>(CurCap)) {
2253     if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
2254       Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr);
2255       return StmtError();
2256     }
2257   } else {
2258     LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(CurCap);
2259     if (LSI->CallOperator->getType()->getAs<FunctionType>()->getNoReturnAttr()){
2260       Diag(ReturnLoc, diag::err_noreturn_lambda_has_return_expr);
2261       return StmtError();
2262     }
2263   }
2264
2265   // Otherwise, verify that this result type matches the previous one.  We are
2266   // pickier with blocks than for normal functions because we don't have GCC
2267   // compatibility to worry about here.
2268   const VarDecl *NRVOCandidate = 0;
2269   if (FnRetType->isDependentType()) {
2270     // Delay processing for now.  TODO: there are lots of dependent
2271     // types we can conclusively prove aren't void.
2272   } else if (FnRetType->isVoidType()) {
2273     if (RetValExp && !isa<InitListExpr>(RetValExp) &&
2274         !(getLangOpts().CPlusPlus &&
2275           (RetValExp->isTypeDependent() ||
2276            RetValExp->getType()->isVoidType()))) {
2277       if (!getLangOpts().CPlusPlus &&
2278           RetValExp->getType()->isVoidType())
2279         Diag(ReturnLoc, diag::ext_return_has_void_expr) << "literal" << 2;
2280       else {
2281         Diag(ReturnLoc, diag::err_return_block_has_expr);
2282         RetValExp = 0;
2283       }
2284     }
2285   } else if (!RetValExp) {
2286     return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
2287   } else if (!RetValExp->isTypeDependent()) {
2288     // we have a non-void block with an expression, continue checking
2289
2290     // C99 6.8.6.4p3(136): The return statement is not an assignment. The
2291     // overlap restriction of subclause 6.5.16.1 does not apply to the case of
2292     // function return.
2293
2294     // In C++ the return statement is handled via a copy initialization.
2295     // the C version of which boils down to CheckSingleAssignmentConstraints.
2296     NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
2297     InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
2298                                                                    FnRetType,
2299                                                           NRVOCandidate != 0);
2300     ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
2301                                                      FnRetType, RetValExp);
2302     if (Res.isInvalid()) {
2303       // FIXME: Cleanup temporaries here, anyway?
2304       return StmtError();
2305     }
2306     RetValExp = Res.take();
2307     CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
2308   }
2309
2310   if (RetValExp) {
2311     CheckImplicitConversions(RetValExp, ReturnLoc);
2312     RetValExp = MaybeCreateExprWithCleanups(RetValExp);
2313   }
2314   ReturnStmt *Result = new (Context) ReturnStmt(ReturnLoc, RetValExp,
2315                                                 NRVOCandidate);
2316
2317   // If we need to check for the named return value optimization,
2318   // or if we need to infer the return type,
2319   // save the return statement in our scope for later processing.
2320   if (CurCap->HasImplicitReturnType ||
2321       (getLangOpts().CPlusPlus && FnRetType->isRecordType() &&
2322        !CurContext->isDependentContext()))
2323     FunctionScopes.back()->Returns.push_back(Result);
2324
2325   return Owned(Result);
2326 }
2327
2328 StmtResult
2329 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
2330   // Check for unexpanded parameter packs.
2331   if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
2332     return StmtError();
2333
2334   if (isa<CapturingScopeInfo>(getCurFunction()))
2335     return ActOnCapScopeReturnStmt(ReturnLoc, RetValExp);
2336
2337   QualType FnRetType;
2338   QualType RelatedRetType;
2339   if (const FunctionDecl *FD = getCurFunctionDecl()) {
2340     FnRetType = FD->getResultType();
2341     if (FD->hasAttr<NoReturnAttr>() ||
2342         FD->getType()->getAs<FunctionType>()->getNoReturnAttr())
2343       Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
2344         << FD->getDeclName();
2345   } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
2346     FnRetType = MD->getResultType();
2347     if (MD->hasRelatedResultType() && MD->getClassInterface()) {
2348       // In the implementation of a method with a related return type, the
2349       // type used to type-check the validity of return statements within the
2350       // method body is a pointer to the type of the class being implemented.
2351       RelatedRetType = Context.getObjCInterfaceType(MD->getClassInterface());
2352       RelatedRetType = Context.getObjCObjectPointerType(RelatedRetType);
2353     }
2354   } else // If we don't have a function/method context, bail.
2355     return StmtError();
2356
2357   ReturnStmt *Result = 0;
2358   if (FnRetType->isVoidType()) {
2359     if (RetValExp) {
2360       if (isa<InitListExpr>(RetValExp)) {
2361         // We simply never allow init lists as the return value of void
2362         // functions. This is compatible because this was never allowed before,
2363         // so there's no legacy code to deal with.
2364         NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
2365         int FunctionKind = 0;
2366         if (isa<ObjCMethodDecl>(CurDecl))
2367           FunctionKind = 1;
2368         else if (isa<CXXConstructorDecl>(CurDecl))
2369           FunctionKind = 2;
2370         else if (isa<CXXDestructorDecl>(CurDecl))
2371           FunctionKind = 3;
2372
2373         Diag(ReturnLoc, diag::err_return_init_list)
2374           << CurDecl->getDeclName() << FunctionKind
2375           << RetValExp->getSourceRange();
2376
2377         // Drop the expression.
2378         RetValExp = 0;
2379       } else if (!RetValExp->isTypeDependent()) {
2380         // C99 6.8.6.4p1 (ext_ since GCC warns)
2381         unsigned D = diag::ext_return_has_expr;
2382         if (RetValExp->getType()->isVoidType())
2383           D = diag::ext_return_has_void_expr;
2384         else {
2385           ExprResult Result = Owned(RetValExp);
2386           Result = IgnoredValueConversions(Result.take());
2387           if (Result.isInvalid())
2388             return StmtError();
2389           RetValExp = Result.take();
2390           RetValExp = ImpCastExprToType(RetValExp,
2391                                         Context.VoidTy, CK_ToVoid).take();
2392         }
2393
2394         // return (some void expression); is legal in C++.
2395         if (D != diag::ext_return_has_void_expr ||
2396             !getLangOpts().CPlusPlus) {
2397           NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
2398
2399           int FunctionKind = 0;
2400           if (isa<ObjCMethodDecl>(CurDecl))
2401             FunctionKind = 1;
2402           else if (isa<CXXConstructorDecl>(CurDecl))
2403             FunctionKind = 2;
2404           else if (isa<CXXDestructorDecl>(CurDecl))
2405             FunctionKind = 3;
2406
2407           Diag(ReturnLoc, D)
2408             << CurDecl->getDeclName() << FunctionKind
2409             << RetValExp->getSourceRange();
2410         }
2411       }
2412
2413       if (RetValExp) {
2414         CheckImplicitConversions(RetValExp, ReturnLoc);
2415         RetValExp = MaybeCreateExprWithCleanups(RetValExp);
2416       }
2417     }
2418
2419     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
2420   } else if (!RetValExp && !FnRetType->isDependentType()) {
2421     unsigned DiagID = diag::warn_return_missing_expr;  // C90 6.6.6.4p4
2422     // C99 6.8.6.4p1 (ext_ since GCC warns)
2423     if (getLangOpts().C99) DiagID = diag::ext_return_missing_expr;
2424
2425     if (FunctionDecl *FD = getCurFunctionDecl())
2426       Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
2427     else
2428       Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
2429     Result = new (Context) ReturnStmt(ReturnLoc);
2430   } else {
2431     const VarDecl *NRVOCandidate = 0;
2432     if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
2433       // we have a non-void function with an expression, continue checking
2434
2435       if (!RelatedRetType.isNull()) {
2436         // If we have a related result type, perform an extra conversion here.
2437         // FIXME: The diagnostics here don't really describe what is happening.
2438         InitializedEntity Entity =
2439             InitializedEntity::InitializeTemporary(RelatedRetType);
2440
2441         ExprResult Res = PerformCopyInitialization(Entity, SourceLocation(),
2442                                                    RetValExp);
2443         if (Res.isInvalid()) {
2444           // FIXME: Cleanup temporaries here, anyway?
2445           return StmtError();
2446         }
2447         RetValExp = Res.takeAs<Expr>();
2448       }
2449
2450       // C99 6.8.6.4p3(136): The return statement is not an assignment. The
2451       // overlap restriction of subclause 6.5.16.1 does not apply to the case of
2452       // function return.
2453
2454       // In C++ the return statement is handled via a copy initialization,
2455       // the C version of which boils down to CheckSingleAssignmentConstraints.
2456       NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
2457       InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
2458                                                                      FnRetType,
2459                                                             NRVOCandidate != 0);
2460       ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
2461                                                        FnRetType, RetValExp);
2462       if (Res.isInvalid()) {
2463         // FIXME: Cleanup temporaries here, anyway?
2464         return StmtError();
2465       }
2466
2467       RetValExp = Res.takeAs<Expr>();
2468       if (RetValExp)
2469         CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
2470     }
2471
2472     if (RetValExp) {
2473       CheckImplicitConversions(RetValExp, ReturnLoc);
2474       RetValExp = MaybeCreateExprWithCleanups(RetValExp);
2475     }
2476     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
2477   }
2478
2479   // If we need to check for the named return value optimization, save the
2480   // return statement in our scope for later processing.
2481   if (getLangOpts().CPlusPlus && FnRetType->isRecordType() &&
2482       !CurContext->isDependentContext())
2483     FunctionScopes.back()->Returns.push_back(Result);
2484
2485   return Owned(Result);
2486 }
2487
2488 /// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
2489 /// ignore "noop" casts in places where an lvalue is required by an inline asm.
2490 /// We emulate this behavior when -fheinous-gnu-extensions is specified, but
2491 /// provide a strong guidance to not use it.
2492 ///
2493 /// This method checks to see if the argument is an acceptable l-value and
2494 /// returns false if it is a case we can handle.
2495 static bool CheckAsmLValue(const Expr *E, Sema &S) {
2496   // Type dependent expressions will be checked during instantiation.
2497   if (E->isTypeDependent())
2498     return false;
2499
2500   if (E->isLValue())
2501     return false;  // Cool, this is an lvalue.
2502
2503   // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
2504   // are supposed to allow.
2505   const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
2506   if (E != E2 && E2->isLValue()) {
2507     if (!S.getLangOpts().HeinousExtensions)
2508       S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
2509         << E->getSourceRange();
2510     else
2511       S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
2512         << E->getSourceRange();
2513     // Accept, even if we emitted an error diagnostic.
2514     return false;
2515   }
2516
2517   // None of the above, just randomly invalid non-lvalue.
2518   return true;
2519 }
2520
2521 /// isOperandMentioned - Return true if the specified operand # is mentioned
2522 /// anywhere in the decomposed asm string.
2523 static bool isOperandMentioned(unsigned OpNo,
2524                          ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) {
2525   for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
2526     const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
2527     if (!Piece.isOperand()) continue;
2528
2529     // If this is a reference to the input and if the input was the smaller
2530     // one, then we have to reject this asm.
2531     if (Piece.getOperandNo() == OpNo)
2532       return true;
2533   }
2534   return false;
2535 }
2536
2537 StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple,
2538                               bool IsVolatile, unsigned NumOutputs,
2539                               unsigned NumInputs, IdentifierInfo **Names,
2540                               MultiExprArg constraints, MultiExprArg exprs,
2541                               Expr *asmString, MultiExprArg clobbers,
2542                               SourceLocation RParenLoc, bool MSAsm) {
2543   unsigned NumClobbers = clobbers.size();
2544   StringLiteral **Constraints =
2545     reinterpret_cast<StringLiteral**>(constraints.get());
2546   Expr **Exprs = exprs.get();
2547   StringLiteral *AsmString = cast<StringLiteral>(asmString);
2548   StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
2549
2550   SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
2551
2552   // The parser verifies that there is a string literal here.
2553   if (!AsmString->isAscii())
2554     return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
2555       << AsmString->getSourceRange());
2556
2557   for (unsigned i = 0; i != NumOutputs; i++) {
2558     StringLiteral *Literal = Constraints[i];
2559     if (!Literal->isAscii())
2560       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2561         << Literal->getSourceRange());
2562
2563     StringRef OutputName;
2564     if (Names[i])
2565       OutputName = Names[i]->getName();
2566
2567     TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
2568     if (!Context.getTargetInfo().validateOutputConstraint(Info))
2569       return StmtError(Diag(Literal->getLocStart(),
2570                             diag::err_asm_invalid_output_constraint)
2571                        << Info.getConstraintStr());
2572
2573     // Check that the output exprs are valid lvalues.
2574     Expr *OutputExpr = Exprs[i];
2575     if (CheckAsmLValue(OutputExpr, *this)) {
2576       return StmtError(Diag(OutputExpr->getLocStart(),
2577                   diag::err_asm_invalid_lvalue_in_output)
2578         << OutputExpr->getSourceRange());
2579     }
2580
2581     OutputConstraintInfos.push_back(Info);
2582   }
2583
2584   SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
2585
2586   for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
2587     StringLiteral *Literal = Constraints[i];
2588     if (!Literal->isAscii())
2589       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2590         << Literal->getSourceRange());
2591
2592     StringRef InputName;
2593     if (Names[i])
2594       InputName = Names[i]->getName();
2595
2596     TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
2597     if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos.data(),
2598                                                 NumOutputs, Info)) {
2599       return StmtError(Diag(Literal->getLocStart(),
2600                             diag::err_asm_invalid_input_constraint)
2601                        << Info.getConstraintStr());
2602     }
2603
2604     Expr *InputExpr = Exprs[i];
2605
2606     // Only allow void types for memory constraints.
2607     if (Info.allowsMemory() && !Info.allowsRegister()) {
2608       if (CheckAsmLValue(InputExpr, *this))
2609         return StmtError(Diag(InputExpr->getLocStart(),
2610                               diag::err_asm_invalid_lvalue_in_input)
2611                          << Info.getConstraintStr()
2612                          << InputExpr->getSourceRange());
2613     }
2614
2615     if (Info.allowsRegister()) {
2616       if (InputExpr->getType()->isVoidType()) {
2617         return StmtError(Diag(InputExpr->getLocStart(),
2618                               diag::err_asm_invalid_type_in_input)
2619           << InputExpr->getType() << Info.getConstraintStr()
2620           << InputExpr->getSourceRange());
2621       }
2622     }
2623
2624     ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
2625     if (Result.isInvalid())
2626       return StmtError();
2627
2628     Exprs[i] = Result.take();
2629     InputConstraintInfos.push_back(Info);
2630   }
2631
2632   // Check that the clobbers are valid.
2633   for (unsigned i = 0; i != NumClobbers; i++) {
2634     StringLiteral *Literal = Clobbers[i];
2635     if (!Literal->isAscii())
2636       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2637         << Literal->getSourceRange());
2638
2639     StringRef Clobber = Literal->getString();
2640
2641     if (!Context.getTargetInfo().isValidClobber(Clobber))
2642       return StmtError(Diag(Literal->getLocStart(),
2643                   diag::err_asm_unknown_register_name) << Clobber);
2644   }
2645
2646   AsmStmt *NS =
2647     new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm,
2648                           NumOutputs, NumInputs, Names, Constraints, Exprs,
2649                           AsmString, NumClobbers, Clobbers, RParenLoc);
2650   // Validate the asm string, ensuring it makes sense given the operands we
2651   // have.
2652   SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
2653   unsigned DiagOffs;
2654   if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
2655     Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
2656            << AsmString->getSourceRange();
2657     return StmtError();
2658   }
2659
2660   // Validate tied input operands for type mismatches.
2661   for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
2662     TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
2663
2664     // If this is a tied constraint, verify that the output and input have
2665     // either exactly the same type, or that they are int/ptr operands with the
2666     // same size (int/long, int*/long, are ok etc).
2667     if (!Info.hasTiedOperand()) continue;
2668
2669     unsigned TiedTo = Info.getTiedOperand();
2670     unsigned InputOpNo = i+NumOutputs;
2671     Expr *OutputExpr = Exprs[TiedTo];
2672     Expr *InputExpr = Exprs[InputOpNo];
2673
2674     if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent())
2675       continue;
2676
2677     QualType InTy = InputExpr->getType();
2678     QualType OutTy = OutputExpr->getType();
2679     if (Context.hasSameType(InTy, OutTy))
2680       continue;  // All types can be tied to themselves.
2681
2682     // Decide if the input and output are in the same domain (integer/ptr or
2683     // floating point.
2684     enum AsmDomain {
2685       AD_Int, AD_FP, AD_Other
2686     } InputDomain, OutputDomain;
2687
2688     if (InTy->isIntegerType() || InTy->isPointerType())
2689       InputDomain = AD_Int;
2690     else if (InTy->isRealFloatingType())
2691       InputDomain = AD_FP;
2692     else
2693       InputDomain = AD_Other;
2694
2695     if (OutTy->isIntegerType() || OutTy->isPointerType())
2696       OutputDomain = AD_Int;
2697     else if (OutTy->isRealFloatingType())
2698       OutputDomain = AD_FP;
2699     else
2700       OutputDomain = AD_Other;
2701
2702     // They are ok if they are the same size and in the same domain.  This
2703     // allows tying things like:
2704     //   void* to int*
2705     //   void* to int            if they are the same size.
2706     //   double to long double   if they are the same size.
2707     //
2708     uint64_t OutSize = Context.getTypeSize(OutTy);
2709     uint64_t InSize = Context.getTypeSize(InTy);
2710     if (OutSize == InSize && InputDomain == OutputDomain &&
2711         InputDomain != AD_Other)
2712       continue;
2713
2714     // If the smaller input/output operand is not mentioned in the asm string,
2715     // then we can promote the smaller one to a larger input and the asm string
2716     // won't notice.
2717     bool SmallerValueMentioned = false;
2718
2719     // If this is a reference to the input and if the input was the smaller
2720     // one, then we have to reject this asm.
2721     if (isOperandMentioned(InputOpNo, Pieces)) {
2722       // This is a use in the asm string of the smaller operand.  Since we
2723       // codegen this by promoting to a wider value, the asm will get printed
2724       // "wrong".
2725       SmallerValueMentioned |= InSize < OutSize;
2726     }
2727     if (isOperandMentioned(TiedTo, Pieces)) {
2728       // If this is a reference to the output, and if the output is the larger
2729       // value, then it's ok because we'll promote the input to the larger type.
2730       SmallerValueMentioned |= OutSize < InSize;
2731     }
2732
2733     // If the smaller value wasn't mentioned in the asm string, and if the
2734     // output was a register, just extend the shorter one to the size of the
2735     // larger one.
2736     if (!SmallerValueMentioned && InputDomain != AD_Other &&
2737         OutputConstraintInfos[TiedTo].allowsRegister())
2738       continue;
2739
2740     // Either both of the operands were mentioned or the smaller one was
2741     // mentioned.  One more special case that we'll allow: if the tied input is
2742     // integer, unmentioned, and is a constant, then we'll allow truncating it
2743     // down to the size of the destination.
2744     if (InputDomain == AD_Int && OutputDomain == AD_Int &&
2745         !isOperandMentioned(InputOpNo, Pieces) &&
2746         InputExpr->isEvaluatable(Context)) {
2747       CastKind castKind =
2748         (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
2749       InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2750       Exprs[InputOpNo] = InputExpr;
2751       NS->setInputExpr(i, InputExpr);
2752       continue;
2753     }
2754
2755     Diag(InputExpr->getLocStart(),
2756          diag::err_asm_tying_incompatible_types)
2757       << InTy << OutTy << OutputExpr->getSourceRange()
2758       << InputExpr->getSourceRange();
2759     return StmtError();
2760   }
2761
2762   return Owned(NS);
2763 }
2764
2765 static void patchMSAsmStrings(Sema &SemaRef, bool &IsSimple,
2766                               SourceLocation AsmLoc,
2767                               ArrayRef<Token> AsmToks,
2768                               const TargetInfo &TI,
2769                               std::vector<llvm::BitVector> &AsmRegs,
2770                               std::vector<llvm::BitVector> &AsmNames,
2771                               std::vector<std::string> &AsmStrings) {
2772   assert (!AsmToks.empty() && "Didn't expect an empty AsmToks!");
2773
2774   // Assume simple asm stmt until we parse a non-register identifer.
2775   IsSimple = true;
2776
2777   SmallString<512> Asm;
2778   unsigned NumAsmStrings = 0;
2779   for (unsigned i = 0, e = AsmToks.size(); i != e; ++i) {
2780
2781     // Determine if this should be considered a new asm.
2782     bool isNewAsm = i == 0 || AsmToks[i].isAtStartOfLine() ||
2783       AsmToks[i].is(tok::kw_asm);
2784
2785     // Emit the previous asm string.
2786     if (i && isNewAsm) {
2787       AsmStrings[NumAsmStrings++] = Asm.c_str();
2788       if (AsmToks[i].is(tok::kw_asm)) {
2789         ++i; // Skip __asm
2790         assert (i != e && "Expected another token.");
2791       }
2792     }
2793
2794     // Start a new asm string with the opcode.
2795     if (isNewAsm) {
2796       AsmRegs[NumAsmStrings].resize(AsmToks.size());
2797       AsmNames[NumAsmStrings].resize(AsmToks.size());
2798       Asm = AsmToks[i].getIdentifierInfo()->getName().str();
2799       continue;
2800     }
2801
2802     if (i && AsmToks[i].hasLeadingSpace())
2803       Asm += ' ';
2804
2805     // Check the operand(s).
2806     switch (AsmToks[i].getKind()) {
2807     default:
2808       //llvm_unreachable("Unknown token.");
2809       break;
2810     case tok::comma: Asm += ","; break;
2811     case tok::colon: Asm += ":"; break;
2812     case tok::l_square: Asm += "["; break;
2813     case tok::r_square: Asm += "]"; break;
2814     case tok::l_brace: Asm += "{"; break;
2815     case tok::r_brace: Asm += "}"; break;
2816     case tok::numeric_constant: {
2817       SmallString<32> TokenBuf;
2818       TokenBuf.resize(32);
2819       bool StringInvalid = false;
2820       Asm += SemaRef.PP.getSpelling(AsmToks[i], TokenBuf, &StringInvalid);
2821       assert (!StringInvalid && "Expected valid string!");
2822       break;
2823     }
2824     case tok::identifier: {
2825       IdentifierInfo *II = AsmToks[i].getIdentifierInfo();
2826       StringRef Name = II->getName();
2827
2828       // Valid register?
2829       if (TI.isValidGCCRegisterName(Name)) {
2830         AsmRegs[NumAsmStrings].set(i);
2831         Asm += Name;
2832         break;
2833       }
2834
2835       IsSimple = false;
2836
2837       // FIXME: Why are we missing this segment register?
2838       if (Name == "fs") {
2839         Asm += Name;
2840         break;
2841       }
2842
2843       // Lookup the identifier.
2844       // TODO: Someone with more experience with clang should verify this the
2845       // proper way of doing a symbol lookup.
2846       DeclarationName DeclName(II);
2847       Scope *CurScope = SemaRef.getCurScope();
2848       LookupResult R(SemaRef, DeclName, AsmLoc, Sema::LookupOrdinaryName);
2849       if (!SemaRef.LookupName(R, CurScope, false/*AllowBuiltinCreation*/))
2850         break;
2851
2852       assert (R.isSingleResult() && "Expected a single result?!");
2853       NamedDecl *Decl = R.getFoundDecl();
2854       switch (Decl->getKind()) {
2855       default:
2856         assert(0 && "Unknown decl kind.");
2857         break;
2858       case Decl::Var: {
2859       case Decl::ParmVar:
2860         AsmNames[NumAsmStrings].set(i);
2861
2862         VarDecl *Var = cast<VarDecl>(Decl);
2863         QualType Ty = Var->getType();
2864         (void)Ty; // Avoid warning.
2865         // TODO: Patch identifier with valid operand.  One potential idea is to
2866         // probe the backend with type information to guess the possible
2867         // operand.
2868         break;
2869       }
2870       }
2871       break;
2872     }
2873     }
2874   }
2875
2876   // Emit the final (and possibly only) asm string.
2877   AsmStrings[NumAsmStrings] = Asm.c_str();
2878 }
2879
2880 // Build the unmodified MSAsmString.
2881 static std::string buildMSAsmString(Sema &SemaRef,
2882                                     ArrayRef<Token> AsmToks,
2883                                     unsigned &NumAsmStrings) {
2884   assert (!AsmToks.empty() && "Didn't expect an empty AsmToks!");
2885   SmallString<512> Asm;
2886   SmallString<512> TokenBuf;
2887   TokenBuf.resize(512);
2888
2889   NumAsmStrings = 0;
2890   for (unsigned i = 0, e = AsmToks.size(); i < e; ++i) {
2891     bool isNewAsm = i == 0 || AsmToks[i].isAtStartOfLine() ||
2892       AsmToks[i].is(tok::kw_asm);
2893
2894     if (isNewAsm) {
2895       ++NumAsmStrings;
2896       if (i)
2897         Asm += '\n';
2898       if (AsmToks[i].is(tok::kw_asm)) {
2899         i++; // Skip __asm
2900         assert (i != e && "Expected another token");
2901       }
2902     }
2903
2904     if (i && AsmToks[i].hasLeadingSpace() && !isNewAsm)
2905       Asm += ' ';
2906
2907     bool StringInvalid = false;
2908     Asm += SemaRef.PP.getSpelling(AsmToks[i], TokenBuf, &StringInvalid);
2909     assert (!StringInvalid && "Expected valid string!");
2910   }
2911   return Asm.c_str();
2912 }
2913
2914 StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc,
2915                                 SourceLocation LBraceLoc,
2916                                 ArrayRef<Token> AsmToks,
2917                                 SourceLocation EndLoc) {
2918   // MS-style inline assembly is not fully supported, so emit a warning.
2919   Diag(AsmLoc, diag::warn_unsupported_msasm);
2920   SmallVector<StringRef,4> Clobbers;
2921   std::set<std::string> ClobberRegs;
2922   SmallVector<IdentifierInfo*, 4> Inputs;
2923   SmallVector<IdentifierInfo*, 4> Outputs;
2924
2925   // Empty asm statements don't need to instantiate the AsmParser, etc.
2926   if (AsmToks.empty()) {
2927     StringRef AsmString;
2928     MSAsmStmt *NS =
2929       new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, /*IsSimple*/ true,
2930                               /*IsVolatile*/ true, AsmToks, Inputs, Outputs,
2931                               AsmString, Clobbers, EndLoc);
2932     return Owned(NS);
2933   }
2934
2935   unsigned NumAsmStrings;
2936   std::string AsmString = buildMSAsmString(*this, AsmToks, NumAsmStrings);
2937
2938   bool IsSimple;
2939   std::vector<llvm::BitVector> Regs;
2940   std::vector<llvm::BitVector> Names;
2941   std::vector<std::string> PatchedAsmStrings;
2942
2943   Regs.resize(NumAsmStrings);
2944   Names.resize(NumAsmStrings);
2945   PatchedAsmStrings.resize(NumAsmStrings);
2946
2947   // Rewrite operands to appease the AsmParser.
2948   patchMSAsmStrings(*this, IsSimple, AsmLoc, AsmToks,
2949                     Context.getTargetInfo(), Regs, Names, PatchedAsmStrings);
2950
2951   // patchMSAsmStrings doesn't correctly patch non-simple asm statements.
2952   if (!IsSimple) {
2953     MSAsmStmt *NS =
2954       new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, /*IsSimple*/ true,
2955                               /*IsVolatile*/ true, AsmToks, Inputs, Outputs,
2956                               AsmString, Clobbers, EndLoc);
2957     return Owned(NS);
2958   }
2959
2960   // Initialize targets and assembly printers/parsers.
2961   llvm::InitializeAllTargetInfos();
2962   llvm::InitializeAllTargetMCs();
2963   llvm::InitializeAllAsmParsers();
2964
2965   // Get the target specific parser.
2966   std::string Error;
2967   const std::string &TT = Context.getTargetInfo().getTriple().getTriple();
2968   const llvm::Target *TheTarget(llvm::TargetRegistry::lookupTarget(TT, Error));
2969
2970   OwningPtr<llvm::MCAsmInfo> MAI(TheTarget->createMCAsmInfo(TT));
2971   OwningPtr<llvm::MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TT));
2972   OwningPtr<llvm::MCObjectFileInfo> MOFI(new llvm::MCObjectFileInfo());
2973   OwningPtr<llvm::MCSubtargetInfo>
2974     STI(TheTarget->createMCSubtargetInfo(TT, "", ""));
2975
2976   for (unsigned i = 0, e = PatchedAsmStrings.size(); i != e; ++i) {
2977     llvm::SourceMgr SrcMgr;
2978     llvm::MCContext Ctx(*MAI, *MRI, MOFI.get(), &SrcMgr);
2979     llvm::MemoryBuffer *Buffer =
2980       llvm::MemoryBuffer::getMemBuffer(PatchedAsmStrings[i], "<inline asm>");
2981
2982     // Tell SrcMgr about this buffer, which is what the parser will pick up.
2983     SrcMgr.AddNewSourceBuffer(Buffer, llvm::SMLoc());
2984
2985     OwningPtr<llvm::MCStreamer> Str;
2986     OwningPtr<llvm::MCAsmParser>
2987       Parser(createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI));
2988     OwningPtr<llvm::MCTargetAsmParser>
2989       TargetParser(TheTarget->createMCAsmParser(*STI, *Parser));
2990     // Change to the Intel dialect.
2991     Parser->setAssemblerDialect(1);
2992     Parser->setTargetParser(*TargetParser.get());
2993
2994     // Prime the lexer.
2995     Parser->Lex();
2996
2997     // Parse the opcode.
2998     StringRef IDVal;
2999     Parser->ParseIdentifier(IDVal);
3000
3001     // Canonicalize the opcode to lower case.
3002     SmallString<128> Opcode;
3003     for (unsigned i = 0, e = IDVal.size(); i != e; ++i)
3004       Opcode.push_back(tolower(IDVal[i]));
3005
3006     // Parse the operands.
3007     llvm::SMLoc IDLoc;
3008     SmallVector<llvm::MCParsedAsmOperand*, 8> Operands;
3009     bool HadError = TargetParser->ParseInstruction(Opcode.str(), IDLoc,
3010                                                    Operands);
3011     assert (!HadError && "Unexpected error parsing instruction");
3012
3013     // Match the MCInstr.
3014     SmallVector<llvm::MCInst, 2> Instrs;
3015     HadError = TargetParser->MatchInstruction(IDLoc, Operands, Instrs);
3016     assert (!HadError && "Unexpected error matching instruction");
3017     assert ((Instrs.size() == 1) && "Expected only a single instruction.");
3018
3019     // Get the instruction descriptor.
3020     llvm::MCInst Inst = Instrs[0];
3021     const llvm::MCInstrInfo *MII = TheTarget->createMCInstrInfo();
3022     const llvm::MCInstrDesc &Desc = MII->get(Inst.getOpcode());
3023     llvm::MCInstPrinter *IP =
3024       TheTarget->createMCInstPrinter(1, *MAI, *MII, *MRI, *STI);
3025
3026     // Build the list of clobbers.
3027     for (unsigned i = 0, e = Desc.getNumDefs(); i != e; ++i) {
3028       const llvm::MCOperand &Op = Inst.getOperand(i);
3029       if (!Op.isReg())
3030         continue;
3031
3032       std::string Reg;
3033       llvm::raw_string_ostream OS(Reg);
3034       IP->printRegName(OS, Op.getReg());
3035
3036       StringRef Clobber(OS.str());
3037       if (!Context.getTargetInfo().isValidClobber(Clobber))
3038         return StmtError(Diag(AsmLoc, diag::err_asm_unknown_register_name) <<
3039                          Clobber);
3040       ClobberRegs.insert(Reg);
3041     }
3042   }
3043   for (std::set<std::string>::iterator I = ClobberRegs.begin(),
3044          E = ClobberRegs.end(); I != E; ++I)
3045     Clobbers.push_back(*I);
3046
3047   MSAsmStmt *NS =
3048     new (Context) MSAsmStmt(Context, AsmLoc, LBraceLoc, IsSimple,
3049                             /*IsVolatile*/ true, AsmToks, Inputs, Outputs,
3050                             AsmString, Clobbers, EndLoc);
3051   return Owned(NS);
3052 }
3053
3054 StmtResult
3055 Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
3056                            SourceLocation RParen, Decl *Parm,
3057                            Stmt *Body) {
3058   VarDecl *Var = cast_or_null<VarDecl>(Parm);
3059   if (Var && Var->isInvalidDecl())
3060     return StmtError();
3061
3062   return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
3063 }
3064
3065 StmtResult
3066 Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
3067   return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
3068 }
3069
3070 StmtResult
3071 Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
3072                          MultiStmtArg CatchStmts, Stmt *Finally) {
3073   if (!getLangOpts().ObjCExceptions)
3074     Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
3075
3076   getCurFunction()->setHasBranchProtectedScope();
3077   unsigned NumCatchStmts = CatchStmts.size();
3078   return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
3079                                      CatchStmts.release(),
3080                                      NumCatchStmts,
3081                                      Finally));
3082 }
3083
3084 StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw) {
3085   if (Throw) {
3086     ExprResult Result = DefaultLvalueConversion(Throw);
3087     if (Result.isInvalid())
3088       return StmtError();
3089
3090     Throw = MaybeCreateExprWithCleanups(Result.take());
3091     QualType ThrowType = Throw->getType();
3092     // Make sure the expression type is an ObjC pointer or "void *".
3093     if (!ThrowType->isDependentType() &&
3094         !ThrowType->isObjCObjectPointerType()) {
3095       const PointerType *PT = ThrowType->getAs<PointerType>();
3096       if (!PT || !PT->getPointeeType()->isVoidType())
3097         return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
3098                          << Throw->getType() << Throw->getSourceRange());
3099     }
3100   }
3101
3102   return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
3103 }
3104
3105 StmtResult
3106 Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
3107                            Scope *CurScope) {
3108   if (!getLangOpts().ObjCExceptions)
3109     Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
3110
3111   if (!Throw) {
3112     // @throw without an expression designates a rethrow (which much occur
3113     // in the context of an @catch clause).
3114     Scope *AtCatchParent = CurScope;
3115     while (AtCatchParent && !AtCatchParent->isAtCatchScope())
3116       AtCatchParent = AtCatchParent->getParent();
3117     if (!AtCatchParent)
3118       return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
3119   }
3120   return BuildObjCAtThrowStmt(AtLoc, Throw);
3121 }
3122
3123 ExprResult
3124 Sema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) {
3125   ExprResult result = DefaultLvalueConversion(operand);
3126   if (result.isInvalid())
3127     return ExprError();
3128   operand = result.take();
3129
3130   // Make sure the expression type is an ObjC pointer or "void *".
3131   QualType type = operand->getType();
3132   if (!type->isDependentType() &&
3133       !type->isObjCObjectPointerType()) {
3134     const PointerType *pointerType = type->getAs<PointerType>();
3135     if (!pointerType || !pointerType->getPointeeType()->isVoidType())
3136       return Diag(atLoc, diag::error_objc_synchronized_expects_object)
3137                << type << operand->getSourceRange();
3138   }
3139
3140   // The operand to @synchronized is a full-expression.
3141   return MaybeCreateExprWithCleanups(operand);
3142 }
3143
3144 StmtResult
3145 Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
3146                                   Stmt *SyncBody) {
3147   // We can't jump into or indirect-jump out of a @synchronized block.
3148   getCurFunction()->setHasBranchProtectedScope();
3149   return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
3150 }
3151
3152 /// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
3153 /// and creates a proper catch handler from them.
3154 StmtResult
3155 Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl,
3156                          Stmt *HandlerBlock) {
3157   // There's nothing to test that ActOnExceptionDecl didn't already test.
3158   return Owned(new (Context) CXXCatchStmt(CatchLoc,
3159                                           cast_or_null<VarDecl>(ExDecl),
3160                                           HandlerBlock));
3161 }
3162
3163 StmtResult
3164 Sema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) {
3165   getCurFunction()->setHasBranchProtectedScope();
3166   return Owned(new (Context) ObjCAutoreleasePoolStmt(AtLoc, Body));
3167 }
3168
3169 namespace {
3170
3171 class TypeWithHandler {
3172   QualType t;
3173   CXXCatchStmt *stmt;
3174 public:
3175   TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
3176   : t(type), stmt(statement) {}
3177
3178   // An arbitrary order is fine as long as it places identical
3179   // types next to each other.
3180   bool operator<(const TypeWithHandler &y) const {
3181     if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr())
3182       return true;
3183     if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
3184       return false;
3185     else
3186       return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
3187   }
3188
3189   bool operator==(const TypeWithHandler& other) const {
3190     return t == other.t;
3191   }
3192
3193   CXXCatchStmt *getCatchStmt() const { return stmt; }
3194   SourceLocation getTypeSpecStartLoc() const {
3195     return stmt->getExceptionDecl()->getTypeSpecStartLoc();
3196   }
3197 };
3198
3199 }
3200
3201 /// ActOnCXXTryBlock - Takes a try compound-statement and a number of
3202 /// handlers and creates a try statement from them.
3203 StmtResult
3204 Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
3205                        MultiStmtArg RawHandlers) {
3206   // Don't report an error if 'try' is used in system headers.
3207   if (!getLangOpts().CXXExceptions &&
3208       !getSourceManager().isInSystemHeader(TryLoc))
3209       Diag(TryLoc, diag::err_exceptions_disabled) << "try";
3210
3211   unsigned NumHandlers = RawHandlers.size();
3212   assert(NumHandlers > 0 &&
3213          "The parser shouldn't call this if there are no handlers.");
3214   Stmt **Handlers = RawHandlers.get();
3215
3216   SmallVector<TypeWithHandler, 8> TypesWithHandlers;
3217
3218   for (unsigned i = 0; i < NumHandlers; ++i) {
3219     CXXCatchStmt *Handler = cast<CXXCatchStmt>(Handlers[i]);
3220     if (!Handler->getExceptionDecl()) {
3221       if (i < NumHandlers - 1)
3222         return StmtError(Diag(Handler->getLocStart(),
3223                               diag::err_early_catch_all));
3224
3225       continue;
3226     }
3227
3228     const QualType CaughtType = Handler->getCaughtType();
3229     const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
3230     TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
3231   }
3232
3233   // Detect handlers for the same type as an earlier one.
3234   if (NumHandlers > 1) {
3235     llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
3236
3237     TypeWithHandler prev = TypesWithHandlers[0];
3238     for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
3239       TypeWithHandler curr = TypesWithHandlers[i];
3240
3241       if (curr == prev) {
3242         Diag(curr.getTypeSpecStartLoc(),
3243              diag::warn_exception_caught_by_earlier_handler)
3244           << curr.getCatchStmt()->getCaughtType().getAsString();
3245         Diag(prev.getTypeSpecStartLoc(),
3246              diag::note_previous_exception_handler)
3247           << prev.getCatchStmt()->getCaughtType().getAsString();
3248       }
3249
3250       prev = curr;
3251     }
3252   }
3253
3254   getCurFunction()->setHasBranchProtectedScope();
3255
3256   // FIXME: We should detect handlers that cannot catch anything because an
3257   // earlier handler catches a superclass. Need to find a method that is not
3258   // quadratic for this.
3259   // Neither of these are explicitly forbidden, but every compiler detects them
3260   // and warns.
3261
3262   return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
3263                                   Handlers, NumHandlers));
3264 }
3265
3266 StmtResult
3267 Sema::ActOnSEHTryBlock(bool IsCXXTry,
3268                        SourceLocation TryLoc,
3269                        Stmt *TryBlock,
3270                        Stmt *Handler) {
3271   assert(TryBlock && Handler);
3272
3273   getCurFunction()->setHasBranchProtectedScope();
3274
3275   return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
3276 }
3277
3278 StmtResult
3279 Sema::ActOnSEHExceptBlock(SourceLocation Loc,
3280                           Expr *FilterExpr,
3281                           Stmt *Block) {
3282   assert(FilterExpr && Block);
3283
3284   if(!FilterExpr->getType()->isIntegerType()) {
3285     return StmtError(Diag(FilterExpr->getExprLoc(),
3286                      diag::err_filter_expression_integral)
3287                      << FilterExpr->getType());
3288   }
3289
3290   return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
3291 }
3292
3293 StmtResult
3294 Sema::ActOnSEHFinallyBlock(SourceLocation Loc,
3295                            Stmt *Block) {
3296   assert(Block);
3297   return Owned(SEHFinallyStmt::Create(Context,Loc,Block));
3298 }
3299
3300 StmtResult Sema::BuildMSDependentExistsStmt(SourceLocation KeywordLoc,
3301                                             bool IsIfExists,
3302                                             NestedNameSpecifierLoc QualifierLoc,
3303                                             DeclarationNameInfo NameInfo,
3304                                             Stmt *Nested)
3305 {
3306   return new (Context) MSDependentExistsStmt(KeywordLoc, IsIfExists,
3307                                              QualifierLoc, NameInfo,
3308                                              cast<CompoundStmt>(Nested));
3309 }
3310
3311
3312 StmtResult Sema::ActOnMSDependentExistsStmt(SourceLocation KeywordLoc,
3313                                             bool IsIfExists,
3314                                             CXXScopeSpec &SS,
3315                                             UnqualifiedId &Name,
3316                                             Stmt *Nested) {
3317   return BuildMSDependentExistsStmt(KeywordLoc, IsIfExists,
3318                                     SS.getWithLocInContext(Context),
3319                                     GetNameFromUnqualifiedId(Name),
3320                                     Nested);
3321 }