contrib/llvm/tools/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/APValue.h"
  20 #include "clang/AST/ASTContext.h"
  21 #include "clang/AST/DeclObjC.h"
  22 #include "clang/AST/ExprCXX.h"
  23 #include "clang/AST/ExprObjC.h"
  24 #include "clang/AST/StmtObjC.h"
  25 #include "clang/AST/StmtCXX.h"
  26 #include "clang/AST/TypeLoc.h"
  27 #include "clang/Lex/Preprocessor.h"
  28 #include "clang/Basic/TargetInfo.h"
  29 #include "llvm/ADT/ArrayRef.h"
  30 #include "llvm/ADT/STLExtras.h"
  31 #include "llvm/ADT/SmallVector.h"
  32 using namespace clang;
  33 using namespace sema;
  34
  35 StmtResult Sema::ActOnExprStmt(FullExprArg expr) {
  36   Expr *E = expr.get();
  37   if (!E) // FIXME: FullExprArg has no error state?
  38     return StmtError();
  39
  40   // C99 6.8.3p2: The expression in an expression statement is evaluated as a
  41   // void expression for its side effects.  Conversion to void allows any
  42   // operand, even incomplete types.
  43
  44   // Same thing in for stmt first clause (when expr) and third clause.
  45   return Owned(static_cast<Stmt*>(E));
  46 }
  47
  48
  49 StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
  50                                bool HasLeadingEmptyMacro) {
  51   return Owned(new (Context) NullStmt(SemiLoc, HasLeadingEmptyMacro));
  52 }
  53
  54 StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
  55                                SourceLocation EndLoc) {
  56   DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
  57
  58   // If we have an invalid decl, just return an error.
  59   if (DG.isNull()) return StmtError();
  60
  61   return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
  62 }
  63
  64 void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
  65   DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
  66
  67   // If we have an invalid decl, just return.
  68   if (DG.isNull() || !DG.isSingleDecl()) return;
  69   VarDecl *var = cast<VarDecl>(DG.getSingleDecl());
  70
  71   // suppress any potential 'unused variable' warning.
  72   var->setUsed();
  73
  74   // foreach variables are never actually initialized in the way that
  75   // the parser came up with.
  76   var->setInit(0);
  77
  78   // In ARC, we don't need to retain the iteration variable of a fast
  79   // enumeration loop.  Rather than actually trying to catch that
  80   // during declaration processing, we remove the consequences here.
  81   if (getLangOptions().ObjCAutoRefCount) {
  82     QualType type = var->getType();
  83
  84     // Only do this if we inferred the lifetime.  Inferred lifetime
  85     // will show up as a local qualifier because explicit lifetime
  86     // should have shown up as an AttributedType instead.
  87     if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) {
  88       // Add 'const' and mark the variable as pseudo-strong.
  89       var->setType(type.withConst());
  90       var->setARCPseudoStrong(true);
  91     }
  92   }
  93 }
  94
  95 /// \brief Diagnose unused '==' and '!=' as likely typos for '=' or '|='.
  96 ///
  97 /// Adding a cast to void (or other expression wrappers) will prevent the
  98 /// warning from firing.
  99 static bool DiagnoseUnusedComparison(Sema &S, const Expr *E) {
 100   SourceLocation Loc;
 101   bool IsNotEqual, CanAssign;
 102
 103   if (const BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {
 104     if (Op->getOpcode() != BO_EQ && Op->getOpcode() != BO_NE)
 105       return false;
 106
 107     Loc = Op->getOperatorLoc();
 108     IsNotEqual = Op->getOpcode() == BO_NE;
 109     CanAssign = Op->getLHS()->IgnoreParenImpCasts()->isLValue();
 110   } else if (const CXXOperatorCallExpr *Op = dyn_cast<CXXOperatorCallExpr>(E)) {
 111     if (Op->getOperator() != OO_EqualEqual &&
 112         Op->getOperator() != OO_ExclaimEqual)
 113       return false;
 114
 115     Loc = Op->getOperatorLoc();
 116     IsNotEqual = Op->getOperator() == OO_ExclaimEqual;
 117     CanAssign = Op->getArg(0)->IgnoreParenImpCasts()->isLValue();
 118   } else {
 119     // Not a typo-prone comparison.
 120     return false;
 121   }
 122
 123   // Suppress warnings when the operator, suspicious as it may be, comes from
 124   // a macro expansion.
 125   if (Loc.isMacroID())
 126     return false;
 127
 128   S.Diag(Loc, diag::warn_unused_comparison)
 129     << (unsigned)IsNotEqual << E->getSourceRange();
 130
 131   // If the LHS is a plausible entity to assign to, provide a fixit hint to
 132   // correct common typos.
 133   if (CanAssign) {
 134     if (IsNotEqual)
 135       S.Diag(Loc, diag::note_inequality_comparison_to_or_assign)
 136         << FixItHint::CreateReplacement(Loc, "|=");
 137     else
 138       S.Diag(Loc, diag::note_equality_comparison_to_assign)
 139         << FixItHint::CreateReplacement(Loc, "=");
 140   }
 141
 142   return true;
 143 }
 144
 145 void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
 146   if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
 147     return DiagnoseUnusedExprResult(Label->getSubStmt());
 148
 149   const Expr *E = dyn_cast_or_null<Expr>(S);
 150   if (!E)
 151     return;
 152
 153   SourceLocation Loc;
 154   SourceRange R1, R2;
 155   if (!E->isUnusedResultAWarning(Loc, R1, R2, Context))
 156     return;
 157
 158   // Okay, we have an unused result.  Depending on what the base expression is,
 159   // we might want to make a more specific diagnostic.  Check for one of these
 160   // cases now.
 161   unsigned DiagID = diag::warn_unused_expr;
 162   if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E))
 163     E = Temps->getSubExpr();
 164   if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
 165     E = TempExpr->getSubExpr();
 166
 167   if (DiagnoseUnusedComparison(*this, E))
 168     return;
 169
 170   E = E->IgnoreParenImpCasts();
 171   if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
 172     if (E->getType()->isVoidType())
 173       return;
 174
 175     // If the callee has attribute pure, const, or warn_unused_result, warn with
 176     // a more specific message to make it clear what is happening.
 177     if (const Decl *FD = CE->getCalleeDecl()) {
 178       if (FD->getAttr<WarnUnusedResultAttr>()) {
 179         Diag(Loc, diag::warn_unused_result) << R1 << R2;
 180         return;
 181       }
 182       if (FD->getAttr<PureAttr>()) {
 183         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
 184         return;
 185       }
 186       if (FD->getAttr<ConstAttr>()) {
 187         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
 188         return;
 189       }
 190     }
 191   } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
 192     if (getLangOptions().ObjCAutoRefCount && ME->isDelegateInitCall()) {
 193       Diag(Loc, diag::err_arc_unused_init_message) << R1;
 194       return;
 195     }
 196     const ObjCMethodDecl *MD = ME->getMethodDecl();
 197     if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
 198       Diag(Loc, diag::warn_unused_result) << R1 << R2;
 199       return;
 200     }
 201   } else if (isa<ObjCPropertyRefExpr>(E)) {
 202     DiagID = diag::warn_unused_property_expr;
 203   } else if (const CXXFunctionalCastExpr *FC
 204                                        = dyn_cast<CXXFunctionalCastExpr>(E)) {
 205     if (isa<CXXConstructExpr>(FC->getSubExpr()) ||
 206         isa<CXXTemporaryObjectExpr>(FC->getSubExpr()))
 207       return;
 208   }
 209   // Diagnose "(void*) blah" as a typo for "(void) blah".
 210   else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
 211     TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
 212     QualType T = TI->getType();
 213
 214     // We really do want to use the non-canonical type here.
 215     if (T == Context.VoidPtrTy) {
 216       PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
 217
 218       Diag(Loc, diag::warn_unused_voidptr)
 219         << FixItHint::CreateRemoval(TL.getStarLoc());
 220       return;
 221     }
 222   }
 223
 224   DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
 225 }
 226
 227 StmtResult
 228 Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
 229                         MultiStmtArg elts, bool isStmtExpr) {
 230   unsigned NumElts = elts.size();
 231   Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
 232   // If we're in C89 mode, check that we don't have any decls after stmts.  If
 233   // so, emit an extension diagnostic.
 234   if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) {
 235     // Note that __extension__ can be around a decl.
 236     unsigned i = 0;
 237     // Skip over all declarations.
 238     for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
 239       /*empty*/;
 240
 241     // We found the end of the list or a statement.  Scan for another declstmt.
 242     for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
 243       /*empty*/;
 244
 245     if (i != NumElts) {
 246       Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
 247       Diag(D->getLocation(), diag::ext_mixed_decls_code);
 248     }
 249   }
 250   // Warn about unused expressions in statements.
 251   for (unsigned i = 0; i != NumElts; ++i) {
 252     // Ignore statements that are last in a statement expression.
 253     if (isStmtExpr && i == NumElts - 1)
 254       continue;
 255
 256     DiagnoseUnusedExprResult(Elts[i]);
 257   }
 258
 259   return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
 260 }
 261
 262 StmtResult
 263 Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
 264                     SourceLocation DotDotDotLoc, Expr *RHSVal,
 265                     SourceLocation ColonLoc) {
 266   assert((LHSVal != 0) && "missing expression in case statement");
 267
 268   // C99 6.8.4.2p3: The expression shall be an integer constant.
 269   // However, GCC allows any evaluatable integer expression.
 270   if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent() &&
 271       VerifyIntegerConstantExpression(LHSVal))
 272     return StmtError();
 273
 274   // GCC extension: The expression shall be an integer constant.
 275
 276   if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent() &&
 277       VerifyIntegerConstantExpression(RHSVal)) {
 278     RHSVal = 0;  // Recover by just forgetting about it.
 279   }
 280
 281   if (getCurFunction()->SwitchStack.empty()) {
 282     Diag(CaseLoc, diag::err_case_not_in_switch);
 283     return StmtError();
 284   }
 285
 286   CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
 287                                         ColonLoc);
 288   getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
 289   return Owned(CS);
 290 }
 291
 292 /// ActOnCaseStmtBody - This installs a statement as the body of a case.
 293 void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
 294   DiagnoseUnusedExprResult(SubStmt);
 295
 296   CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
 297   CS->setSubStmt(SubStmt);
 298 }
 299
 300 StmtResult
 301 Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
 302                        Stmt *SubStmt, Scope *CurScope) {
 303   DiagnoseUnusedExprResult(SubStmt);
 304
 305   if (getCurFunction()->SwitchStack.empty()) {
 306     Diag(DefaultLoc, diag::err_default_not_in_switch);
 307     return Owned(SubStmt);
 308   }
 309
 310   DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
 311   getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
 312   return Owned(DS);
 313 }
 314
 315 StmtResult
 316 Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
 317                      SourceLocation ColonLoc, Stmt *SubStmt) {
 318
 319   // If the label was multiply defined, reject it now.
 320   if (TheDecl->getStmt()) {
 321     Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
 322     Diag(TheDecl->getLocation(), diag::note_previous_definition);
 323     return Owned(SubStmt);
 324   }
 325
 326   // Otherwise, things are good.  Fill in the declaration and return it.
 327   LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
 328   TheDecl->setStmt(LS);
 329   if (!TheDecl->isGnuLocal())
 330     TheDecl->setLocation(IdentLoc);
 331   return Owned(LS);
 332 }
 333
 334 StmtResult
 335 Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
 336                   Stmt *thenStmt, SourceLocation ElseLoc,
 337                   Stmt *elseStmt) {
 338   ExprResult CondResult(CondVal.release());
 339
 340   VarDecl *ConditionVar = 0;
 341   if (CondVar) {
 342     ConditionVar = cast<VarDecl>(CondVar);
 343     CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
 344     if (CondResult.isInvalid())
 345       return StmtError();
 346   }
 347   Expr *ConditionExpr = CondResult.takeAs<Expr>();
 348   if (!ConditionExpr)
 349     return StmtError();
 350
 351   DiagnoseUnusedExprResult(thenStmt);
 352
 353   // Warn if the if block has a null body without an else value.
 354   // this helps prevent bugs due to typos, such as
 355   // if (condition);
 356   //   do_stuff();
 357   //
 358   if (!elseStmt) {
 359     if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt))
 360       // But do not warn if the body is a macro that expands to nothing, e.g:
 361       //
 362       // #define CALL(x)
 363       // if (condition)
 364       //   CALL(0);
 365       //
 366       if (!stmt->hasLeadingEmptyMacro())
 367         Diag(stmt->getSemiLoc(), diag::warn_empty_if_body);
 368   }
 369
 370   DiagnoseUnusedExprResult(elseStmt);
 371
 372   return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
 373                                     thenStmt, ElseLoc, elseStmt));
 374 }
 375
 376 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
 377 /// the specified width and sign.  If an overflow occurs, detect it and emit
 378 /// the specified diagnostic.
 379 void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
 380                                               unsigned NewWidth, bool NewSign,
 381                                               SourceLocation Loc,
 382                                               unsigned DiagID) {
 383   // Perform a conversion to the promoted condition type if needed.
 384   if (NewWidth > Val.getBitWidth()) {
 385     // If this is an extension, just do it.
 386     Val = Val.extend(NewWidth);
 387     Val.setIsSigned(NewSign);
 388
 389     // If the input was signed and negative and the output is
 390     // unsigned, don't bother to warn: this is implementation-defined
 391     // behavior.
 392     // FIXME: Introduce a second, default-ignored warning for this case?
 393   } else if (NewWidth < Val.getBitWidth()) {
 394     // If this is a truncation, check for overflow.
 395     llvm::APSInt ConvVal(Val);
 396     ConvVal = ConvVal.trunc(NewWidth);
 397     ConvVal.setIsSigned(NewSign);
 398     ConvVal = ConvVal.extend(Val.getBitWidth());
 399     ConvVal.setIsSigned(Val.isSigned());
 400     if (ConvVal != Val)
 401       Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
 402
 403     // Regardless of whether a diagnostic was emitted, really do the
 404     // truncation.
 405     Val = Val.trunc(NewWidth);
 406     Val.setIsSigned(NewSign);
 407   } else if (NewSign != Val.isSigned()) {
 408     // Convert the sign to match the sign of the condition.  This can cause
 409     // overflow as well: unsigned(INTMIN)
 410     // We don't diagnose this overflow, because it is implementation-defined
 411     // behavior.
 412     // FIXME: Introduce a second, default-ignored warning for this case?
 413     llvm::APSInt OldVal(Val);
 414     Val.setIsSigned(NewSign);
 415   }
 416 }
 417
 418 namespace {
 419   struct CaseCompareFunctor {
 420     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
 421                     const llvm::APSInt &RHS) {
 422       return LHS.first < RHS;
 423     }
 424     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
 425                     const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
 426       return LHS.first < RHS.first;
 427     }
 428     bool operator()(const llvm::APSInt &LHS,
 429                     const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
 430       return LHS < RHS.first;
 431     }
 432   };
 433 }
 434
 435 /// CmpCaseVals - Comparison predicate for sorting case values.
 436 ///
 437 static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
 438                         const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
 439   if (lhs.first < rhs.first)
 440     return true;
 441
 442   if (lhs.first == rhs.first &&
 443       lhs.second->getCaseLoc().getRawEncoding()
 444        < rhs.second->getCaseLoc().getRawEncoding())
 445     return true;
 446   return false;
 447 }
 448
 449 /// CmpEnumVals - Comparison predicate for sorting enumeration values.
 450 ///
 451 static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
 452                         const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
 453 {
 454   return lhs.first < rhs.first;
 455 }
 456
 457 /// EqEnumVals - Comparison preficate for uniqing enumeration values.
 458 ///
 459 static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
 460                        const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
 461 {
 462   return lhs.first == rhs.first;
 463 }
 464
 465 /// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
 466 /// potentially integral-promoted expression @p expr.
 467 static QualType GetTypeBeforeIntegralPromotion(Expr *&expr) {
 468   if (ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(expr))
 469     expr = cleanups->getSubExpr();
 470   while (ImplicitCastExpr *impcast = dyn_cast<ImplicitCastExpr>(expr)) {
 471     if (impcast->getCastKind() != CK_IntegralCast) break;
 472     expr = impcast->getSubExpr();
 473   }
 474   return expr->getType();
 475 }
 476
 477 StmtResult
 478 Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
 479                              Decl *CondVar) {
 480   ExprResult CondResult;
 481
 482   VarDecl *ConditionVar = 0;
 483   if (CondVar) {
 484     ConditionVar = cast<VarDecl>(CondVar);
 485     CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
 486     if (CondResult.isInvalid())
 487       return StmtError();
 488
 489     Cond = CondResult.release();
 490   }
 491
 492   if (!Cond)
 493     return StmtError();
 494
 495   CondResult
 496     = ConvertToIntegralOrEnumerationType(SwitchLoc, Cond,
 497                           PDiag(diag::err_typecheck_statement_requires_integer),
 498                                    PDiag(diag::err_switch_incomplete_class_type)
 499                                      << Cond->getSourceRange(),
 500                                    PDiag(diag::err_switch_explicit_conversion),
 501                                          PDiag(diag::note_switch_conversion),
 502                                    PDiag(diag::err_switch_multiple_conversions),
 503                                          PDiag(diag::note_switch_conversion),
 504                                          PDiag(0));
 505   if (CondResult.isInvalid()) return StmtError();
 506   Cond = CondResult.take();
 507
 508   // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
 509   CondResult = UsualUnaryConversions(Cond);
 510   if (CondResult.isInvalid()) return StmtError();
 511   Cond = CondResult.take();
 512
 513   if (!CondVar) {
 514     CheckImplicitConversions(Cond, SwitchLoc);
 515     CondResult = MaybeCreateExprWithCleanups(Cond);
 516     if (CondResult.isInvalid())
 517       return StmtError();
 518     Cond = CondResult.take();
 519   }
 520
 521   getCurFunction()->setHasBranchIntoScope();
 522
 523   SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
 524   getCurFunction()->SwitchStack.push_back(SS);
 525   return Owned(SS);
 526 }
 527
 528 static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
 529   if (Val.getBitWidth() < BitWidth)
 530     Val = Val.extend(BitWidth);
 531   else if (Val.getBitWidth() > BitWidth)
 532     Val = Val.trunc(BitWidth);
 533   Val.setIsSigned(IsSigned);
 534 }
 535
 536 StmtResult
 537 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
 538                             Stmt *BodyStmt) {
 539   SwitchStmt *SS = cast<SwitchStmt>(Switch);
 540   assert(SS == getCurFunction()->SwitchStack.back() &&
 541          "switch stack missing push/pop!");
 542
 543   SS->setBody(BodyStmt, SwitchLoc);
 544   getCurFunction()->SwitchStack.pop_back();
 545
 546   Expr *CondExpr = SS->getCond();
 547   if (!CondExpr) return StmtError();
 548
 549   QualType CondType = CondExpr->getType();
 550
 551   Expr *CondExprBeforePromotion = CondExpr;
 552   QualType CondTypeBeforePromotion =
 553       GetTypeBeforeIntegralPromotion(CondExprBeforePromotion);
 554
 555   // C++ 6.4.2.p2:
 556   // Integral promotions are performed (on the switch condition).
 557   //
 558   // A case value unrepresentable by the original switch condition
 559   // type (before the promotion) doesn't make sense, even when it can
 560   // be represented by the promoted type.  Therefore we need to find
 561   // the pre-promotion type of the switch condition.
 562   if (!CondExpr->isTypeDependent()) {
 563     // We have already converted the expression to an integral or enumeration
 564     // type, when we started the switch statement. If we don't have an
 565     // appropriate type now, just return an error.
 566     if (!CondType->isIntegralOrEnumerationType())
 567       return StmtError();
 568
 569     if (CondExpr->isKnownToHaveBooleanValue()) {
 570       // switch(bool_expr) {...} is often a programmer error, e.g.
 571       //   switch(n && mask) { ... }  // Doh - should be "n & mask".
 572       // One can always use an if statement instead of switch(bool_expr).
 573       Diag(SwitchLoc, diag::warn_bool_switch_condition)
 574           << CondExpr->getSourceRange();
 575     }
 576   }
 577
 578   // Get the bitwidth of the switched-on value before promotions.  We must
 579   // convert the integer case values to this width before comparison.
 580   bool HasDependentValue
 581     = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
 582   unsigned CondWidth
 583     = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
 584   bool CondIsSigned
 585     = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
 586
 587   // Accumulate all of the case values in a vector so that we can sort them
 588   // and detect duplicates.  This vector contains the APInt for the case after
 589   // it has been converted to the condition type.
 590   typedef SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
 591   CaseValsTy CaseVals;
 592
 593   // Keep track of any GNU case ranges we see.  The APSInt is the low value.
 594   typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
 595   CaseRangesTy CaseRanges;
 596
 597   DefaultStmt *TheDefaultStmt = 0;
 598
 599   bool CaseListIsErroneous = false;
 600
 601   for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
 602        SC = SC->getNextSwitchCase()) {
 603
 604     if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
 605       if (TheDefaultStmt) {
 606         Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
 607         Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
 608
 609         // FIXME: Remove the default statement from the switch block so that
 610         // we'll return a valid AST.  This requires recursing down the AST and
 611         // finding it, not something we are set up to do right now.  For now,
 612         // just lop the entire switch stmt out of the AST.
 613         CaseListIsErroneous = true;
 614       }
 615       TheDefaultStmt = DS;
 616
 617     } else {
 618       CaseStmt *CS = cast<CaseStmt>(SC);
 619
 620       // We already verified that the expression has a i-c-e value (C99
 621       // 6.8.4.2p3) - get that value now.
 622       Expr *Lo = CS->getLHS();
 623
 624       if (Lo->isTypeDependent() || Lo->isValueDependent()) {
 625         HasDependentValue = true;
 626         break;
 627       }
 628
 629       llvm::APSInt LoVal = Lo->EvaluateKnownConstInt(Context);
 630
 631       // Convert the value to the same width/sign as the condition.
 632       ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
 633                                          Lo->getLocStart(),
 634                                          diag::warn_case_value_overflow);
 635
 636       // If the LHS is not the same type as the condition, insert an implicit
 637       // cast.
 638       Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
 639       CS->setLHS(Lo);
 640
 641       // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
 642       if (CS->getRHS()) {
 643         if (CS->getRHS()->isTypeDependent() ||
 644             CS->getRHS()->isValueDependent()) {
 645           HasDependentValue = true;
 646           break;
 647         }
 648         CaseRanges.push_back(std::make_pair(LoVal, CS));
 649       } else
 650         CaseVals.push_back(std::make_pair(LoVal, CS));
 651     }
 652   }
 653
 654   if (!HasDependentValue) {
 655     // If we don't have a default statement, check whether the
 656     // condition is constant.
 657     llvm::APSInt ConstantCondValue;
 658     bool HasConstantCond = false;
 659     bool ShouldCheckConstantCond = false;
 660     if (!HasDependentValue && !TheDefaultStmt) {
 661       Expr::EvalResult Result;
 662       HasConstantCond = CondExprBeforePromotion->Evaluate(Result, Context);
 663       if (HasConstantCond) {
 664         assert(Result.Val.isInt() && "switch condition evaluated to non-int");
 665         ConstantCondValue = Result.Val.getInt();
 666         ShouldCheckConstantCond = true;
 667
 668         assert(ConstantCondValue.getBitWidth() == CondWidth &&
 669                ConstantCondValue.isSigned() == CondIsSigned);
 670       }
 671     }
 672
 673     // Sort all the scalar case values so we can easily detect duplicates.
 674     std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
 675
 676     if (!CaseVals.empty()) {
 677       for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
 678         if (ShouldCheckConstantCond &&
 679             CaseVals[i].first == ConstantCondValue)
 680           ShouldCheckConstantCond = false;
 681
 682         if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
 683           // If we have a duplicate, report it.
 684           Diag(CaseVals[i].second->getLHS()->getLocStart(),
 685                diag::err_duplicate_case) << CaseVals[i].first.toString(10);
 686           Diag(CaseVals[i-1].second->getLHS()->getLocStart(),
 687                diag::note_duplicate_case_prev);
 688           // FIXME: We really want to remove the bogus case stmt from the
 689           // substmt, but we have no way to do this right now.
 690           CaseListIsErroneous = true;
 691         }
 692       }
 693     }
 694
 695     // Detect duplicate case ranges, which usually don't exist at all in
 696     // the first place.
 697     if (!CaseRanges.empty()) {
 698       // Sort all the case ranges by their low value so we can easily detect
 699       // overlaps between ranges.
 700       std::stable_sort(CaseRanges.begin(), CaseRanges.end());
 701
 702       // Scan the ranges, computing the high values and removing empty ranges.
 703       std::vector<llvm::APSInt> HiVals;
 704       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
 705         llvm::APSInt &LoVal = CaseRanges[i].first;
 706         CaseStmt *CR = CaseRanges[i].second;
 707         Expr *Hi = CR->getRHS();
 708         llvm::APSInt HiVal = Hi->EvaluateKnownConstInt(Context);
 709
 710         // Convert the value to the same width/sign as the condition.
 711         ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
 712                                            Hi->getLocStart(),
 713                                            diag::warn_case_value_overflow);
 714
 715         // If the LHS is not the same type as the condition, insert an implicit
 716         // cast.
 717         Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
 718         CR->setRHS(Hi);
 719
 720         // If the low value is bigger than the high value, the case is empty.
 721         if (LoVal > HiVal) {
 722           Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
 723             << SourceRange(CR->getLHS()->getLocStart(),
 724                            Hi->getLocEnd());
 725           CaseRanges.erase(CaseRanges.begin()+i);
 726           --i, --e;
 727           continue;
 728         }
 729
 730         if (ShouldCheckConstantCond &&
 731             LoVal <= ConstantCondValue &&
 732             ConstantCondValue <= HiVal)
 733           ShouldCheckConstantCond = false;
 734
 735         HiVals.push_back(HiVal);
 736       }
 737
 738       // Rescan the ranges, looking for overlap with singleton values and other
 739       // ranges.  Since the range list is sorted, we only need to compare case
 740       // ranges with their neighbors.
 741       for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
 742         llvm::APSInt &CRLo = CaseRanges[i].first;
 743         llvm::APSInt &CRHi = HiVals[i];
 744         CaseStmt *CR = CaseRanges[i].second;
 745
 746         // Check to see whether the case range overlaps with any
 747         // singleton cases.
 748         CaseStmt *OverlapStmt = 0;
 749         llvm::APSInt OverlapVal(32);
 750
 751         // Find the smallest value >= the lower bound.  If I is in the
 752         // case range, then we have overlap.
 753         CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
 754                                                   CaseVals.end(), CRLo,
 755                                                   CaseCompareFunctor());
 756         if (I != CaseVals.end() && I->first < CRHi) {
 757           OverlapVal  = I->first;   // Found overlap with scalar.
 758           OverlapStmt = I->second;
 759         }
 760
 761         // Find the smallest value bigger than the upper bound.
 762         I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
 763         if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
 764           OverlapVal  = (I-1)->first;      // Found overlap with scalar.
 765           OverlapStmt = (I-1)->second;
 766         }
 767
 768         // Check to see if this case stmt overlaps with the subsequent
 769         // case range.
 770         if (i && CRLo <= HiVals[i-1]) {
 771           OverlapVal  = HiVals[i-1];       // Found overlap with range.
 772           OverlapStmt = CaseRanges[i-1].second;
 773         }
 774
 775         if (OverlapStmt) {
 776           // If we have a duplicate, report it.
 777           Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
 778             << OverlapVal.toString(10);
 779           Diag(OverlapStmt->getLHS()->getLocStart(),
 780                diag::note_duplicate_case_prev);
 781           // FIXME: We really want to remove the bogus case stmt from the
 782           // substmt, but we have no way to do this right now.
 783           CaseListIsErroneous = true;
 784         }
 785       }
 786     }
 787
 788     // Complain if we have a constant condition and we didn't find a match.
 789     if (!CaseListIsErroneous && ShouldCheckConstantCond) {
 790       // TODO: it would be nice if we printed enums as enums, chars as
 791       // chars, etc.
 792       Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
 793         << ConstantCondValue.toString(10)
 794         << CondExpr->getSourceRange();
 795     }
 796
 797     // Check to see if switch is over an Enum and handles all of its
 798     // values.  We only issue a warning if there is not 'default:', but
 799     // we still do the analysis to preserve this information in the AST
 800     // (which can be used by flow-based analyes).
 801     //
 802     const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
 803
 804     // If switch has default case, then ignore it.
 805     if (!CaseListIsErroneous  && !HasConstantCond && ET) {
 806       const EnumDecl *ED = ET->getDecl();
 807       typedef SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
 808         EnumValsTy;
 809       EnumValsTy EnumVals;
 810
 811       // Gather all enum values, set their type and sort them,
 812       // allowing easier comparison with CaseVals.
 813       for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
 814            EDI != ED->enumerator_end(); ++EDI) {
 815         llvm::APSInt Val = EDI->getInitVal();
 816         AdjustAPSInt(Val, CondWidth, CondIsSigned);
 817         EnumVals.push_back(std::make_pair(Val, *EDI));
 818       }
 819       std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
 820       EnumValsTy::iterator EIend =
 821         std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
 822
 823       // See which case values aren't in enum.
 824       // TODO: we might want to check whether case values are out of the
 825       // enum even if we don't want to check whether all cases are handled.
 826       if (!TheDefaultStmt) {
 827         EnumValsTy::const_iterator EI = EnumVals.begin();
 828         for (CaseValsTy::const_iterator CI = CaseVals.begin();
 829              CI != CaseVals.end(); CI++) {
 830           while (EI != EIend && EI->first < CI->first)
 831             EI++;
 832           if (EI == EIend || EI->first > CI->first)
 833             Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
 834               << ED->getDeclName();
 835         }
 836         // See which of case ranges aren't in enum
 837         EI = EnumVals.begin();
 838         for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
 839              RI != CaseRanges.end() && EI != EIend; RI++) {
 840           while (EI != EIend && EI->first < RI->first)
 841             EI++;
 842
 843           if (EI == EIend || EI->first != RI->first) {
 844             Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
 845               << ED->getDeclName();
 846           }
 847
 848           llvm::APSInt Hi =
 849             RI->second->getRHS()->EvaluateKnownConstInt(Context);
 850           AdjustAPSInt(Hi, CondWidth, CondIsSigned);
 851           while (EI != EIend && EI->first < Hi)
 852             EI++;
 853           if (EI == EIend || EI->first != Hi)
 854             Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
 855               << ED->getDeclName();
 856         }
 857       }
 858
 859       // Check which enum vals aren't in switch
 860       CaseValsTy::const_iterator CI = CaseVals.begin();
 861       CaseRangesTy::const_iterator RI = CaseRanges.begin();
 862       bool hasCasesNotInSwitch = false;
 863
 864       SmallVector<DeclarationName,8> UnhandledNames;
 865
 866       for (EnumValsTy::const_iterator EI = EnumVals.begin(); EI != EIend; EI++){
 867         // Drop unneeded case values
 868         llvm::APSInt CIVal;
 869         while (CI != CaseVals.end() && CI->first < EI->first)
 870           CI++;
 871
 872         if (CI != CaseVals.end() && CI->first == EI->first)
 873           continue;
 874
 875         // Drop unneeded case ranges
 876         for (; RI != CaseRanges.end(); RI++) {
 877           llvm::APSInt Hi =
 878             RI->second->getRHS()->EvaluateKnownConstInt(Context);
 879           AdjustAPSInt(Hi, CondWidth, CondIsSigned);
 880           if (EI->first <= Hi)
 881             break;
 882         }
 883
 884         if (RI == CaseRanges.end() || EI->first < RI->first) {
 885           hasCasesNotInSwitch = true;
 886           if (!TheDefaultStmt)
 887             UnhandledNames.push_back(EI->second->getDeclName());
 888         }
 889       }
 890
 891       // Produce a nice diagnostic if multiple values aren't handled.
 892       switch (UnhandledNames.size()) {
 893       case 0: break;
 894       case 1:
 895         Diag(CondExpr->getExprLoc(), diag::warn_missing_case1)
 896           << UnhandledNames[0];
 897         break;
 898       case 2:
 899         Diag(CondExpr->getExprLoc(), diag::warn_missing_case2)
 900           << UnhandledNames[0] << UnhandledNames[1];
 901         break;
 902       case 3:
 903         Diag(CondExpr->getExprLoc(), diag::warn_missing_case3)
 904           << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
 905         break;
 906       default:
 907         Diag(CondExpr->getExprLoc(), diag::warn_missing_cases)
 908           << (unsigned)UnhandledNames.size()
 909           << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
 910         break;
 911       }
 912
 913       if (!hasCasesNotInSwitch)
 914         SS->setAllEnumCasesCovered();
 915     }
 916   }
 917
 918   // FIXME: If the case list was broken is some way, we don't have a good system
 919   // to patch it up.  Instead, just return the whole substmt as broken.
 920   if (CaseListIsErroneous)
 921     return StmtError();
 922
 923   return Owned(SS);
 924 }
 925
 926 StmtResult
 927 Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
 928                      Decl *CondVar, Stmt *Body) {
 929   ExprResult CondResult(Cond.release());
 930
 931   VarDecl *ConditionVar = 0;
 932   if (CondVar) {
 933     ConditionVar = cast<VarDecl>(CondVar);
 934     CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
 935     if (CondResult.isInvalid())
 936       return StmtError();
 937   }
 938   Expr *ConditionExpr = CondResult.take();
 939   if (!ConditionExpr)
 940     return StmtError();
 941
 942   DiagnoseUnusedExprResult(Body);
 943
 944   return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
 945                                        Body, WhileLoc));
 946 }
 947
 948 StmtResult
 949 Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
 950                   SourceLocation WhileLoc, SourceLocation CondLParen,
 951                   Expr *Cond, SourceLocation CondRParen) {
 952   assert(Cond && "ActOnDoStmt(): missing expression");
 953
 954   ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
 955   if (CondResult.isInvalid() || CondResult.isInvalid())
 956     return StmtError();
 957   Cond = CondResult.take();
 958
 959   CheckImplicitConversions(Cond, DoLoc);
 960   CondResult = MaybeCreateExprWithCleanups(Cond);
 961   if (CondResult.isInvalid())
 962     return StmtError();
 963   Cond = CondResult.take();
 964
 965   DiagnoseUnusedExprResult(Body);
 966
 967   return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
 968 }
 969
 970 StmtResult
 971 Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
 972                    Stmt *First, FullExprArg second, Decl *secondVar,
 973                    FullExprArg third,
 974                    SourceLocation RParenLoc, Stmt *Body) {
 975   if (!getLangOptions().CPlusPlus) {
 976     if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
 977       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
 978       // declare identifiers for objects having storage class 'auto' or
 979       // 'register'.
 980       for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
 981            DI!=DE; ++DI) {
 982         VarDecl *VD = dyn_cast<VarDecl>(*DI);
 983         if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
 984           VD = 0;
 985         if (VD == 0)
 986           Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
 987         // FIXME: mark decl erroneous!
 988       }
 989     }
 990   }
 991
 992   ExprResult SecondResult(second.release());
 993   VarDecl *ConditionVar = 0;
 994   if (secondVar) {
 995     ConditionVar = cast<VarDecl>(secondVar);
 996     SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
 997     if (SecondResult.isInvalid())
 998       return StmtError();
 999   }
1000
1001   Expr *Third  = third.release().takeAs<Expr>();
1002
1003   DiagnoseUnusedExprResult(First);
1004   DiagnoseUnusedExprResult(Third);
1005   DiagnoseUnusedExprResult(Body);
1006
1007   return Owned(new (Context) ForStmt(Context, First,
1008                                      SecondResult.take(), ConditionVar,
1009                                      Third, Body, ForLoc, LParenLoc,
1010                                      RParenLoc));
1011 }
1012
1013 /// In an Objective C collection iteration statement:
1014 ///   for (x in y)
1015 /// x can be an arbitrary l-value expression.  Bind it up as a
1016 /// full-expression.
1017 StmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
1018   CheckImplicitConversions(E);
1019   ExprResult Result = MaybeCreateExprWithCleanups(E);
1020   if (Result.isInvalid()) return StmtError();
1021   return Owned(static_cast<Stmt*>(Result.get()));
1022 }
1023
1024 ExprResult
1025 Sema::ActOnObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {
1026   assert(collection);
1027
1028   // Bail out early if we've got a type-dependent expression.
1029   if (collection->isTypeDependent()) return Owned(collection);
1030
1031   // Perform normal l-value conversion.
1032   ExprResult result = DefaultFunctionArrayLvalueConversion(collection);
1033   if (result.isInvalid())
1034     return ExprError();
1035   collection = result.take();
1036
1037   // The operand needs to have object-pointer type.
1038   // TODO: should we do a contextual conversion?
1039   const ObjCObjectPointerType *pointerType =
1040     collection->getType()->getAs<ObjCObjectPointerType>();
1041   if (!pointerType)
1042     return Diag(forLoc, diag::err_collection_expr_type)
1043              << collection->getType() << collection->getSourceRange();
1044
1045   // Check that the operand provides
1046   //   - countByEnumeratingWithState:objects:count:
1047   const ObjCObjectType *objectType = pointerType->getObjectType();
1048   ObjCInterfaceDecl *iface = objectType->getInterface();
1049
1050   // If we have a forward-declared type, we can't do this check.
1051   if (iface && iface->isForwardDecl()) {
1052     // This is ill-formed under ARC.
1053     if (getLangOptions().ObjCAutoRefCount) {
1054       Diag(forLoc, diag::err_arc_collection_forward)
1055         << pointerType->getPointeeType() << collection->getSourceRange();
1056     }
1057
1058     // Otherwise, if we have any useful type information, check that
1059     // the type declares the appropriate method.
1060   } else if (iface || !objectType->qual_empty()) {
1061     IdentifierInfo *selectorIdents[] = {
1062       &Context.Idents.get("countByEnumeratingWithState"),
1063       &Context.Idents.get("objects"),
1064       &Context.Idents.get("count")
1065     };
1066     Selector selector = Context.Selectors.getSelector(3, &selectorIdents[0]);
1067
1068     ObjCMethodDecl *method = 0;
1069
1070     // If there's an interface, look in both the public and private APIs.
1071     if (iface) {
1072       method = iface->lookupInstanceMethod(selector);
1073       if (!method) method = LookupPrivateInstanceMethod(selector, iface);
1074     }
1075
1076     // Also check protocol qualifiers.
1077     if (!method)
1078       method = LookupMethodInQualifiedType(selector, pointerType,
1079                                            /*instance*/ true);
1080
1081     // If we didn't find it anywhere, give up.
1082     if (!method) {
1083       Diag(forLoc, diag::warn_collection_expr_type)
1084         << collection->getType() << selector << collection->getSourceRange();
1085     }
1086
1087     // TODO: check for an incompatible signature?
1088   }
1089
1090   // Wrap up any cleanups in the expression.
1091   return Owned(MaybeCreateExprWithCleanups(collection));
1092 }
1093
1094 StmtResult
1095 Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
1096                                  SourceLocation LParenLoc,
1097                                  Stmt *First, Expr *Second,
1098                                  SourceLocation RParenLoc, Stmt *Body) {
1099   if (First) {
1100     QualType FirstType;
1101     if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
1102       if (!DS->isSingleDecl())
1103         return StmtError(Diag((*DS->decl_begin())->getLocation(),
1104                          diag::err_toomany_element_decls));
1105
1106       VarDecl *D = cast<VarDecl>(DS->getSingleDecl());
1107       FirstType = D->getType();
1108       // C99 6.8.5p3: The declaration part of a 'for' statement shall only
1109       // declare identifiers for objects having storage class 'auto' or
1110       // 'register'.
1111       if (!D->hasLocalStorage())
1112         return StmtError(Diag(D->getLocation(),
1113                               diag::err_non_variable_decl_in_for));
1114     } else {
1115       Expr *FirstE = cast<Expr>(First);
1116       if (!FirstE->isTypeDependent() && !FirstE->isLValue())
1117         return StmtError(Diag(First->getLocStart(),
1118                    diag::err_selector_element_not_lvalue)
1119           << First->getSourceRange());
1120
1121       FirstType = static_cast<Expr*>(First)->getType();
1122     }
1123     if (!FirstType->isDependentType() &&
1124         !FirstType->isObjCObjectPointerType() &&
1125         !FirstType->isBlockPointerType())
1126         Diag(ForLoc, diag::err_selector_element_type)
1127           << FirstType << First->getSourceRange();
1128   }
1129
1130   return Owned(new (Context) ObjCForCollectionStmt(First, Second, Body,
1131                                                    ForLoc, RParenLoc));
1132 }
1133
1134 namespace {
1135
1136 enum BeginEndFunction {
1137   BEF_begin,
1138   BEF_end
1139 };
1140
1141 /// Build a variable declaration for a for-range statement.
1142 static VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
1143                                      QualType Type, const char *Name) {
1144   DeclContext *DC = SemaRef.CurContext;
1145   IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1146   TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1147   VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
1148                                   TInfo, SC_Auto, SC_None);
1149   Decl->setImplicit();
1150   return Decl;
1151 }
1152
1153 /// Finish building a variable declaration for a for-range statement.
1154 /// \return true if an error occurs.
1155 static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
1156                                   SourceLocation Loc, int diag) {
1157   // Deduce the type for the iterator variable now rather than leaving it to
1158   // AddInitializerToDecl, so we can produce a more suitable diagnostic.
1159   TypeSourceInfo *InitTSI = 0;
1160   if (Init->getType()->isVoidType() ||
1161       !SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTSI))
1162     SemaRef.Diag(Loc, diag) << Init->getType();
1163   if (!InitTSI) {
1164     Decl->setInvalidDecl();
1165     return true;
1166   }
1167   Decl->setTypeSourceInfo(InitTSI);
1168   Decl->setType(InitTSI->getType());
1169
1170   // In ARC, infer lifetime.
1171   // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if
1172   // we're doing the equivalent of fast iteration.
1173   if (SemaRef.getLangOptions().ObjCAutoRefCount &&
1174       SemaRef.inferObjCARCLifetime(Decl))
1175     Decl->setInvalidDecl();
1176
1177   SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1178                                /*TypeMayContainAuto=*/false);
1179   SemaRef.FinalizeDeclaration(Decl);
1180   SemaRef.CurContext->addHiddenDecl(Decl);
1181   return false;
1182 }
1183
1184 /// Produce a note indicating which begin/end function was implicitly called
1185 /// by a C++0x for-range statement. This is often not obvious from the code,
1186 /// nor from the diagnostics produced when analysing the implicit expressions
1187 /// required in a for-range statement.
1188 void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1189                                   BeginEndFunction BEF) {
1190   CallExpr *CE = dyn_cast<CallExpr>(E);
1191   if (!CE)
1192     return;
1193   FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1194   if (!D)
1195     return;
1196   SourceLocation Loc = D->getLocation();
1197
1198   std::string Description;
1199   bool IsTemplate = false;
1200   if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1201     Description = SemaRef.getTemplateArgumentBindingsText(
1202       FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1203     IsTemplate = true;
1204   }
1205
1206   SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1207     << BEF << IsTemplate << Description << E->getType();
1208 }
1209
1210 /// Build a call to 'begin' or 'end' for a C++0x for-range statement. If the
1211 /// given LookupResult is non-empty, it is assumed to describe a member which
1212 /// will be invoked. Otherwise, the function will be found via argument
1213 /// dependent lookup.
1214 static ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1215                                             SourceLocation Loc,
1216                                             VarDecl *Decl,
1217                                             BeginEndFunction BEF,
1218                                             const DeclarationNameInfo &NameInfo,
1219                                             LookupResult &MemberLookup,
1220                                             Expr *Range) {
1221   ExprResult CallExpr;
1222   if (!MemberLookup.empty()) {
1223     ExprResult MemberRef =
1224       SemaRef.BuildMemberReferenceExpr(Range, Range->getType(), Loc,
1225                                        /*IsPtr=*/false, CXXScopeSpec(),
1226                                        /*Qualifier=*/0, MemberLookup,
1227                                        /*TemplateArgs=*/0);
1228     if (MemberRef.isInvalid())
1229       return ExprError();
1230     CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1231                                      Loc, 0);
1232     if (CallExpr.isInvalid())
1233       return ExprError();
1234   } else {
1235     UnresolvedSet<0> FoundNames;
1236     // C++0x [stmt.ranged]p1: For the purposes of this name lookup, namespace
1237     // std is an associated namespace.
1238     UnresolvedLookupExpr *Fn =
1239       UnresolvedLookupExpr::Create(SemaRef.Context, /*NamingClass=*/0,
1240                                    NestedNameSpecifierLoc(), NameInfo,
1241                                    /*NeedsADL=*/true, /*Overloaded=*/false,
1242                                    FoundNames.begin(), FoundNames.end(),
1243                                    /*LookInStdNamespace=*/true);
1244     CallExpr = SemaRef.BuildOverloadedCallExpr(S, Fn, Fn, Loc, &Range, 1, Loc,
1245                                                0);
1246     if (CallExpr.isInvalid()) {
1247       SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1248         << Range->getType();
1249       return ExprError();
1250     }
1251   }
1252   if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1253                             diag::err_for_range_iter_deduction_failure)) {
1254     NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1255     return ExprError();
1256   }
1257   return CallExpr;
1258 }
1259
1260 }
1261
1262 /// ActOnCXXForRangeStmt - Check and build a C++0x for-range statement.
1263 ///
1264 /// C++0x [stmt.ranged]:
1265 ///   A range-based for statement is equivalent to
1266 ///
1267 ///   {
1268 ///     auto && __range = range-init;
1269 ///     for ( auto __begin = begin-expr,
1270 ///           __end = end-expr;
1271 ///           __begin != __end;
1272 ///           ++__begin ) {
1273 ///       for-range-declaration = *__begin;
1274 ///       statement
1275 ///     }
1276 ///   }
1277 ///
1278 /// The body of the loop is not available yet, since it cannot be analysed until
1279 /// we have determined the type of the for-range-declaration.
1280 StmtResult
1281 Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1282                            Stmt *First, SourceLocation ColonLoc, Expr *Range,
1283                            SourceLocation RParenLoc) {
1284   if (!First || !Range)
1285     return StmtError();
1286
1287   DeclStmt *DS = dyn_cast<DeclStmt>(First);
1288   assert(DS && "first part of for range not a decl stmt");
1289
1290   if (!DS->isSingleDecl()) {
1291     Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1292     return StmtError();
1293   }
1294   if (DS->getSingleDecl()->isInvalidDecl())
1295     return StmtError();
1296
1297   if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1298     return StmtError();
1299
1300   // Build  auto && __range = range-init
1301   SourceLocation RangeLoc = Range->getLocStart();
1302   VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1303                                            Context.getAutoRRefDeductType(),
1304                                            "__range");
1305   if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1306                             diag::err_for_range_deduction_failure))
1307     return StmtError();
1308
1309   // Claim the type doesn't contain auto: we've already done the checking.
1310   DeclGroupPtrTy RangeGroup =
1311     BuildDeclaratorGroup((Decl**)&RangeVar, 1, /*TypeMayContainAuto=*/false);
1312   StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
1313   if (RangeDecl.isInvalid())
1314     return StmtError();
1315
1316   return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1317                               /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1318                               RParenLoc);
1319 }
1320
1321 /// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1322 StmtResult
1323 Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1324                            Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1325                            Expr *Inc, Stmt *LoopVarDecl,
1326                            SourceLocation RParenLoc) {
1327   Scope *S = getCurScope();
1328
1329   DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1330   VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1331   QualType RangeVarType = RangeVar->getType();
1332
1333   DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1334   VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1335
1336   StmtResult BeginEndDecl = BeginEnd;
1337   ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1338
1339   if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1340     SourceLocation RangeLoc = RangeVar->getLocation();
1341
1342     const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType();
1343
1344     ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1345                                                 VK_LValue, ColonLoc);
1346     if (BeginRangeRef.isInvalid())
1347       return StmtError();
1348
1349     ExprResult EndRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
1350                                               VK_LValue, ColonLoc);
1351     if (EndRangeRef.isInvalid())
1352       return StmtError();
1353
1354     QualType AutoType = Context.getAutoDeductType();
1355     Expr *Range = RangeVar->getInit();
1356     if (!Range)
1357       return StmtError();
1358     QualType RangeType = Range->getType();
1359
1360     if (RequireCompleteType(RangeLoc, RangeType,
1361                             PDiag(diag::err_for_range_incomplete_type)))
1362       return StmtError();
1363
1364     // Build auto __begin = begin-expr, __end = end-expr.
1365     VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1366                                              "__begin");
1367     VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1368                                            "__end");
1369
1370     // Build begin-expr and end-expr and attach to __begin and __end variables.
1371     ExprResult BeginExpr, EndExpr;
1372     if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
1373       // - if _RangeT is an array type, begin-expr and end-expr are __range and
1374       //   __range + __bound, respectively, where __bound is the array bound. If
1375       //   _RangeT is an array of unknown size or an array of incomplete type,
1376       //   the program is ill-formed;
1377
1378       // begin-expr is __range.
1379       BeginExpr = BeginRangeRef;
1380       if (FinishForRangeVarDecl(*this, BeginVar, BeginRangeRef.get(), ColonLoc,
1381                                 diag::err_for_range_iter_deduction_failure)) {
1382         NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1383         return StmtError();
1384       }
1385
1386       // Find the array bound.
1387       ExprResult BoundExpr;
1388       if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
1389         BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(),
1390                                                  Context.getPointerDiffType(),
1391                                                  RangeLoc));
1392       else if (const VariableArrayType *VAT =
1393                dyn_cast<VariableArrayType>(UnqAT))
1394         BoundExpr = VAT->getSizeExpr();
1395       else {
1396         // Can't be a DependentSizedArrayType or an IncompleteArrayType since
1397         // UnqAT is not incomplete and Range is not type-dependent.
1398         llvm_unreachable("Unexpected array type in for-range");
1399       }
1400
1401       // end-expr is __range + __bound.
1402       EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, EndRangeRef.get(),
1403                            BoundExpr.get());
1404       if (EndExpr.isInvalid())
1405         return StmtError();
1406       if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1407                                 diag::err_for_range_iter_deduction_failure)) {
1408         NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1409         return StmtError();
1410       }
1411     } else {
1412       DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1413                                         ColonLoc);
1414       DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1415                                       ColonLoc);
1416
1417       LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1418       LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1419
1420       if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
1421         // - if _RangeT is a class type, the unqualified-ids begin and end are
1422         //   looked up in the scope of class _RangeT as if by class member access
1423         //   lookup (3.4.5), and if either (or both) finds at least one
1424         //   declaration, begin-expr and end-expr are __range.begin() and
1425         //   __range.end(), respectively;
1426         LookupQualifiedName(BeginMemberLookup, D);
1427         LookupQualifiedName(EndMemberLookup, D);
1428
1429         if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1430           Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1431             << RangeType << BeginMemberLookup.empty();
1432           return StmtError();
1433         }
1434       } else {
1435         // - otherwise, begin-expr and end-expr are begin(__range) and
1436         //   end(__range), respectively, where begin and end are looked up with
1437         //   argument-dependent lookup (3.4.2). For the purposes of this name
1438         //   lookup, namespace std is an associated namespace.
1439       }
1440
1441       BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1442                                             BEF_begin, BeginNameInfo,
1443                                             BeginMemberLookup,
1444                                             BeginRangeRef.get());
1445       if (BeginExpr.isInvalid())
1446         return StmtError();
1447
1448       EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1449                                           BEF_end, EndNameInfo,
1450                                           EndMemberLookup, EndRangeRef.get());
1451       if (EndExpr.isInvalid())
1452         return StmtError();
1453     }
1454
1455     // C++0x [decl.spec.auto]p6: BeginType and EndType must be the same.
1456     QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
1457     if (!Context.hasSameType(BeginType, EndType)) {
1458       Diag(RangeLoc, diag::err_for_range_begin_end_types_differ)
1459         << BeginType << EndType;
1460       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1461       NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1462     }
1463
1464     Decl *BeginEndDecls[] = { BeginVar, EndVar };
1465     // Claim the type doesn't contain auto: we've already done the checking.
1466     DeclGroupPtrTy BeginEndGroup =
1467       BuildDeclaratorGroup(BeginEndDecls, 2, /*TypeMayContainAuto=*/false);
1468     BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc);
1469
1470     const QualType BeginRefNonRefType = BeginType.getNonReferenceType();
1471     ExprResult BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1472                                            VK_LValue, ColonLoc);
1473     if (BeginRef.isInvalid())
1474       return StmtError();
1475
1476     ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1477                                          VK_LValue, ColonLoc);
1478     if (EndRef.isInvalid())
1479       return StmtError();
1480
1481     // Build and check __begin != __end expression.
1482     NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
1483                            BeginRef.get(), EndRef.get());
1484     NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get());
1485     NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get());
1486     if (NotEqExpr.isInvalid()) {
1487       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1488       if (!Context.hasSameType(BeginType, EndType))
1489         NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1490       return StmtError();
1491     }
1492
1493     // Build and check ++__begin expression.
1494     BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1495                                 VK_LValue, ColonLoc);
1496     if (BeginRef.isInvalid())
1497       return StmtError();
1498
1499     IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
1500     IncrExpr = ActOnFinishFullExpr(IncrExpr.get());
1501     if (IncrExpr.isInvalid()) {
1502       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1503       return StmtError();
1504     }
1505
1506     // Build and check *__begin  expression.
1507     BeginRef = BuildDeclRefExpr(BeginVar, BeginRefNonRefType,
1508                                 VK_LValue, ColonLoc);
1509     if (BeginRef.isInvalid())
1510       return StmtError();
1511
1512     ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
1513     if (DerefExpr.isInvalid()) {
1514       NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1515       return StmtError();
1516     }
1517
1518     // Attach  *__begin  as initializer for VD.
1519     if (!LoopVar->isInvalidDecl()) {
1520       AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false,
1521                            /*TypeMayContainAuto=*/true);
1522       if (LoopVar->isInvalidDecl())
1523         NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1524     }
1525   } else {
1526     // The range is implicitly used as a placeholder when it is dependent.
1527     RangeVar->setUsed();
1528   }
1529
1530   return Owned(new (Context) CXXForRangeStmt(RangeDS,
1531                                      cast_or_null<DeclStmt>(BeginEndDecl.get()),
1532                                              NotEqExpr.take(), IncrExpr.take(),
1533                                              LoopVarDS, /*Body=*/0, ForLoc,
1534                                              ColonLoc, RParenLoc));
1535 }
1536
1537 /// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
1538 /// This is a separate step from ActOnCXXForRangeStmt because analysis of the
1539 /// body cannot be performed until after the type of the range variable is
1540 /// determined.
1541 StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
1542   if (!S || !B)
1543     return StmtError();
1544
1545   cast<CXXForRangeStmt>(S)->setBody(B);
1546   return S;
1547 }
1548
1549 StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
1550                                SourceLocation LabelLoc,
1551                                LabelDecl *TheDecl) {
1552   getCurFunction()->setHasBranchIntoScope();
1553   TheDecl->setUsed();
1554   return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
1555 }
1556
1557 StmtResult
1558 Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
1559                             Expr *E) {
1560   // Convert operand to void*
1561   if (!E->isTypeDependent()) {
1562     QualType ETy = E->getType();
1563     QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
1564     ExprResult ExprRes = Owned(E);
1565     AssignConvertType ConvTy =
1566       CheckSingleAssignmentConstraints(DestTy, ExprRes);
1567     if (ExprRes.isInvalid())
1568       return StmtError();
1569     E = ExprRes.take();
1570     if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
1571       return StmtError();
1572   }
1573
1574   getCurFunction()->setHasIndirectGoto();
1575
1576   return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
1577 }
1578
1579 StmtResult
1580 Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
1581   Scope *S = CurScope->getContinueParent();
1582   if (!S) {
1583     // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
1584     return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
1585   }
1586
1587   return Owned(new (Context) ContinueStmt(ContinueLoc));
1588 }
1589
1590 StmtResult
1591 Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
1592   Scope *S = CurScope->getBreakParent();
1593   if (!S) {
1594     // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
1595     return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
1596   }
1597
1598   return Owned(new (Context) BreakStmt(BreakLoc));
1599 }
1600
1601 /// \brief Determine whether the given expression is a candidate for
1602 /// copy elision in either a return statement or a throw expression.
1603 ///
1604 /// \param ReturnType If we're determining the copy elision candidate for
1605 /// a return statement, this is the return type of the function. If we're
1606 /// determining the copy elision candidate for a throw expression, this will
1607 /// be a NULL type.
1608 ///
1609 /// \param E The expression being returned from the function or block, or
1610 /// being thrown.
1611 ///
1612 /// \param AllowFunctionParameter Whether we allow function parameters to
1613 /// be considered NRVO candidates. C++ prohibits this for NRVO itself, but
1614 /// we re-use this logic to determine whether we should try to move as part of
1615 /// a return or throw (which does allow function parameters).
1616 ///
1617 /// \returns The NRVO candidate variable, if the return statement may use the
1618 /// NRVO, or NULL if there is no such candidate.
1619 const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
1620                                              Expr *E,
1621                                              bool AllowFunctionParameter) {
1622   QualType ExprType = E->getType();
1623   // - in a return statement in a function with ...
1624   // ... a class return type ...
1625   if (!ReturnType.isNull()) {
1626     if (!ReturnType->isRecordType())
1627       return 0;
1628     // ... the same cv-unqualified type as the function return type ...
1629     if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
1630       return 0;
1631   }
1632
1633   // ... the expression is the name of a non-volatile automatic object
1634   // (other than a function or catch-clause parameter)) ...
1635   const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
1636   if (!DR)
1637     return 0;
1638   const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
1639   if (!VD)
1640     return 0;
1641
1642   if (VD->hasLocalStorage() && !VD->isExceptionVariable() &&
1643       !VD->getType()->isReferenceType() && !VD->hasAttr<BlocksAttr>() &&
1644       !VD->getType().isVolatileQualified() &&
1645       ((VD->getKind() == Decl::Var) ||
1646        (AllowFunctionParameter && VD->getKind() == Decl::ParmVar)))
1647     return VD;
1648
1649   return 0;
1650 }
1651
1652 /// \brief Perform the initialization of a potentially-movable value, which
1653 /// is the result of return value.
1654 ///
1655 /// This routine implements C++0x [class.copy]p33, which attempts to treat
1656 /// returned lvalues as rvalues in certain cases (to prefer move construction),
1657 /// then falls back to treating them as lvalues if that failed.
1658 ExprResult
1659 Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
1660                                       const VarDecl *NRVOCandidate,
1661                                       QualType ResultType,
1662                                       Expr *Value,
1663                                       bool AllowNRVO) {
1664   // C++0x [class.copy]p33:
1665   //   When the criteria for elision of a copy operation are met or would
1666   //   be met save for the fact that the source object is a function
1667   //   parameter, and the object to be copied is designated by an lvalue,
1668   //   overload resolution to select the constructor for the copy is first
1669   //   performed as if the object were designated by an rvalue.
1670   ExprResult Res = ExprError();
1671   if (AllowNRVO &&
1672       (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true))) {
1673     ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
1674                               Value->getType(), CK_LValueToRValue,
1675                               Value, VK_XValue);
1676
1677     Expr *InitExpr = &AsRvalue;
1678     InitializationKind Kind
1679       = InitializationKind::CreateCopy(Value->getLocStart(),
1680                                        Value->getLocStart());
1681     InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
1682
1683     //   [...] If overload resolution fails, or if the type of the first
1684     //   parameter of the selected constructor is not an rvalue reference
1685     //   to the object's type (possibly cv-qualified), overload resolution
1686     //   is performed again, considering the object as an lvalue.
1687     if (Seq) {
1688       for (InitializationSequence::step_iterator Step = Seq.step_begin(),
1689            StepEnd = Seq.step_end();
1690            Step != StepEnd; ++Step) {
1691         if (Step->Kind != InitializationSequence::SK_ConstructorInitialization)
1692           continue;
1693
1694         CXXConstructorDecl *Constructor
1695         = cast<CXXConstructorDecl>(Step->Function.Function);
1696
1697         const RValueReferenceType *RRefType
1698           = Constructor->getParamDecl(0)->getType()
1699                                                  ->getAs<RValueReferenceType>();
1700
1701         // If we don't meet the criteria, break out now.
1702         if (!RRefType ||
1703             !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
1704                             Context.getTypeDeclType(Constructor->getParent())))
1705           break;
1706
1707         // Promote "AsRvalue" to the heap, since we now need this
1708         // expression node to persist.
1709         Value = ImplicitCastExpr::Create(Context, Value->getType(),
1710                                          CK_LValueToRValue, Value, 0,
1711                                          VK_XValue);
1712
1713         // Complete type-checking the initialization of the return type
1714         // using the constructor we found.
1715         Res = Seq.Perform(*this, Entity, Kind, MultiExprArg(&Value, 1));
1716       }
1717     }
1718   }
1719
1720   // Either we didn't meet the criteria for treating an lvalue as an rvalue,
1721   // above, or overload resolution failed. Either way, we need to try
1722   // (again) now with the return value expression as written.
1723   if (Res.isInvalid())
1724     Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
1725
1726   return Res;
1727 }
1728
1729 /// ActOnBlockReturnStmt - Utility routine to figure out block's return type.
1730 ///
1731 StmtResult
1732 Sema::ActOnBlockReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1733   // If this is the first return we've seen in the block, infer the type of
1734   // the block from it.
1735   BlockScopeInfo *CurBlock = getCurBlock();
1736   if (CurBlock->ReturnType.isNull()) {
1737     if (RetValExp) {
1738       // Don't call UsualUnaryConversions(), since we don't want to do
1739       // integer promotions here.
1740       ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
1741       if (Result.isInvalid())
1742         return StmtError();
1743       RetValExp = Result.take();
1744
1745       if (!RetValExp->isTypeDependent()) {
1746         CurBlock->ReturnType = RetValExp->getType();
1747         if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(RetValExp)) {
1748           // We have to remove a 'const' added to copied-in variable which was
1749           // part of the implementation spec. and not the actual qualifier for
1750           // the variable.
1751           if (CDRE->isConstQualAdded())
1752             CurBlock->ReturnType.removeLocalConst(); // FIXME: local???
1753         }
1754       } else
1755         CurBlock->ReturnType = Context.DependentTy;
1756     } else
1757       CurBlock->ReturnType = Context.VoidTy;
1758   }
1759   QualType FnRetType = CurBlock->ReturnType;
1760
1761   if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
1762     Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr)
1763       << getCurFunctionOrMethodDecl()->getDeclName();
1764     return StmtError();
1765   }
1766
1767   // Otherwise, verify that this result type matches the previous one.  We are
1768   // pickier with blocks than for normal functions because we don't have GCC
1769   // compatibility to worry about here.
1770   const VarDecl *NRVOCandidate = 0;
1771   if (FnRetType->isDependentType()) {
1772     // Delay processing for now.  TODO: there are lots of dependent
1773     // types we can conclusively prove aren't void.
1774   } else if (FnRetType->isVoidType()) {
1775     if (RetValExp &&
1776         !(getLangOptions().CPlusPlus &&
1777           (RetValExp->isTypeDependent() ||
1778            RetValExp->getType()->isVoidType()))) {
1779       Diag(ReturnLoc, diag::err_return_block_has_expr);
1780       RetValExp = 0;
1781     }
1782   } else if (!RetValExp) {
1783     return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
1784   } else if (!RetValExp->isTypeDependent()) {
1785     // we have a non-void block with an expression, continue checking
1786
1787     // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1788     // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1789     // function return.
1790
1791     // In C++ the return statement is handled via a copy initialization.
1792     // the C version of which boils down to CheckSingleAssignmentConstraints.
1793     NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1794     InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1795                                                                    FnRetType,
1796                                                            NRVOCandidate != 0);
1797     ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1798                                                      FnRetType, RetValExp);
1799     if (Res.isInvalid()) {
1800       // FIXME: Cleanup temporaries here, anyway?
1801       return StmtError();
1802     }
1803     RetValExp = Res.take();
1804     CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1805   }
1806
1807   if (RetValExp) {
1808     CheckImplicitConversions(RetValExp, ReturnLoc);
1809     RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1810   }
1811   ReturnStmt *Result = new (Context) ReturnStmt(ReturnLoc, RetValExp,
1812                                                 NRVOCandidate);
1813
1814   // If we need to check for the named return value optimization, save the
1815   // return statement in our scope for later processing.
1816   if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1817       !CurContext->isDependentContext())
1818     FunctionScopes.back()->Returns.push_back(Result);
1819
1820   return Owned(Result);
1821 }
1822
1823 StmtResult
1824 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1825   // Check for unexpanded parameter packs.
1826   if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
1827     return StmtError();
1828
1829   if (getCurBlock())
1830     return ActOnBlockReturnStmt(ReturnLoc, RetValExp);
1831
1832   QualType FnRetType;
1833   QualType DeclaredRetType;
1834   if (const FunctionDecl *FD = getCurFunctionDecl()) {
1835     FnRetType = FD->getResultType();
1836     DeclaredRetType = FnRetType;
1837     if (FD->hasAttr<NoReturnAttr>() ||
1838         FD->getType()->getAs<FunctionType>()->getNoReturnAttr())
1839       Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
1840         << getCurFunctionOrMethodDecl()->getDeclName();
1841   } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
1842     DeclaredRetType = MD->getResultType();
1843     if (MD->hasRelatedResultType() && MD->getClassInterface()) {
1844       // In the implementation of a method with a related return type, the
1845       // type used to type-check the validity of return statements within the
1846       // method body is a pointer to the type of the class being implemented.
1847       FnRetType = Context.getObjCInterfaceType(MD->getClassInterface());
1848       FnRetType = Context.getObjCObjectPointerType(FnRetType);
1849     } else {
1850       FnRetType = DeclaredRetType;
1851     }
1852   } else // If we don't have a function/method context, bail.
1853     return StmtError();
1854
1855   ReturnStmt *Result = 0;
1856   if (FnRetType->isVoidType()) {
1857     if (RetValExp) {
1858       if (!RetValExp->isTypeDependent()) {
1859         // C99 6.8.6.4p1 (ext_ since GCC warns)
1860         unsigned D = diag::ext_return_has_expr;
1861         if (RetValExp->getType()->isVoidType())
1862           D = diag::ext_return_has_void_expr;
1863         else {
1864           ExprResult Result = Owned(RetValExp);
1865           Result = IgnoredValueConversions(Result.take());
1866           if (Result.isInvalid())
1867             return StmtError();
1868           RetValExp = Result.take();
1869           RetValExp = ImpCastExprToType(RetValExp,
1870                                         Context.VoidTy, CK_ToVoid).take();
1871         }
1872
1873         // return (some void expression); is legal in C++.
1874         if (D != diag::ext_return_has_void_expr ||
1875             !getLangOptions().CPlusPlus) {
1876           NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
1877
1878           int FunctionKind = 0;
1879           if (isa<ObjCMethodDecl>(CurDecl))
1880             FunctionKind = 1;
1881           else if (isa<CXXConstructorDecl>(CurDecl))
1882             FunctionKind = 2;
1883           else if (isa<CXXDestructorDecl>(CurDecl))
1884             FunctionKind = 3;
1885
1886           Diag(ReturnLoc, D)
1887             << CurDecl->getDeclName() << FunctionKind
1888             << RetValExp->getSourceRange();
1889         }
1890       }
1891
1892       CheckImplicitConversions(RetValExp, ReturnLoc);
1893       RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1894     }
1895
1896     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
1897   } else if (!RetValExp && !FnRetType->isDependentType()) {
1898     unsigned DiagID = diag::warn_return_missing_expr;  // C90 6.6.6.4p4
1899     // C99 6.8.6.4p1 (ext_ since GCC warns)
1900     if (getLangOptions().C99) DiagID = diag::ext_return_missing_expr;
1901
1902     if (FunctionDecl *FD = getCurFunctionDecl())
1903       Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
1904     else
1905       Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
1906     Result = new (Context) ReturnStmt(ReturnLoc);
1907   } else {
1908     const VarDecl *NRVOCandidate = 0;
1909     if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1910       // we have a non-void function with an expression, continue checking
1911
1912       // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1913       // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1914       // function return.
1915
1916       // In C++ the return statement is handled via a copy initialization,
1917       // the C version of which boils down to CheckSingleAssignmentConstraints.
1918       NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1919       InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1920                                                                      FnRetType,
1921                                                             NRVOCandidate != 0);
1922       ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1923                                                        FnRetType, RetValExp);
1924       if (Res.isInvalid()) {
1925         // FIXME: Cleanup temporaries here, anyway?
1926         return StmtError();
1927       }
1928
1929       RetValExp = Res.takeAs<Expr>();
1930       if (RetValExp)
1931         CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1932     }
1933
1934     if (RetValExp) {
1935       // If we type-checked an Objective-C method's return type based
1936       // on a related return type, we may need to adjust the return
1937       // type again. Do so now.
1938       if (DeclaredRetType != FnRetType) {
1939         ExprResult result = PerformImplicitConversion(RetValExp,
1940                                                       DeclaredRetType,
1941                                                       AA_Returning);
1942         if (result.isInvalid()) return StmtError();
1943         RetValExp = result.take();
1944       }
1945
1946       CheckImplicitConversions(RetValExp, ReturnLoc);
1947       RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1948     }
1949     Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1950   }
1951
1952   // If we need to check for the named return value optimization, save the
1953   // return statement in our scope for later processing.
1954   if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1955       !CurContext->isDependentContext())
1956     FunctionScopes.back()->Returns.push_back(Result);
1957
1958   return Owned(Result);
1959 }
1960
1961 /// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
1962 /// ignore "noop" casts in places where an lvalue is required by an inline asm.
1963 /// We emulate this behavior when -fheinous-gnu-extensions is specified, but
1964 /// provide a strong guidance to not use it.
1965 ///
1966 /// This method checks to see if the argument is an acceptable l-value and
1967 /// returns false if it is a case we can handle.
1968 static bool CheckAsmLValue(const Expr *E, Sema &S) {
1969   // Type dependent expressions will be checked during instantiation.
1970   if (E->isTypeDependent())
1971     return false;
1972
1973   if (E->isLValue())
1974     return false;  // Cool, this is an lvalue.
1975
1976   // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
1977   // are supposed to allow.
1978   const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
1979   if (E != E2 && E2->isLValue()) {
1980     if (!S.getLangOptions().HeinousExtensions)
1981       S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
1982         << E->getSourceRange();
1983     else
1984       S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
1985         << E->getSourceRange();
1986     // Accept, even if we emitted an error diagnostic.
1987     return false;
1988   }
1989
1990   // None of the above, just randomly invalid non-lvalue.
1991   return true;
1992 }
1993
1994 /// isOperandMentioned - Return true if the specified operand # is mentioned
1995 /// anywhere in the decomposed asm string.
1996 static bool isOperandMentioned(unsigned OpNo,
1997                          ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) {
1998   for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
1999     const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
2000     if (!Piece.isOperand()) continue;
2001
2002     // If this is a reference to the input and if the input was the smaller
2003     // one, then we have to reject this asm.
2004     if (Piece.getOperandNo() == OpNo)
2005       return true;
2006   }
2007
2008   return false;
2009 }
2010
2011 StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple,
2012                               bool IsVolatile, unsigned NumOutputs,
2013                               unsigned NumInputs, IdentifierInfo **Names,
2014                               MultiExprArg constraints, MultiExprArg exprs,
2015                               Expr *asmString, MultiExprArg clobbers,
2016                               SourceLocation RParenLoc, bool MSAsm) {
2017   unsigned NumClobbers = clobbers.size();
2018   StringLiteral **Constraints =
2019     reinterpret_cast<StringLiteral**>(constraints.get());
2020   Expr **Exprs = exprs.get();
2021   StringLiteral *AsmString = cast<StringLiteral>(asmString);
2022   StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
2023
2024   SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
2025
2026   // The parser verifies that there is a string literal here.
2027   if (!AsmString->isAscii())
2028     return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
2029       << AsmString->getSourceRange());
2030
2031   for (unsigned i = 0; i != NumOutputs; i++) {
2032     StringLiteral *Literal = Constraints[i];
2033     if (!Literal->isAscii())
2034       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2035         << Literal->getSourceRange());
2036
2037     StringRef OutputName;
2038     if (Names[i])
2039       OutputName = Names[i]->getName();
2040
2041     TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
2042     if (!Context.getTargetInfo().validateOutputConstraint(Info))
2043       return StmtError(Diag(Literal->getLocStart(),
2044                             diag::err_asm_invalid_output_constraint)
2045                        << Info.getConstraintStr());
2046
2047     // Check that the output exprs are valid lvalues.
2048     Expr *OutputExpr = Exprs[i];
2049     if (CheckAsmLValue(OutputExpr, *this)) {
2050       return StmtError(Diag(OutputExpr->getLocStart(),
2051                   diag::err_asm_invalid_lvalue_in_output)
2052         << OutputExpr->getSourceRange());
2053     }
2054
2055     OutputConstraintInfos.push_back(Info);
2056   }
2057
2058   SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
2059
2060   for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
2061     StringLiteral *Literal = Constraints[i];
2062     if (!Literal->isAscii())
2063       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2064         << Literal->getSourceRange());
2065
2066     StringRef InputName;
2067     if (Names[i])
2068       InputName = Names[i]->getName();
2069
2070     TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
2071     if (!Context.getTargetInfo().validateInputConstraint(OutputConstraintInfos.data(),
2072                                                 NumOutputs, Info)) {
2073       return StmtError(Diag(Literal->getLocStart(),
2074                             diag::err_asm_invalid_input_constraint)
2075                        << Info.getConstraintStr());
2076     }
2077
2078     Expr *InputExpr = Exprs[i];
2079
2080     // Only allow void types for memory constraints.
2081     if (Info.allowsMemory() && !Info.allowsRegister()) {
2082       if (CheckAsmLValue(InputExpr, *this))
2083         return StmtError(Diag(InputExpr->getLocStart(),
2084                               diag::err_asm_invalid_lvalue_in_input)
2085                          << Info.getConstraintStr()
2086                          << InputExpr->getSourceRange());
2087     }
2088
2089     if (Info.allowsRegister()) {
2090       if (InputExpr->getType()->isVoidType()) {
2091         return StmtError(Diag(InputExpr->getLocStart(),
2092                               diag::err_asm_invalid_type_in_input)
2093           << InputExpr->getType() << Info.getConstraintStr()
2094           << InputExpr->getSourceRange());
2095       }
2096     }
2097
2098     ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
2099     if (Result.isInvalid())
2100       return StmtError();
2101
2102     Exprs[i] = Result.take();
2103     InputConstraintInfos.push_back(Info);
2104   }
2105
2106   // Check that the clobbers are valid.
2107   for (unsigned i = 0; i != NumClobbers; i++) {
2108     StringLiteral *Literal = Clobbers[i];
2109     if (!Literal->isAscii())
2110       return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2111         << Literal->getSourceRange());
2112
2113     StringRef Clobber = Literal->getString();
2114
2115     if (!Context.getTargetInfo().isValidClobber(Clobber))
2116       return StmtError(Diag(Literal->getLocStart(),
2117                   diag::err_asm_unknown_register_name) << Clobber);
2118   }
2119
2120   AsmStmt *NS =
2121     new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm,
2122                           NumOutputs, NumInputs, Names, Constraints, Exprs,
2123                           AsmString, NumClobbers, Clobbers, RParenLoc);
2124   // Validate the asm string, ensuring it makes sense given the operands we
2125   // have.
2126   SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
2127   unsigned DiagOffs;
2128   if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
2129     Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
2130            << AsmString->getSourceRange();
2131     return StmtError();
2132   }
2133
2134   // Validate tied input operands for type mismatches.
2135   for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
2136     TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
2137
2138     // If this is a tied constraint, verify that the output and input have
2139     // either exactly the same type, or that they are int/ptr operands with the
2140     // same size (int/long, int*/long, are ok etc).
2141     if (!Info.hasTiedOperand()) continue;
2142
2143     unsigned TiedTo = Info.getTiedOperand();
2144     unsigned InputOpNo = i+NumOutputs;
2145     Expr *OutputExpr = Exprs[TiedTo];
2146     Expr *InputExpr = Exprs[InputOpNo];
2147
2148     if (OutputExpr->isTypeDependent() || InputExpr->isTypeDependent())
2149       continue;
2150
2151     QualType InTy = InputExpr->getType();
2152     QualType OutTy = OutputExpr->getType();
2153     if (Context.hasSameType(InTy, OutTy))
2154       continue;  // All types can be tied to themselves.
2155
2156     // Decide if the input and output are in the same domain (integer/ptr or
2157     // floating point.
2158     enum AsmDomain {
2159       AD_Int, AD_FP, AD_Other
2160     } InputDomain, OutputDomain;
2161
2162     if (InTy->isIntegerType() || InTy->isPointerType())
2163       InputDomain = AD_Int;
2164     else if (InTy->isRealFloatingType())
2165       InputDomain = AD_FP;
2166     else
2167       InputDomain = AD_Other;
2168
2169     if (OutTy->isIntegerType() || OutTy->isPointerType())
2170       OutputDomain = AD_Int;
2171     else if (OutTy->isRealFloatingType())
2172       OutputDomain = AD_FP;
2173     else
2174       OutputDomain = AD_Other;
2175
2176     // They are ok if they are the same size and in the same domain.  This
2177     // allows tying things like:
2178     //   void* to int*
2179     //   void* to int            if they are the same size.
2180     //   double to long double   if they are the same size.
2181     //
2182     uint64_t OutSize = Context.getTypeSize(OutTy);
2183     uint64_t InSize = Context.getTypeSize(InTy);
2184     if (OutSize == InSize && InputDomain == OutputDomain &&
2185         InputDomain != AD_Other)
2186       continue;
2187
2188     // If the smaller input/output operand is not mentioned in the asm string,
2189     // then we can promote the smaller one to a larger input and the asm string
2190     // won't notice.
2191     bool SmallerValueMentioned = false;
2192
2193     // If this is a reference to the input and if the input was the smaller
2194     // one, then we have to reject this asm.
2195     if (isOperandMentioned(InputOpNo, Pieces)) {
2196       // This is a use in the asm string of the smaller operand.  Since we
2197       // codegen this by promoting to a wider value, the asm will get printed
2198       // "wrong".
2199       SmallerValueMentioned |= InSize < OutSize;
2200     }
2201     if (isOperandMentioned(TiedTo, Pieces)) {
2202       // If this is a reference to the output, and if the output is the larger
2203       // value, then it's ok because we'll promote the input to the larger type.
2204       SmallerValueMentioned |= OutSize < InSize;
2205     }
2206
2207     // If the smaller value wasn't mentioned in the asm string, and if the
2208     // output was a register, just extend the shorter one to the size of the
2209     // larger one.
2210     if (!SmallerValueMentioned && InputDomain != AD_Other &&
2211         OutputConstraintInfos[TiedTo].allowsRegister())
2212       continue;
2213
2214     // Either both of the operands were mentioned or the smaller one was
2215     // mentioned.  One more special case that we'll allow: if the tied input is
2216     // integer, unmentioned, and is a constant, then we'll allow truncating it
2217     // down to the size of the destination.
2218     if (InputDomain == AD_Int && OutputDomain == AD_Int &&
2219         !isOperandMentioned(InputOpNo, Pieces) &&
2220         InputExpr->isEvaluatable(Context)) {
2221       CastKind castKind =
2222         (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
2223       InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2224       Exprs[InputOpNo] = InputExpr;
2225       NS->setInputExpr(i, InputExpr);
2226       continue;
2227     }
2228
2229     Diag(InputExpr->getLocStart(),
2230          diag::err_asm_tying_incompatible_types)
2231       << InTy << OutTy << OutputExpr->getSourceRange()
2232       << InputExpr->getSourceRange();
2233     return StmtError();
2234   }
2235
2236   return Owned(NS);
2237 }
2238
2239 StmtResult
2240 Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
2241                            SourceLocation RParen, Decl *Parm,
2242                            Stmt *Body) {
2243   VarDecl *Var = cast_or_null<VarDecl>(Parm);
2244   if (Var && Var->isInvalidDecl())
2245     return StmtError();
2246
2247   return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
2248 }
2249
2250 StmtResult
2251 Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
2252   return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
2253 }
2254
2255 StmtResult
2256 Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
2257                          MultiStmtArg CatchStmts, Stmt *Finally) {
2258   if (!getLangOptions().ObjCExceptions)
2259     Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
2260
2261   getCurFunction()->setHasBranchProtectedScope();
2262   unsigned NumCatchStmts = CatchStmts.size();
2263   return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
2264                                      CatchStmts.release(),
2265                                      NumCatchStmts,
2266                                      Finally));
2267 }
2268
2269 StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc,
2270                                                   Expr *Throw) {
2271   if (Throw) {
2272     Throw = MaybeCreateExprWithCleanups(Throw);
2273     ExprResult Result = DefaultLvalueConversion(Throw);
2274     if (Result.isInvalid())
2275       return StmtError();
2276
2277     Throw = Result.take();
2278     QualType ThrowType = Throw->getType();
2279     // Make sure the expression type is an ObjC pointer or "void *".
2280     if (!ThrowType->isDependentType() &&
2281         !ThrowType->isObjCObjectPointerType()) {
2282       const PointerType *PT = ThrowType->getAs<PointerType>();
2283       if (!PT || !PT->getPointeeType()->isVoidType())
2284         return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
2285                          << Throw->getType() << Throw->getSourceRange());
2286     }
2287   }
2288
2289   return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
2290 }
2291
2292 StmtResult
2293 Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
2294                            Scope *CurScope) {
2295   if (!getLangOptions().ObjCExceptions)
2296     Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
2297
2298   if (!Throw) {
2299     // @throw without an expression designates a rethrow (which much occur
2300     // in the context of an @catch clause).
2301     Scope *AtCatchParent = CurScope;
2302     while (AtCatchParent && !AtCatchParent->isAtCatchScope())
2303       AtCatchParent = AtCatchParent->getParent();
2304     if (!AtCatchParent)
2305       return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
2306   }
2307
2308   return BuildObjCAtThrowStmt(AtLoc, Throw);
2309 }
2310
2311 ExprResult
2312 Sema::ActOnObjCAtSynchronizedOperand(SourceLocation atLoc, Expr *operand) {
2313   ExprResult result = DefaultLvalueConversion(operand);
2314   if (result.isInvalid())
2315     return ExprError();
2316   operand = result.take();
2317
2318   // Make sure the expression type is an ObjC pointer or "void *".
2319   QualType type = operand->getType();
2320   if (!type->isDependentType() &&
2321       !type->isObjCObjectPointerType()) {
2322     const PointerType *pointerType = type->getAs<PointerType>();
2323     if (!pointerType || !pointerType->getPointeeType()->isVoidType())
2324       return Diag(atLoc, diag::error_objc_synchronized_expects_object)
2325                << type << operand->getSourceRange();
2326   }
2327
2328   // The operand to @synchronized is a full-expression.
2329   return MaybeCreateExprWithCleanups(operand);
2330 }
2331
2332 StmtResult
2333 Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
2334                                   Stmt *SyncBody) {
2335   // We can't jump into or indirect-jump out of a @synchronized block.
2336   getCurFunction()->setHasBranchProtectedScope();
2337   return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
2338 }
2339
2340 /// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
2341 /// and creates a proper catch handler from them.
2342 StmtResult
2343 Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl,
2344                          Stmt *HandlerBlock) {
2345   // There's nothing to test that ActOnExceptionDecl didn't already test.
2346   return Owned(new (Context) CXXCatchStmt(CatchLoc,
2347                                           cast_or_null<VarDecl>(ExDecl),
2348                                           HandlerBlock));
2349 }
2350
2351 StmtResult
2352 Sema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) {
2353   getCurFunction()->setHasBranchProtectedScope();
2354   return Owned(new (Context) ObjCAutoreleasePoolStmt(AtLoc, Body));
2355 }
2356
2357 namespace {
2358
2359 class TypeWithHandler {
2360   QualType t;
2361   CXXCatchStmt *stmt;
2362 public:
2363   TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
2364   : t(type), stmt(statement) {}
2365
2366   // An arbitrary order is fine as long as it places identical
2367   // types next to each other.
2368   bool operator<(const TypeWithHandler &y) const {
2369     if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr())
2370       return true;
2371     if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
2372       return false;
2373     else
2374       return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
2375   }
2376
2377   bool operator==(const TypeWithHandler& other) const {
2378     return t == other.t;
2379   }
2380
2381   CXXCatchStmt *getCatchStmt() const { return stmt; }
2382   SourceLocation getTypeSpecStartLoc() const {
2383     return stmt->getExceptionDecl()->getTypeSpecStartLoc();
2384   }
2385 };
2386
2387 }
2388
2389 /// ActOnCXXTryBlock - Takes a try compound-statement and a number of
2390 /// handlers and creates a try statement from them.
2391 StmtResult
2392 Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
2393                        MultiStmtArg RawHandlers) {
2394   // Don't report an error if 'try' is used in system headers.
2395   if (!getLangOptions().CXXExceptions &&
2396       !getSourceManager().isInSystemHeader(TryLoc))
2397       Diag(TryLoc, diag::err_exceptions_disabled) << "try";
2398
2399   unsigned NumHandlers = RawHandlers.size();
2400   assert(NumHandlers > 0 &&
2401          "The parser shouldn't call this if there are no handlers.");
2402   Stmt **Handlers = RawHandlers.get();
2403
2404   SmallVector<TypeWithHandler, 8> TypesWithHandlers;
2405
2406   for (unsigned i = 0; i < NumHandlers; ++i) {
2407     CXXCatchStmt *Handler = cast<CXXCatchStmt>(Handlers[i]);
2408     if (!Handler->getExceptionDecl()) {
2409       if (i < NumHandlers - 1)
2410         return StmtError(Diag(Handler->getLocStart(),
2411                               diag::err_early_catch_all));
2412
2413       continue;
2414     }
2415
2416     const QualType CaughtType = Handler->getCaughtType();
2417     const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
2418     TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
2419   }
2420
2421   // Detect handlers for the same type as an earlier one.
2422   if (NumHandlers > 1) {
2423     llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
2424
2425     TypeWithHandler prev = TypesWithHandlers[0];
2426     for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
2427       TypeWithHandler curr = TypesWithHandlers[i];
2428
2429       if (curr == prev) {
2430         Diag(curr.getTypeSpecStartLoc(),
2431              diag::warn_exception_caught_by_earlier_handler)
2432           << curr.getCatchStmt()->getCaughtType().getAsString();
2433         Diag(prev.getTypeSpecStartLoc(),
2434              diag::note_previous_exception_handler)
2435           << prev.getCatchStmt()->getCaughtType().getAsString();
2436       }
2437
2438       prev = curr;
2439     }
2440   }
2441
2442   getCurFunction()->setHasBranchProtectedScope();
2443
2444   // FIXME: We should detect handlers that cannot catch anything because an
2445   // earlier handler catches a superclass. Need to find a method that is not
2446   // quadratic for this.
2447   // Neither of these are explicitly forbidden, but every compiler detects them
2448   // and warns.
2449
2450   return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
2451                                   Handlers, NumHandlers));
2452 }
2453
2454 StmtResult
2455 Sema::ActOnSEHTryBlock(bool IsCXXTry,
2456                        SourceLocation TryLoc,
2457                        Stmt *TryBlock,
2458                        Stmt *Handler) {
2459   assert(TryBlock && Handler);
2460
2461   getCurFunction()->setHasBranchProtectedScope();
2462
2463   return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
2464 }
2465
2466 StmtResult
2467 Sema::ActOnSEHExceptBlock(SourceLocation Loc,
2468                           Expr *FilterExpr,
2469                           Stmt *Block) {
2470   assert(FilterExpr && Block);
2471
2472   if(!FilterExpr->getType()->isIntegerType()) {
2473     return StmtError(Diag(FilterExpr->getExprLoc(),
2474                      diag::err_filter_expression_integral)
2475                      << FilterExpr->getType());
2476   }
2477
2478   return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
2479 }
2480
2481 StmtResult
2482 Sema::ActOnSEHFinallyBlock(SourceLocation Loc,
2483                            Stmt *Block) {
2484   assert(Block);
2485   return Owned(SEHFinallyStmt::Create(Context,Loc,Block));
2486 }