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