SemaStmt.cpp revision 0faede6f31b07bcec7b776f2b420c3ea9bb3e58c
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 "Sema.h" 15#include "SemaInit.h" 16#include "clang/AST/APValue.h" 17#include "clang/AST/ASTContext.h" 18#include "clang/AST/DeclObjC.h" 19#include "clang/AST/ExprCXX.h" 20#include "clang/AST/ExprObjC.h" 21#include "clang/AST/StmtObjC.h" 22#include "clang/AST/StmtCXX.h" 23#include "clang/Lex/Preprocessor.h" 24#include "clang/Basic/TargetInfo.h" 25#include "llvm/ADT/STLExtras.h" 26#include "llvm/ADT/SmallVector.h" 27using namespace clang; 28 29Sema::OwningStmtResult Sema::ActOnExprStmt(FullExprArg expr) { 30 Expr *E = expr->takeAs<Expr>(); 31 assert(E && "ActOnExprStmt(): missing expression"); 32 if (E->getType()->isObjCInterfaceType()) { 33 if (LangOpts.ObjCNonFragileABI) 34 Diag(E->getLocEnd(), diag::err_indirection_requires_nonfragile_object) 35 << E->getType(); 36 else 37 Diag(E->getLocEnd(), diag::err_direct_interface_unsupported) 38 << E->getType(); 39 return StmtError(); 40 } 41 // C99 6.8.3p2: The expression in an expression statement is evaluated as a 42 // void expression for its side effects. Conversion to void allows any 43 // operand, even incomplete types. 44 45 // Same thing in for stmt first clause (when expr) and third clause. 46 return Owned(static_cast<Stmt*>(E)); 47} 48 49 50Sema::OwningStmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc) { 51 return Owned(new (Context) NullStmt(SemiLoc)); 52} 53 54Sema::OwningStmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, 55 SourceLocation StartLoc, 56 SourceLocation EndLoc) { 57 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>(); 58 59 // If we have an invalid decl, just return an error. 60 if (DG.isNull()) return StmtError(); 61 62 return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc)); 63} 64 65void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) { 66 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>(); 67 68 // If we have an invalid decl, just return. 69 if (DG.isNull() || !DG.isSingleDecl()) return; 70 // suppress any potential 'unused variable' warning. 71 DG.getSingleDecl()->setUsed(); 72} 73 74void Sema::DiagnoseUnusedExprResult(const Stmt *S) { 75 const Expr *E = dyn_cast_or_null<Expr>(S); 76 if (!E) 77 return; 78 79 SourceLocation Loc; 80 SourceRange R1, R2; 81 if (!E->isUnusedResultAWarning(Loc, R1, R2, Context)) 82 return; 83 84 // Okay, we have an unused result. Depending on what the base expression is, 85 // we might want to make a more specific diagnostic. Check for one of these 86 // cases now. 87 unsigned DiagID = diag::warn_unused_expr; 88 E = E->IgnoreParens(); 89 if (isa<ObjCImplicitSetterGetterRefExpr>(E)) 90 DiagID = diag::warn_unused_property_expr; 91 92 if (const CXXExprWithTemporaries *Temps = dyn_cast<CXXExprWithTemporaries>(E)) 93 E = Temps->getSubExpr(); 94 if (const CXXZeroInitValueExpr *Zero = dyn_cast<CXXZeroInitValueExpr>(E)) { 95 if (const RecordType *RecordT = Zero->getType()->getAs<RecordType>()) 96 if (CXXRecordDecl *RecordD = dyn_cast<CXXRecordDecl>(RecordT->getDecl())) 97 if (!RecordD->hasTrivialDestructor()) 98 return; 99 } 100 101 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) { 102 if (E->getType()->isVoidType()) 103 return; 104 105 // If the callee has attribute pure, const, or warn_unused_result, warn with 106 // a more specific message to make it clear what is happening. 107 if (const Decl *FD = CE->getCalleeDecl()) { 108 if (FD->getAttr<WarnUnusedResultAttr>()) { 109 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result"; 110 return; 111 } 112 if (FD->getAttr<PureAttr>()) { 113 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure"; 114 return; 115 } 116 if (FD->getAttr<ConstAttr>()) { 117 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const"; 118 return; 119 } 120 } 121 } 122 123 Diag(Loc, DiagID) << R1 << R2; 124} 125 126Action::OwningStmtResult 127Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R, 128 MultiStmtArg elts, bool isStmtExpr) { 129 unsigned NumElts = elts.size(); 130 Stmt **Elts = reinterpret_cast<Stmt**>(elts.release()); 131 // If we're in C89 mode, check that we don't have any decls after stmts. If 132 // so, emit an extension diagnostic. 133 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) { 134 // Note that __extension__ can be around a decl. 135 unsigned i = 0; 136 // Skip over all declarations. 137 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i) 138 /*empty*/; 139 140 // We found the end of the list or a statement. Scan for another declstmt. 141 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i) 142 /*empty*/; 143 144 if (i != NumElts) { 145 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin(); 146 Diag(D->getLocation(), diag::ext_mixed_decls_code); 147 } 148 } 149 // Warn about unused expressions in statements. 150 for (unsigned i = 0; i != NumElts; ++i) { 151 // Ignore statements that are last in a statement expression. 152 if (isStmtExpr && i == NumElts - 1) 153 continue; 154 155 DiagnoseUnusedExprResult(Elts[i]); 156 } 157 158 return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R)); 159} 160 161Action::OwningStmtResult 162Sema::ActOnCaseStmt(SourceLocation CaseLoc, ExprArg lhsval, 163 SourceLocation DotDotDotLoc, ExprArg rhsval, 164 SourceLocation ColonLoc) { 165 assert((lhsval.get() != 0) && "missing expression in case statement"); 166 167 // C99 6.8.4.2p3: The expression shall be an integer constant. 168 // However, GCC allows any evaluatable integer expression. 169 Expr *LHSVal = static_cast<Expr*>(lhsval.get()); 170 if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent() && 171 VerifyIntegerConstantExpression(LHSVal)) 172 return StmtError(); 173 174 // GCC extension: The expression shall be an integer constant. 175 176 Expr *RHSVal = static_cast<Expr*>(rhsval.get()); 177 if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent() && 178 VerifyIntegerConstantExpression(RHSVal)) { 179 RHSVal = 0; // Recover by just forgetting about it. 180 rhsval = 0; 181 } 182 183 if (getSwitchStack().empty()) { 184 Diag(CaseLoc, diag::err_case_not_in_switch); 185 return StmtError(); 186 } 187 188 // Only now release the smart pointers. 189 lhsval.release(); 190 rhsval.release(); 191 CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc, 192 ColonLoc); 193 getSwitchStack().back()->addSwitchCase(CS); 194 return Owned(CS); 195} 196 197/// ActOnCaseStmtBody - This installs a statement as the body of a case. 198void Sema::ActOnCaseStmtBody(StmtTy *caseStmt, StmtArg subStmt) { 199 CaseStmt *CS = static_cast<CaseStmt*>(caseStmt); 200 Stmt *SubStmt = subStmt.takeAs<Stmt>(); 201 CS->setSubStmt(SubStmt); 202} 203 204Action::OwningStmtResult 205Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, 206 StmtArg subStmt, Scope *CurScope) { 207 Stmt *SubStmt = subStmt.takeAs<Stmt>(); 208 209 if (getSwitchStack().empty()) { 210 Diag(DefaultLoc, diag::err_default_not_in_switch); 211 return Owned(SubStmt); 212 } 213 214 DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt); 215 getSwitchStack().back()->addSwitchCase(DS); 216 return Owned(DS); 217} 218 219Action::OwningStmtResult 220Sema::ActOnLabelStmt(SourceLocation IdentLoc, IdentifierInfo *II, 221 SourceLocation ColonLoc, StmtArg subStmt) { 222 Stmt *SubStmt = subStmt.takeAs<Stmt>(); 223 // Look up the record for this label identifier. 224 LabelStmt *&LabelDecl = getLabelMap()[II]; 225 226 // If not forward referenced or defined already, just create a new LabelStmt. 227 if (LabelDecl == 0) 228 return Owned(LabelDecl = new (Context) LabelStmt(IdentLoc, II, SubStmt)); 229 230 assert(LabelDecl->getID() == II && "Label mismatch!"); 231 232 // Otherwise, this label was either forward reference or multiply defined. If 233 // multiply defined, reject it now. 234 if (LabelDecl->getSubStmt()) { 235 Diag(IdentLoc, diag::err_redefinition_of_label) << LabelDecl->getID(); 236 Diag(LabelDecl->getIdentLoc(), diag::note_previous_definition); 237 return Owned(SubStmt); 238 } 239 240 // Otherwise, this label was forward declared, and we just found its real 241 // definition. Fill in the forward definition and return it. 242 LabelDecl->setIdentLoc(IdentLoc); 243 LabelDecl->setSubStmt(SubStmt); 244 return Owned(LabelDecl); 245} 246 247Action::OwningStmtResult 248Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, DeclPtrTy CondVar, 249 StmtArg ThenVal, SourceLocation ElseLoc, 250 StmtArg ElseVal) { 251 OwningExprResult CondResult(CondVal.release()); 252 253 VarDecl *ConditionVar = 0; 254 if (CondVar.get()) { 255 ConditionVar = CondVar.getAs<VarDecl>(); 256 CondResult = CheckConditionVariable(ConditionVar); 257 if (CondResult.isInvalid()) 258 return StmtError(); 259 } 260 Expr *ConditionExpr = CondResult.takeAs<Expr>(); 261 if (!ConditionExpr) 262 return StmtError(); 263 264 if (CheckBooleanCondition(ConditionExpr, IfLoc)) { 265 CondResult = ConditionExpr; 266 return StmtError(); 267 } 268 269 Stmt *thenStmt = ThenVal.takeAs<Stmt>(); 270 DiagnoseUnusedExprResult(thenStmt); 271 272 // Warn if the if block has a null body without an else value. 273 // this helps prevent bugs due to typos, such as 274 // if (condition); 275 // do_stuff(); 276 if (!ElseVal.get()) { 277 if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt)) 278 Diag(stmt->getSemiLoc(), diag::warn_empty_if_body); 279 } 280 281 Stmt *elseStmt = ElseVal.takeAs<Stmt>(); 282 DiagnoseUnusedExprResult(elseStmt); 283 284 CondResult.release(); 285 return Owned(new (Context) IfStmt(IfLoc, ConditionVar, ConditionExpr, 286 thenStmt, ElseLoc, elseStmt)); 287} 288 289Action::OwningStmtResult 290Sema::ActOnStartOfSwitchStmt(FullExprArg cond, DeclPtrTy CondVar) { 291 OwningExprResult CondResult(cond.release()); 292 293 VarDecl *ConditionVar = 0; 294 if (CondVar.get()) { 295 ConditionVar = CondVar.getAs<VarDecl>(); 296 CondResult = CheckConditionVariable(ConditionVar); 297 if (CondResult.isInvalid()) 298 return StmtError(); 299 } 300 SwitchStmt *SS = new (Context) SwitchStmt(ConditionVar, 301 CondResult.takeAs<Expr>()); 302 getSwitchStack().push_back(SS); 303 return Owned(SS); 304} 305 306/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have 307/// the specified width and sign. If an overflow occurs, detect it and emit 308/// the specified diagnostic. 309void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val, 310 unsigned NewWidth, bool NewSign, 311 SourceLocation Loc, 312 unsigned DiagID) { 313 // Perform a conversion to the promoted condition type if needed. 314 if (NewWidth > Val.getBitWidth()) { 315 // If this is an extension, just do it. 316 Val.extend(NewWidth); 317 Val.setIsSigned(NewSign); 318 319 // If the input was signed and negative and the output is 320 // unsigned, don't bother to warn: this is implementation-defined 321 // behavior. 322 // FIXME: Introduce a second, default-ignored warning for this case? 323 } else if (NewWidth < Val.getBitWidth()) { 324 // If this is a truncation, check for overflow. 325 llvm::APSInt ConvVal(Val); 326 ConvVal.trunc(NewWidth); 327 ConvVal.setIsSigned(NewSign); 328 ConvVal.extend(Val.getBitWidth()); 329 ConvVal.setIsSigned(Val.isSigned()); 330 if (ConvVal != Val) 331 Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10); 332 333 // Regardless of whether a diagnostic was emitted, really do the 334 // truncation. 335 Val.trunc(NewWidth); 336 Val.setIsSigned(NewSign); 337 } else if (NewSign != Val.isSigned()) { 338 // Convert the sign to match the sign of the condition. This can cause 339 // overflow as well: unsigned(INTMIN) 340 // We don't diagnose this overflow, because it is implementation-defined 341 // behavior. 342 // FIXME: Introduce a second, default-ignored warning for this case? 343 llvm::APSInt OldVal(Val); 344 Val.setIsSigned(NewSign); 345 } 346} 347 348namespace { 349 struct CaseCompareFunctor { 350 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 351 const llvm::APSInt &RHS) { 352 return LHS.first < RHS; 353 } 354 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 355 const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 356 return LHS.first < RHS.first; 357 } 358 bool operator()(const llvm::APSInt &LHS, 359 const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 360 return LHS < RHS.first; 361 } 362 }; 363} 364 365/// CmpCaseVals - Comparison predicate for sorting case values. 366/// 367static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs, 368 const std::pair<llvm::APSInt, CaseStmt*>& rhs) { 369 if (lhs.first < rhs.first) 370 return true; 371 372 if (lhs.first == rhs.first && 373 lhs.second->getCaseLoc().getRawEncoding() 374 < rhs.second->getCaseLoc().getRawEncoding()) 375 return true; 376 return false; 377} 378 379/// CmpEnumVals - Comparison predicate for sorting enumeration values. 380/// 381static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs, 382 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs) 383{ 384 return lhs.first < rhs.first; 385} 386 387/// EqEnumVals - Comparison preficate for uniqing enumeration values. 388/// 389static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs, 390 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs) 391{ 392 return lhs.first == rhs.first; 393} 394 395/// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of 396/// potentially integral-promoted expression @p expr. 397static QualType GetTypeBeforeIntegralPromotion(const Expr* expr) { 398 const ImplicitCastExpr *ImplicitCast = 399 dyn_cast_or_null<ImplicitCastExpr>(expr); 400 if (ImplicitCast != NULL) { 401 const Expr *ExprBeforePromotion = ImplicitCast->getSubExpr(); 402 QualType TypeBeforePromotion = ExprBeforePromotion->getType(); 403 if (TypeBeforePromotion->isIntegralType()) { 404 return TypeBeforePromotion; 405 } 406 } 407 return expr->getType(); 408} 409 410/// \brief Check (and possibly convert) the condition in a switch 411/// statement in C++. 412static bool CheckCXXSwitchCondition(Sema &S, SourceLocation SwitchLoc, 413 Expr *&CondExpr) { 414 if (CondExpr->isTypeDependent()) 415 return false; 416 417 QualType CondType = CondExpr->getType(); 418 419 // C++ 6.4.2.p2: 420 // The condition shall be of integral type, enumeration type, or of a class 421 // type for which a single conversion function to integral or enumeration 422 // type exists (12.3). If the condition is of class type, the condition is 423 // converted by calling that conversion function, and the result of the 424 // conversion is used in place of the original condition for the remainder 425 // of this section. Integral promotions are performed. 426 427 // Make sure that the condition expression has a complete type, 428 // otherwise we'll never find any conversions. 429 if (S.RequireCompleteType(SwitchLoc, CondType, 430 PDiag(diag::err_switch_incomplete_class_type) 431 << CondExpr->getSourceRange())) 432 return true; 433 434 llvm::SmallVector<CXXConversionDecl *, 4> ViableConversions; 435 llvm::SmallVector<CXXConversionDecl *, 4> ExplicitConversions; 436 if (const RecordType *RecordTy = CondType->getAs<RecordType>()) { 437 const UnresolvedSetImpl *Conversions 438 = cast<CXXRecordDecl>(RecordTy->getDecl()) 439 ->getVisibleConversionFunctions(); 440 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 441 E = Conversions->end(); I != E; ++I) { 442 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(*I)) 443 if (Conversion->getConversionType().getNonReferenceType() 444 ->isIntegralType()) { 445 if (Conversion->isExplicit()) 446 ExplicitConversions.push_back(Conversion); 447 else 448 ViableConversions.push_back(Conversion); 449 } 450 } 451 452 switch (ViableConversions.size()) { 453 case 0: 454 if (ExplicitConversions.size() == 1) { 455 // The user probably meant to invoke the given explicit 456 // conversion; use it. 457 QualType ConvTy 458 = ExplicitConversions[0]->getConversionType() 459 .getNonReferenceType(); 460 std::string TypeStr; 461 ConvTy.getAsStringInternal(TypeStr, S.Context.PrintingPolicy); 462 463 S.Diag(SwitchLoc, diag::err_switch_explicit_conversion) 464 << CondType << ConvTy << CondExpr->getSourceRange() 465 << CodeModificationHint::CreateInsertion(CondExpr->getLocStart(), 466 "static_cast<" + TypeStr + ">(") 467 << CodeModificationHint::CreateInsertion( 468 S.PP.getLocForEndOfToken(CondExpr->getLocEnd()), 469 ")"); 470 S.Diag(ExplicitConversions[0]->getLocation(), 471 diag::note_switch_conversion) 472 << ConvTy->isEnumeralType() << ConvTy; 473 474 // If we aren't in a SFINAE context, build a call to the 475 // explicit conversion function. 476 if (S.isSFINAEContext()) 477 return true; 478 479 CondExpr = S.BuildCXXMemberCallExpr(CondExpr, ExplicitConversions[0]); 480 } 481 482 // We'll complain below about a non-integral condition type. 483 break; 484 485 case 1: 486 // Apply this conversion. 487 CondExpr = S.BuildCXXMemberCallExpr(CondExpr, ViableConversions[0]); 488 break; 489 490 default: 491 S.Diag(SwitchLoc, diag::err_switch_multiple_conversions) 492 << CondType << CondExpr->getSourceRange(); 493 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) { 494 QualType ConvTy 495 = ViableConversions[I]->getConversionType().getNonReferenceType(); 496 S.Diag(ViableConversions[I]->getLocation(), 497 diag::note_switch_conversion) 498 << ConvTy->isEnumeralType() << ConvTy; 499 } 500 return true; 501 } 502 } 503 504 return false; 505} 506 507/// ActOnSwitchBodyError - This is called if there is an error parsing the 508/// body of the switch stmt instead of ActOnFinishSwitchStmt. 509void Sema::ActOnSwitchBodyError(SourceLocation SwitchLoc, StmtArg Switch, 510 StmtArg Body) { 511 // Keep the switch stack balanced. 512 assert(getSwitchStack().back() == (SwitchStmt*)Switch.get() && 513 "switch stack missing push/pop!"); 514 getSwitchStack().pop_back(); 515} 516 517Action::OwningStmtResult 518Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, StmtArg Switch, 519 StmtArg Body) { 520 Stmt *BodyStmt = Body.takeAs<Stmt>(); 521 522 SwitchStmt *SS = getSwitchStack().back(); 523 assert(SS == (SwitchStmt*)Switch.get() && "switch stack missing push/pop!"); 524 525 SS->setBody(BodyStmt, SwitchLoc); 526 getSwitchStack().pop_back(); 527 528 if (SS->getCond() == 0) { 529 SS->Destroy(Context); 530 return StmtError(); 531 } 532 533 Expr *CondExpr = SS->getCond(); 534 QualType CondTypeBeforePromotion = 535 GetTypeBeforeIntegralPromotion(CondExpr); 536 537 if (getLangOptions().CPlusPlus && 538 CheckCXXSwitchCondition(*this, SwitchLoc, CondExpr)) 539 return StmtError(); 540 541 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr. 542 UsualUnaryConversions(CondExpr); 543 QualType CondType = CondExpr->getType(); 544 SS->setCond(CondExpr); 545 546 // C++ 6.4.2.p2: 547 // Integral promotions are performed (on the switch condition). 548 // 549 // A case value unrepresentable by the original switch condition 550 // type (before the promotion) doesn't make sense, even when it can 551 // be represented by the promoted type. Therefore we need to find 552 // the pre-promotion type of the switch condition. 553 if (!CondExpr->isTypeDependent()) { 554 if (!CondType->isIntegerType()) { // C99 6.8.4.2p1 555 Diag(SwitchLoc, diag::err_typecheck_statement_requires_integer) 556 << CondType << CondExpr->getSourceRange(); 557 return StmtError(); 558 } 559 560 if (CondTypeBeforePromotion->isBooleanType()) { 561 // switch(bool_expr) {...} is often a programmer error, e.g. 562 // switch(n && mask) { ... } // Doh - should be "n & mask". 563 // One can always use an if statement instead of switch(bool_expr). 564 Diag(SwitchLoc, diag::warn_bool_switch_condition) 565 << CondExpr->getSourceRange(); 566 } 567 } 568 569 // Get the bitwidth of the switched-on value before promotions. We must 570 // convert the integer case values to this width before comparison. 571 bool HasDependentValue 572 = CondExpr->isTypeDependent() || CondExpr->isValueDependent(); 573 unsigned CondWidth 574 = HasDependentValue? 0 575 : static_cast<unsigned>(Context.getTypeSize(CondTypeBeforePromotion)); 576 bool CondIsSigned = CondTypeBeforePromotion->isSignedIntegerType(); 577 578 // Accumulate all of the case values in a vector so that we can sort them 579 // and detect duplicates. This vector contains the APInt for the case after 580 // it has been converted to the condition type. 581 typedef llvm::SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy; 582 CaseValsTy CaseVals; 583 584 // Keep track of any GNU case ranges we see. The APSInt is the low value. 585 typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy; 586 CaseRangesTy CaseRanges; 587 588 DefaultStmt *TheDefaultStmt = 0; 589 590 bool CaseListIsErroneous = false; 591 592 for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue; 593 SC = SC->getNextSwitchCase()) { 594 595 if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) { 596 if (TheDefaultStmt) { 597 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined); 598 Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev); 599 600 // FIXME: Remove the default statement from the switch block so that 601 // we'll return a valid AST. This requires recursing down the AST and 602 // finding it, not something we are set up to do right now. For now, 603 // just lop the entire switch stmt out of the AST. 604 CaseListIsErroneous = true; 605 } 606 TheDefaultStmt = DS; 607 608 } else { 609 CaseStmt *CS = cast<CaseStmt>(SC); 610 611 // We already verified that the expression has a i-c-e value (C99 612 // 6.8.4.2p3) - get that value now. 613 Expr *Lo = CS->getLHS(); 614 615 if (Lo->isTypeDependent() || Lo->isValueDependent()) { 616 HasDependentValue = true; 617 break; 618 } 619 620 llvm::APSInt LoVal = Lo->EvaluateAsInt(Context); 621 622 // Convert the value to the same width/sign as the condition. 623 ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned, 624 CS->getLHS()->getLocStart(), 625 diag::warn_case_value_overflow); 626 627 // If the LHS is not the same type as the condition, insert an implicit 628 // cast. 629 ImpCastExprToType(Lo, CondType, CastExpr::CK_IntegralCast); 630 CS->setLHS(Lo); 631 632 // If this is a case range, remember it in CaseRanges, otherwise CaseVals. 633 if (CS->getRHS()) { 634 if (CS->getRHS()->isTypeDependent() || 635 CS->getRHS()->isValueDependent()) { 636 HasDependentValue = true; 637 break; 638 } 639 CaseRanges.push_back(std::make_pair(LoVal, CS)); 640 } else 641 CaseVals.push_back(std::make_pair(LoVal, CS)); 642 } 643 } 644 645 if (!HasDependentValue) { 646 // Sort all the scalar case values so we can easily detect duplicates. 647 std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals); 648 649 if (!CaseVals.empty()) { 650 for (unsigned i = 0, e = CaseVals.size()-1; i != e; ++i) { 651 if (CaseVals[i].first == CaseVals[i+1].first) { 652 // If we have a duplicate, report it. 653 Diag(CaseVals[i+1].second->getLHS()->getLocStart(), 654 diag::err_duplicate_case) << CaseVals[i].first.toString(10); 655 Diag(CaseVals[i].second->getLHS()->getLocStart(), 656 diag::note_duplicate_case_prev); 657 // FIXME: We really want to remove the bogus case stmt from the 658 // substmt, but we have no way to do this right now. 659 CaseListIsErroneous = true; 660 } 661 } 662 } 663 664 // Detect duplicate case ranges, which usually don't exist at all in 665 // the first place. 666 if (!CaseRanges.empty()) { 667 // Sort all the case ranges by their low value so we can easily detect 668 // overlaps between ranges. 669 std::stable_sort(CaseRanges.begin(), CaseRanges.end()); 670 671 // Scan the ranges, computing the high values and removing empty ranges. 672 std::vector<llvm::APSInt> HiVals; 673 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 674 CaseStmt *CR = CaseRanges[i].second; 675 Expr *Hi = CR->getRHS(); 676 llvm::APSInt HiVal = Hi->EvaluateAsInt(Context); 677 678 // Convert the value to the same width/sign as the condition. 679 ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned, 680 CR->getRHS()->getLocStart(), 681 diag::warn_case_value_overflow); 682 683 // If the LHS is not the same type as the condition, insert an implicit 684 // cast. 685 ImpCastExprToType(Hi, CondType, CastExpr::CK_IntegralCast); 686 CR->setRHS(Hi); 687 688 // If the low value is bigger than the high value, the case is empty. 689 if (CaseRanges[i].first > HiVal) { 690 Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range) 691 << SourceRange(CR->getLHS()->getLocStart(), 692 CR->getRHS()->getLocEnd()); 693 CaseRanges.erase(CaseRanges.begin()+i); 694 --i, --e; 695 continue; 696 } 697 HiVals.push_back(HiVal); 698 } 699 700 // Rescan the ranges, looking for overlap with singleton values and other 701 // ranges. Since the range list is sorted, we only need to compare case 702 // ranges with their neighbors. 703 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 704 llvm::APSInt &CRLo = CaseRanges[i].first; 705 llvm::APSInt &CRHi = HiVals[i]; 706 CaseStmt *CR = CaseRanges[i].second; 707 708 // Check to see whether the case range overlaps with any 709 // singleton cases. 710 CaseStmt *OverlapStmt = 0; 711 llvm::APSInt OverlapVal(32); 712 713 // Find the smallest value >= the lower bound. If I is in the 714 // case range, then we have overlap. 715 CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(), 716 CaseVals.end(), CRLo, 717 CaseCompareFunctor()); 718 if (I != CaseVals.end() && I->first < CRHi) { 719 OverlapVal = I->first; // Found overlap with scalar. 720 OverlapStmt = I->second; 721 } 722 723 // Find the smallest value bigger than the upper bound. 724 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor()); 725 if (I != CaseVals.begin() && (I-1)->first >= CRLo) { 726 OverlapVal = (I-1)->first; // Found overlap with scalar. 727 OverlapStmt = (I-1)->second; 728 } 729 730 // Check to see if this case stmt overlaps with the subsequent 731 // case range. 732 if (i && CRLo <= HiVals[i-1]) { 733 OverlapVal = HiVals[i-1]; // Found overlap with range. 734 OverlapStmt = CaseRanges[i-1].second; 735 } 736 737 if (OverlapStmt) { 738 // If we have a duplicate, report it. 739 Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case) 740 << OverlapVal.toString(10); 741 Diag(OverlapStmt->getLHS()->getLocStart(), 742 diag::note_duplicate_case_prev); 743 // FIXME: We really want to remove the bogus case stmt from the 744 // substmt, but we have no way to do this right now. 745 CaseListIsErroneous = true; 746 } 747 } 748 } 749 750 // Check to see if switch is over an Enum and handles all of its 751 // values 752 const EnumType* ET = CondTypeBeforePromotion->getAs<EnumType>(); 753 // If switch has default case, then ignore it. 754 if (!CaseListIsErroneous && !TheDefaultStmt && ET) { 755 const EnumDecl *ED = ET->getDecl(); 756 typedef llvm::SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64> EnumValsTy; 757 EnumValsTy EnumVals; 758 759 // Gather all enum values, set their type and sort them, allowing easier comparison 760 // with CaseVals. 761 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin(); EDI != ED->enumerator_end(); EDI++) { 762 llvm::APSInt Val = (*EDI)->getInitVal(); 763 if(Val.getBitWidth() < CondWidth) 764 Val.extend(CondWidth); 765 Val.setIsSigned(CondIsSigned); 766 EnumVals.push_back(std::make_pair(Val, (*EDI))); 767 } 768 std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals); 769 EnumValsTy::iterator EIend = std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals); 770 // See which case values aren't in enum 771 EnumValsTy::const_iterator EI = EnumVals.begin(); 772 for (CaseValsTy::const_iterator CI = CaseVals.begin(); CI != CaseVals.end(); CI++) { 773 while (EI != EIend && EI->first < CI->first) 774 EI++; 775 if (EI == EIend || EI->first > CI->first) 776 Diag(CI->second->getLHS()->getExprLoc(), diag::not_in_enum) << ED->getDeclName(); 777 } 778 // See which of case ranges aren't in enum 779 EI = EnumVals.begin(); 780 for (CaseRangesTy::const_iterator RI = CaseRanges.begin(); RI != CaseRanges.end() && EI != EIend; RI++) { 781 while (EI != EIend && EI->first < RI->first) 782 EI++; 783 784 if (EI == EIend || EI->first != RI->first) { 785 Diag(RI->second->getLHS()->getExprLoc(), diag::not_in_enum) << ED->getDeclName(); 786 } 787 788 llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context); 789 while (EI != EIend && EI->first < Hi) 790 EI++; 791 if (EI == EIend || EI->first != Hi) 792 Diag(RI->second->getRHS()->getExprLoc(), diag::not_in_enum) << ED->getDeclName(); 793 } 794 //Check which enum vals aren't in switch 795 CaseValsTy::const_iterator CI = CaseVals.begin(); 796 CaseRangesTy::const_iterator RI = CaseRanges.begin(); 797 EI = EnumVals.begin(); 798 for (; EI != EIend; EI++) { 799 //Drop unneeded case values 800 llvm::APSInt CIVal; 801 while (CI != CaseVals.end() && CI->first < EI->first) 802 CI++; 803 804 if (CI != CaseVals.end() && CI->first == EI->first) 805 continue; 806 807 //Drop unneeded case ranges 808 for (; RI != CaseRanges.end(); RI++) { 809 llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context); 810 if (EI->first <= Hi) 811 break; 812 } 813 814 if (RI == CaseRanges.end() || EI->first < RI->first) 815 Diag(CondExpr->getExprLoc(), diag::warn_missing_cases) << EI->second->getDeclName(); 816 } 817 } 818 } 819 820 // FIXME: If the case list was broken is some way, we don't have a good system 821 // to patch it up. Instead, just return the whole substmt as broken. 822 if (CaseListIsErroneous) 823 return StmtError(); 824 825 Switch.release(); 826 return Owned(SS); 827} 828 829Action::OwningStmtResult 830Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond, 831 DeclPtrTy CondVar, StmtArg Body) { 832 OwningExprResult CondResult(Cond.release()); 833 834 VarDecl *ConditionVar = 0; 835 if (CondVar.get()) { 836 ConditionVar = CondVar.getAs<VarDecl>(); 837 CondResult = CheckConditionVariable(ConditionVar); 838 if (CondResult.isInvalid()) 839 return StmtError(); 840 } 841 Expr *ConditionExpr = CondResult.takeAs<Expr>(); 842 if (!ConditionExpr) 843 return StmtError(); 844 845 if (CheckBooleanCondition(ConditionExpr, WhileLoc)) { 846 CondResult = ConditionExpr; 847 return StmtError(); 848 } 849 850 Stmt *bodyStmt = Body.takeAs<Stmt>(); 851 DiagnoseUnusedExprResult(bodyStmt); 852 853 CondResult.release(); 854 return Owned(new (Context) WhileStmt(ConditionVar, ConditionExpr, bodyStmt, 855 WhileLoc)); 856} 857 858Action::OwningStmtResult 859Sema::ActOnDoStmt(SourceLocation DoLoc, StmtArg Body, 860 SourceLocation WhileLoc, SourceLocation CondLParen, 861 ExprArg Cond, SourceLocation CondRParen) { 862 Expr *condExpr = Cond.takeAs<Expr>(); 863 assert(condExpr && "ActOnDoStmt(): missing expression"); 864 865 if (CheckBooleanCondition(condExpr, DoLoc)) { 866 Cond = condExpr; 867 return StmtError(); 868 } 869 870 Stmt *bodyStmt = Body.takeAs<Stmt>(); 871 DiagnoseUnusedExprResult(bodyStmt); 872 873 Cond.release(); 874 return Owned(new (Context) DoStmt(bodyStmt, condExpr, DoLoc, 875 WhileLoc, CondRParen)); 876} 877 878Action::OwningStmtResult 879Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, 880 StmtArg first, FullExprArg second, DeclPtrTy secondVar, 881 FullExprArg third, 882 SourceLocation RParenLoc, StmtArg body) { 883 Stmt *First = static_cast<Stmt*>(first.get()); 884 885 if (!getLangOptions().CPlusPlus) { 886 if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) { 887 // C99 6.8.5p3: The declaration part of a 'for' statement shall only 888 // declare identifiers for objects having storage class 'auto' or 889 // 'register'. 890 for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end(); 891 DI!=DE; ++DI) { 892 VarDecl *VD = dyn_cast<VarDecl>(*DI); 893 if (VD && VD->isBlockVarDecl() && !VD->hasLocalStorage()) 894 VD = 0; 895 if (VD == 0) 896 Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for); 897 // FIXME: mark decl erroneous! 898 } 899 } 900 } 901 902 OwningExprResult SecondResult(second.release()); 903 VarDecl *ConditionVar = 0; 904 if (secondVar.get()) { 905 ConditionVar = secondVar.getAs<VarDecl>(); 906 SecondResult = CheckConditionVariable(ConditionVar); 907 if (SecondResult.isInvalid()) 908 return StmtError(); 909 } 910 911 Expr *Second = SecondResult.takeAs<Expr>(); 912 if (Second && CheckBooleanCondition(Second, ForLoc)) { 913 SecondResult = Second; 914 return StmtError(); 915 } 916 917 Expr *Third = third.release().takeAs<Expr>(); 918 Stmt *Body = static_cast<Stmt*>(body.get()); 919 920 DiagnoseUnusedExprResult(First); 921 DiagnoseUnusedExprResult(Third); 922 DiagnoseUnusedExprResult(Body); 923 924 first.release(); 925 body.release(); 926 return Owned(new (Context) ForStmt(First, Second, ConditionVar, Third, Body, 927 ForLoc, LParenLoc, RParenLoc)); 928} 929 930Action::OwningStmtResult 931Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc, 932 SourceLocation LParenLoc, 933 StmtArg first, ExprArg second, 934 SourceLocation RParenLoc, StmtArg body) { 935 Stmt *First = static_cast<Stmt*>(first.get()); 936 Expr *Second = static_cast<Expr*>(second.get()); 937 Stmt *Body = static_cast<Stmt*>(body.get()); 938 if (First) { 939 QualType FirstType; 940 if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) { 941 if (!DS->isSingleDecl()) 942 return StmtError(Diag((*DS->decl_begin())->getLocation(), 943 diag::err_toomany_element_decls)); 944 945 Decl *D = DS->getSingleDecl(); 946 FirstType = cast<ValueDecl>(D)->getType(); 947 // C99 6.8.5p3: The declaration part of a 'for' statement shall only 948 // declare identifiers for objects having storage class 'auto' or 949 // 'register'. 950 VarDecl *VD = cast<VarDecl>(D); 951 if (VD->isBlockVarDecl() && !VD->hasLocalStorage()) 952 return StmtError(Diag(VD->getLocation(), 953 diag::err_non_variable_decl_in_for)); 954 } else { 955 if (cast<Expr>(First)->isLvalue(Context) != Expr::LV_Valid) 956 return StmtError(Diag(First->getLocStart(), 957 diag::err_selector_element_not_lvalue) 958 << First->getSourceRange()); 959 960 FirstType = static_cast<Expr*>(First)->getType(); 961 } 962 if (!FirstType->isObjCObjectPointerType() && 963 !FirstType->isBlockPointerType()) 964 Diag(ForLoc, diag::err_selector_element_type) 965 << FirstType << First->getSourceRange(); 966 } 967 if (Second) { 968 DefaultFunctionArrayLvalueConversion(Second); 969 QualType SecondType = Second->getType(); 970 if (!SecondType->isObjCObjectPointerType()) 971 Diag(ForLoc, diag::err_collection_expr_type) 972 << SecondType << Second->getSourceRange(); 973 } 974 first.release(); 975 second.release(); 976 body.release(); 977 return Owned(new (Context) ObjCForCollectionStmt(First, Second, Body, 978 ForLoc, RParenLoc)); 979} 980 981Action::OwningStmtResult 982Sema::ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, 983 IdentifierInfo *LabelII) { 984 // Look up the record for this label identifier. 985 LabelStmt *&LabelDecl = getLabelMap()[LabelII]; 986 987 // If we haven't seen this label yet, create a forward reference. 988 if (LabelDecl == 0) 989 LabelDecl = new (Context) LabelStmt(LabelLoc, LabelII, 0); 990 991 return Owned(new (Context) GotoStmt(LabelDecl, GotoLoc, LabelLoc)); 992} 993 994Action::OwningStmtResult 995Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc, 996 ExprArg DestExp) { 997 // Convert operand to void* 998 Expr* E = DestExp.takeAs<Expr>(); 999 if (!E->isTypeDependent()) { 1000 QualType ETy = E->getType(); 1001 QualType DestTy = Context.getPointerType(Context.VoidTy.withConst()); 1002 AssignConvertType ConvTy = 1003 CheckSingleAssignmentConstraints(DestTy, E); 1004 if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing)) 1005 return StmtError(); 1006 } 1007 return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E)); 1008} 1009 1010Action::OwningStmtResult 1011Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) { 1012 Scope *S = CurScope->getContinueParent(); 1013 if (!S) { 1014 // C99 6.8.6.2p1: A break shall appear only in or as a loop body. 1015 return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop)); 1016 } 1017 1018 return Owned(new (Context) ContinueStmt(ContinueLoc)); 1019} 1020 1021Action::OwningStmtResult 1022Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) { 1023 Scope *S = CurScope->getBreakParent(); 1024 if (!S) { 1025 // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body. 1026 return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch)); 1027 } 1028 1029 return Owned(new (Context) BreakStmt(BreakLoc)); 1030} 1031 1032/// ActOnBlockReturnStmt - Utility routine to figure out block's return type. 1033/// 1034Action::OwningStmtResult 1035Sema::ActOnBlockReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) { 1036 // If this is the first return we've seen in the block, infer the type of 1037 // the block from it. 1038 BlockScopeInfo *CurBlock = getCurBlock(); 1039 if (CurBlock->ReturnType.isNull()) { 1040 if (RetValExp) { 1041 // Don't call UsualUnaryConversions(), since we don't want to do 1042 // integer promotions here. 1043 DefaultFunctionArrayLvalueConversion(RetValExp); 1044 CurBlock->ReturnType = RetValExp->getType(); 1045 if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(RetValExp)) { 1046 // We have to remove a 'const' added to copied-in variable which was 1047 // part of the implementation spec. and not the actual qualifier for 1048 // the variable. 1049 if (CDRE->isConstQualAdded()) 1050 CurBlock->ReturnType.removeConst(); 1051 } 1052 } else 1053 CurBlock->ReturnType = Context.VoidTy; 1054 } 1055 QualType FnRetType = CurBlock->ReturnType; 1056 1057 if (CurBlock->TheDecl->hasAttr<NoReturnAttr>()) { 1058 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr) 1059 << getCurFunctionOrMethodDecl()->getDeclName(); 1060 return StmtError(); 1061 } 1062 1063 // Otherwise, verify that this result type matches the previous one. We are 1064 // pickier with blocks than for normal functions because we don't have GCC 1065 // compatibility to worry about here. 1066 if (CurBlock->ReturnType->isVoidType()) { 1067 if (RetValExp) { 1068 Diag(ReturnLoc, diag::err_return_block_has_expr); 1069 RetValExp->Destroy(Context); 1070 RetValExp = 0; 1071 } 1072 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp)); 1073 } 1074 1075 if (!RetValExp) 1076 return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr)); 1077 1078 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) { 1079 // we have a non-void block with an expression, continue checking 1080 1081 // C99 6.8.6.4p3(136): The return statement is not an assignment. The 1082 // overlap restriction of subclause 6.5.16.1 does not apply to the case of 1083 // function return. 1084 1085 // In C++ the return statement is handled via a copy initialization. 1086 // the C version of which boils down to CheckSingleAssignmentConstraints. 1087 OwningExprResult Res = PerformCopyInitialization( 1088 InitializedEntity::InitializeResult(ReturnLoc, 1089 FnRetType), 1090 SourceLocation(), 1091 Owned(RetValExp)); 1092 if (Res.isInvalid()) { 1093 // FIXME: Cleanup temporaries here, anyway? 1094 return StmtError(); 1095 } 1096 1097 RetValExp = Res.takeAs<Expr>(); 1098 if (RetValExp) 1099 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc); 1100 } 1101 1102 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp)); 1103} 1104 1105/// IsReturnCopyElidable - Whether returning @p RetExpr from a function that 1106/// returns a @p RetType fulfills the criteria for copy elision (C++0x 12.8p15). 1107static bool IsReturnCopyElidable(ASTContext &Ctx, QualType RetType, 1108 Expr *RetExpr) { 1109 QualType ExprType = RetExpr->getType(); 1110 // - in a return statement in a function with ... 1111 // ... a class return type ... 1112 if (!RetType->isRecordType()) 1113 return false; 1114 // ... the same cv-unqualified type as the function return type ... 1115 if (!Ctx.hasSameUnqualifiedType(RetType, ExprType)) 1116 return false; 1117 // ... the expression is the name of a non-volatile automatic object ... 1118 // We ignore parentheses here. 1119 // FIXME: Is this compliant? 1120 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(RetExpr->IgnoreParens()); 1121 if (!DR) 1122 return false; 1123 const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl()); 1124 if (!VD) 1125 return false; 1126 return VD->hasLocalStorage() && !VD->getType()->isReferenceType() 1127 && !VD->getType().isVolatileQualified(); 1128} 1129 1130Action::OwningStmtResult 1131Sema::ActOnReturnStmt(SourceLocation ReturnLoc, ExprArg rex) { 1132 Expr *RetValExp = rex.takeAs<Expr>(); 1133 if (getCurBlock()) 1134 return ActOnBlockReturnStmt(ReturnLoc, RetValExp); 1135 1136 QualType FnRetType; 1137 if (const FunctionDecl *FD = getCurFunctionDecl()) { 1138 FnRetType = FD->getResultType(); 1139 if (FD->hasAttr<NoReturnAttr>() || 1140 FD->getType()->getAs<FunctionType>()->getNoReturnAttr()) 1141 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr) 1142 << getCurFunctionOrMethodDecl()->getDeclName(); 1143 } else if (ObjCMethodDecl *MD = getCurMethodDecl()) 1144 FnRetType = MD->getResultType(); 1145 else // If we don't have a function/method context, bail. 1146 return StmtError(); 1147 1148 if (FnRetType->isVoidType()) { 1149 if (RetValExp && !RetValExp->isTypeDependent()) { 1150 // C99 6.8.6.4p1 (ext_ since GCC warns) 1151 unsigned D = diag::ext_return_has_expr; 1152 if (RetValExp->getType()->isVoidType()) 1153 D = diag::ext_return_has_void_expr; 1154 1155 // return (some void expression); is legal in C++. 1156 if (D != diag::ext_return_has_void_expr || 1157 !getLangOptions().CPlusPlus) { 1158 NamedDecl *CurDecl = getCurFunctionOrMethodDecl(); 1159 Diag(ReturnLoc, D) 1160 << CurDecl->getDeclName() << isa<ObjCMethodDecl>(CurDecl) 1161 << RetValExp->getSourceRange(); 1162 } 1163 1164 RetValExp = MaybeCreateCXXExprWithTemporaries(RetValExp); 1165 } 1166 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp)); 1167 } 1168 1169 if (!RetValExp && !FnRetType->isDependentType()) { 1170 unsigned DiagID = diag::warn_return_missing_expr; // C90 6.6.6.4p4 1171 // C99 6.8.6.4p1 (ext_ since GCC warns) 1172 if (getLangOptions().C99) DiagID = diag::ext_return_missing_expr; 1173 1174 if (FunctionDecl *FD = getCurFunctionDecl()) 1175 Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/; 1176 else 1177 Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/; 1178 return Owned(new (Context) ReturnStmt(ReturnLoc, (Expr*)0)); 1179 } 1180 1181 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) { 1182 // we have a non-void function with an expression, continue checking 1183 1184 // C99 6.8.6.4p3(136): The return statement is not an assignment. The 1185 // overlap restriction of subclause 6.5.16.1 does not apply to the case of 1186 // function return. 1187 1188 // C++0x 12.8p15: When certain criteria are met, an implementation is 1189 // allowed to omit the copy construction of a class object, [...] 1190 // - in a return statement in a function with a class return type, when 1191 // the expression is the name of a non-volatile automatic object with 1192 // the same cv-unqualified type as the function return type, the copy 1193 // operation can be omitted [...] 1194 // C++0x 12.8p16: When the criteria for elision of a copy operation are met 1195 // and the object to be copied is designated by an lvalue, overload 1196 // resolution to select the constructor for the copy is first performed 1197 // as if the object were designated by an rvalue. 1198 // Note that we only compute Elidable if we're in C++0x, since we don't 1199 // care otherwise. 1200 bool Elidable = getLangOptions().CPlusPlus0x ? 1201 IsReturnCopyElidable(Context, FnRetType, RetValExp) : 1202 false; 1203 // FIXME: Elidable 1204 (void)Elidable; 1205 1206 // In C++ the return statement is handled via a copy initialization. 1207 // the C version of which boils down to CheckSingleAssignmentConstraints. 1208 OwningExprResult Res = PerformCopyInitialization( 1209 InitializedEntity::InitializeResult(ReturnLoc, 1210 FnRetType), 1211 SourceLocation(), 1212 Owned(RetValExp)); 1213 if (Res.isInvalid()) { 1214 // FIXME: Cleanup temporaries here, anyway? 1215 return StmtError(); 1216 } 1217 1218 RetValExp = Res.takeAs<Expr>(); 1219 if (RetValExp) 1220 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc); 1221 } 1222 1223 if (RetValExp) 1224 RetValExp = MaybeCreateCXXExprWithTemporaries(RetValExp); 1225 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp)); 1226} 1227 1228/// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently 1229/// ignore "noop" casts in places where an lvalue is required by an inline asm. 1230/// We emulate this behavior when -fheinous-gnu-extensions is specified, but 1231/// provide a strong guidance to not use it. 1232/// 1233/// This method checks to see if the argument is an acceptable l-value and 1234/// returns false if it is a case we can handle. 1235static bool CheckAsmLValue(const Expr *E, Sema &S) { 1236 // Type dependent expressions will be checked during instantiation. 1237 if (E->isTypeDependent()) 1238 return false; 1239 1240 if (E->isLvalue(S.Context) == Expr::LV_Valid) 1241 return false; // Cool, this is an lvalue. 1242 1243 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we 1244 // are supposed to allow. 1245 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context); 1246 if (E != E2 && E2->isLvalue(S.Context) == Expr::LV_Valid) { 1247 if (!S.getLangOptions().HeinousExtensions) 1248 S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue) 1249 << E->getSourceRange(); 1250 else 1251 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue) 1252 << E->getSourceRange(); 1253 // Accept, even if we emitted an error diagnostic. 1254 return false; 1255 } 1256 1257 // None of the above, just randomly invalid non-lvalue. 1258 return true; 1259} 1260 1261 1262Sema::OwningStmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, 1263 bool IsSimple, 1264 bool IsVolatile, 1265 unsigned NumOutputs, 1266 unsigned NumInputs, 1267 IdentifierInfo **Names, 1268 MultiExprArg constraints, 1269 MultiExprArg exprs, 1270 ExprArg asmString, 1271 MultiExprArg clobbers, 1272 SourceLocation RParenLoc, 1273 bool MSAsm) { 1274 unsigned NumClobbers = clobbers.size(); 1275 StringLiteral **Constraints = 1276 reinterpret_cast<StringLiteral**>(constraints.get()); 1277 Expr **Exprs = reinterpret_cast<Expr **>(exprs.get()); 1278 StringLiteral *AsmString = cast<StringLiteral>((Expr *)asmString.get()); 1279 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get()); 1280 1281 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos; 1282 1283 // The parser verifies that there is a string literal here. 1284 if (AsmString->isWide()) 1285 return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character) 1286 << AsmString->getSourceRange()); 1287 1288 for (unsigned i = 0; i != NumOutputs; i++) { 1289 StringLiteral *Literal = Constraints[i]; 1290 if (Literal->isWide()) 1291 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 1292 << Literal->getSourceRange()); 1293 1294 llvm::StringRef OutputName; 1295 if (Names[i]) 1296 OutputName = Names[i]->getName(); 1297 1298 TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName); 1299 if (!Context.Target.validateOutputConstraint(Info)) 1300 return StmtError(Diag(Literal->getLocStart(), 1301 diag::err_asm_invalid_output_constraint) 1302 << Info.getConstraintStr()); 1303 1304 // Check that the output exprs are valid lvalues. 1305 Expr *OutputExpr = Exprs[i]; 1306 if (CheckAsmLValue(OutputExpr, *this)) { 1307 return StmtError(Diag(OutputExpr->getLocStart(), 1308 diag::err_asm_invalid_lvalue_in_output) 1309 << OutputExpr->getSourceRange()); 1310 } 1311 1312 OutputConstraintInfos.push_back(Info); 1313 } 1314 1315 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos; 1316 1317 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) { 1318 StringLiteral *Literal = Constraints[i]; 1319 if (Literal->isWide()) 1320 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 1321 << Literal->getSourceRange()); 1322 1323 llvm::StringRef InputName; 1324 if (Names[i]) 1325 InputName = Names[i]->getName(); 1326 1327 TargetInfo::ConstraintInfo Info(Literal->getString(), InputName); 1328 if (!Context.Target.validateInputConstraint(OutputConstraintInfos.data(), 1329 NumOutputs, Info)) { 1330 return StmtError(Diag(Literal->getLocStart(), 1331 diag::err_asm_invalid_input_constraint) 1332 << Info.getConstraintStr()); 1333 } 1334 1335 Expr *InputExpr = Exprs[i]; 1336 1337 // Only allow void types for memory constraints. 1338 if (Info.allowsMemory() && !Info.allowsRegister()) { 1339 if (CheckAsmLValue(InputExpr, *this)) 1340 return StmtError(Diag(InputExpr->getLocStart(), 1341 diag::err_asm_invalid_lvalue_in_input) 1342 << Info.getConstraintStr() 1343 << InputExpr->getSourceRange()); 1344 } 1345 1346 if (Info.allowsRegister()) { 1347 if (InputExpr->getType()->isVoidType()) { 1348 return StmtError(Diag(InputExpr->getLocStart(), 1349 diag::err_asm_invalid_type_in_input) 1350 << InputExpr->getType() << Info.getConstraintStr() 1351 << InputExpr->getSourceRange()); 1352 } 1353 } 1354 1355 DefaultFunctionArrayLvalueConversion(Exprs[i]); 1356 1357 InputConstraintInfos.push_back(Info); 1358 } 1359 1360 // Check that the clobbers are valid. 1361 for (unsigned i = 0; i != NumClobbers; i++) { 1362 StringLiteral *Literal = Clobbers[i]; 1363 if (Literal->isWide()) 1364 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character) 1365 << Literal->getSourceRange()); 1366 1367 llvm::StringRef Clobber = Literal->getString(); 1368 1369 if (!Context.Target.isValidGCCRegisterName(Clobber)) 1370 return StmtError(Diag(Literal->getLocStart(), 1371 diag::err_asm_unknown_register_name) << Clobber); 1372 } 1373 1374 constraints.release(); 1375 exprs.release(); 1376 asmString.release(); 1377 clobbers.release(); 1378 AsmStmt *NS = 1379 new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm, 1380 NumOutputs, NumInputs, Names, Constraints, Exprs, 1381 AsmString, NumClobbers, Clobbers, RParenLoc); 1382 // Validate the asm string, ensuring it makes sense given the operands we 1383 // have. 1384 llvm::SmallVector<AsmStmt::AsmStringPiece, 8> Pieces; 1385 unsigned DiagOffs; 1386 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) { 1387 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID) 1388 << AsmString->getSourceRange(); 1389 DeleteStmt(NS); 1390 return StmtError(); 1391 } 1392 1393 // Validate tied input operands for type mismatches. 1394 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) { 1395 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i]; 1396 1397 // If this is a tied constraint, verify that the output and input have 1398 // either exactly the same type, or that they are int/ptr operands with the 1399 // same size (int/long, int*/long, are ok etc). 1400 if (!Info.hasTiedOperand()) continue; 1401 1402 unsigned TiedTo = Info.getTiedOperand(); 1403 Expr *OutputExpr = Exprs[TiedTo]; 1404 Expr *InputExpr = Exprs[i+NumOutputs]; 1405 QualType InTy = InputExpr->getType(); 1406 QualType OutTy = OutputExpr->getType(); 1407 if (Context.hasSameType(InTy, OutTy)) 1408 continue; // All types can be tied to themselves. 1409 1410 // Int/ptr operands have some special cases that we allow. 1411 if ((OutTy->isIntegerType() || OutTy->isPointerType()) && 1412 (InTy->isIntegerType() || InTy->isPointerType())) { 1413 1414 // They are ok if they are the same size. Tying void* to int is ok if 1415 // they are the same size, for example. This also allows tying void* to 1416 // int*. 1417 uint64_t OutSize = Context.getTypeSize(OutTy); 1418 uint64_t InSize = Context.getTypeSize(InTy); 1419 if (OutSize == InSize) 1420 continue; 1421 1422 // If the smaller input/output operand is not mentioned in the asm string, 1423 // then we can promote it and the asm string won't notice. Check this 1424 // case now. 1425 bool SmallerValueMentioned = false; 1426 for (unsigned p = 0, e = Pieces.size(); p != e; ++p) { 1427 AsmStmt::AsmStringPiece &Piece = Pieces[p]; 1428 if (!Piece.isOperand()) continue; 1429 1430 // If this is a reference to the input and if the input was the smaller 1431 // one, then we have to reject this asm. 1432 if (Piece.getOperandNo() == i+NumOutputs) { 1433 if (InSize < OutSize) { 1434 SmallerValueMentioned = true; 1435 break; 1436 } 1437 } 1438 1439 // If this is a reference to the input and if the input was the smaller 1440 // one, then we have to reject this asm. 1441 if (Piece.getOperandNo() == TiedTo) { 1442 if (InSize > OutSize) { 1443 SmallerValueMentioned = true; 1444 break; 1445 } 1446 } 1447 } 1448 1449 // If the smaller value wasn't mentioned in the asm string, and if the 1450 // output was a register, just extend the shorter one to the size of the 1451 // larger one. 1452 if (!SmallerValueMentioned && 1453 OutputConstraintInfos[TiedTo].allowsRegister()) 1454 continue; 1455 } 1456 1457 Diag(InputExpr->getLocStart(), 1458 diag::err_asm_tying_incompatible_types) 1459 << InTy << OutTy << OutputExpr->getSourceRange() 1460 << InputExpr->getSourceRange(); 1461 DeleteStmt(NS); 1462 return StmtError(); 1463 } 1464 1465 return Owned(NS); 1466} 1467 1468Action::OwningStmtResult 1469Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc, 1470 SourceLocation RParen, DeclPtrTy Parm, 1471 StmtArg Body, StmtArg catchList) { 1472 Stmt *CatchList = catchList.takeAs<Stmt>(); 1473 ParmVarDecl *PVD = cast_or_null<ParmVarDecl>(Parm.getAs<Decl>()); 1474 1475 // PVD == 0 implies @catch(...). 1476 if (PVD) { 1477 // If we already know the decl is invalid, reject it. 1478 if (PVD->isInvalidDecl()) 1479 return StmtError(); 1480 1481 if (!PVD->getType()->isObjCObjectPointerType()) 1482 return StmtError(Diag(PVD->getLocation(), 1483 diag::err_catch_param_not_objc_type)); 1484 if (PVD->getType()->isObjCQualifiedIdType()) 1485 return StmtError(Diag(PVD->getLocation(), 1486 diag::err_illegal_qualifiers_on_catch_parm)); 1487 } 1488 1489 ObjCAtCatchStmt *CS = new (Context) ObjCAtCatchStmt(AtLoc, RParen, 1490 PVD, Body.takeAs<Stmt>(), CatchList); 1491 return Owned(CatchList ? CatchList : CS); 1492} 1493 1494Action::OwningStmtResult 1495Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, StmtArg Body) { 1496 return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, 1497 static_cast<Stmt*>(Body.release()))); 1498} 1499 1500Action::OwningStmtResult 1501Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, 1502 StmtArg Try, StmtArg Catch, StmtArg Finally) { 1503 FunctionNeedsScopeChecking() = true; 1504 return Owned(new (Context) ObjCAtTryStmt(AtLoc, Try.takeAs<Stmt>(), 1505 Catch.takeAs<Stmt>(), 1506 Finally.takeAs<Stmt>())); 1507} 1508 1509Action::OwningStmtResult 1510Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, ExprArg expr,Scope *CurScope) { 1511 Expr *ThrowExpr = expr.takeAs<Expr>(); 1512 if (!ThrowExpr) { 1513 // @throw without an expression designates a rethrow (which much occur 1514 // in the context of an @catch clause). 1515 Scope *AtCatchParent = CurScope; 1516 while (AtCatchParent && !AtCatchParent->isAtCatchScope()) 1517 AtCatchParent = AtCatchParent->getParent(); 1518 if (!AtCatchParent) 1519 return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch)); 1520 } else { 1521 QualType ThrowType = ThrowExpr->getType(); 1522 // Make sure the expression type is an ObjC pointer or "void *". 1523 if (!ThrowType->isObjCObjectPointerType()) { 1524 const PointerType *PT = ThrowType->getAs<PointerType>(); 1525 if (!PT || !PT->getPointeeType()->isVoidType()) 1526 return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object) 1527 << ThrowExpr->getType() << ThrowExpr->getSourceRange()); 1528 } 1529 } 1530 return Owned(new (Context) ObjCAtThrowStmt(AtLoc, ThrowExpr)); 1531} 1532 1533Action::OwningStmtResult 1534Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, ExprArg SynchExpr, 1535 StmtArg SynchBody) { 1536 FunctionNeedsScopeChecking() = true; 1537 1538 // Make sure the expression type is an ObjC pointer or "void *". 1539 Expr *SyncExpr = static_cast<Expr*>(SynchExpr.get()); 1540 if (!SyncExpr->getType()->isObjCObjectPointerType()) { 1541 const PointerType *PT = SyncExpr->getType()->getAs<PointerType>(); 1542 if (!PT || !PT->getPointeeType()->isVoidType()) 1543 return StmtError(Diag(AtLoc, diag::error_objc_synchronized_expects_object) 1544 << SyncExpr->getType() << SyncExpr->getSourceRange()); 1545 } 1546 1547 return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, 1548 SynchExpr.takeAs<Stmt>(), 1549 SynchBody.takeAs<Stmt>())); 1550} 1551 1552/// ActOnCXXCatchBlock - Takes an exception declaration and a handler block 1553/// and creates a proper catch handler from them. 1554Action::OwningStmtResult 1555Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, DeclPtrTy ExDecl, 1556 StmtArg HandlerBlock) { 1557 // There's nothing to test that ActOnExceptionDecl didn't already test. 1558 return Owned(new (Context) CXXCatchStmt(CatchLoc, 1559 cast_or_null<VarDecl>(ExDecl.getAs<Decl>()), 1560 HandlerBlock.takeAs<Stmt>())); 1561} 1562 1563class TypeWithHandler { 1564 QualType t; 1565 CXXCatchStmt *stmt; 1566public: 1567 TypeWithHandler(const QualType &type, CXXCatchStmt *statement) 1568 : t(type), stmt(statement) {} 1569 1570 // An arbitrary order is fine as long as it places identical 1571 // types next to each other. 1572 bool operator<(const TypeWithHandler &y) const { 1573 if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr()) 1574 return true; 1575 if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr()) 1576 return false; 1577 else 1578 return getTypeSpecStartLoc() < y.getTypeSpecStartLoc(); 1579 } 1580 1581 bool operator==(const TypeWithHandler& other) const { 1582 return t == other.t; 1583 } 1584 1585 QualType getQualType() const { return t; } 1586 CXXCatchStmt *getCatchStmt() const { return stmt; } 1587 SourceLocation getTypeSpecStartLoc() const { 1588 return stmt->getExceptionDecl()->getTypeSpecStartLoc(); 1589 } 1590}; 1591 1592/// ActOnCXXTryBlock - Takes a try compound-statement and a number of 1593/// handlers and creates a try statement from them. 1594Action::OwningStmtResult 1595Sema::ActOnCXXTryBlock(SourceLocation TryLoc, StmtArg TryBlock, 1596 MultiStmtArg RawHandlers) { 1597 unsigned NumHandlers = RawHandlers.size(); 1598 assert(NumHandlers > 0 && 1599 "The parser shouldn't call this if there are no handlers."); 1600 Stmt **Handlers = reinterpret_cast<Stmt**>(RawHandlers.get()); 1601 1602 llvm::SmallVector<TypeWithHandler, 8> TypesWithHandlers; 1603 1604 for (unsigned i = 0; i < NumHandlers; ++i) { 1605 CXXCatchStmt *Handler = llvm::cast<CXXCatchStmt>(Handlers[i]); 1606 if (!Handler->getExceptionDecl()) { 1607 if (i < NumHandlers - 1) 1608 return StmtError(Diag(Handler->getLocStart(), 1609 diag::err_early_catch_all)); 1610 1611 continue; 1612 } 1613 1614 const QualType CaughtType = Handler->getCaughtType(); 1615 const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType); 1616 TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler)); 1617 } 1618 1619 // Detect handlers for the same type as an earlier one. 1620 if (NumHandlers > 1) { 1621 llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end()); 1622 1623 TypeWithHandler prev = TypesWithHandlers[0]; 1624 for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) { 1625 TypeWithHandler curr = TypesWithHandlers[i]; 1626 1627 if (curr == prev) { 1628 Diag(curr.getTypeSpecStartLoc(), 1629 diag::warn_exception_caught_by_earlier_handler) 1630 << curr.getCatchStmt()->getCaughtType().getAsString(); 1631 Diag(prev.getTypeSpecStartLoc(), 1632 diag::note_previous_exception_handler) 1633 << prev.getCatchStmt()->getCaughtType().getAsString(); 1634 } 1635 1636 prev = curr; 1637 } 1638 } 1639 1640 // FIXME: We should detect handlers that cannot catch anything because an 1641 // earlier handler catches a superclass. Need to find a method that is not 1642 // quadratic for this. 1643 // Neither of these are explicitly forbidden, but every compiler detects them 1644 // and warns. 1645 1646 FunctionNeedsScopeChecking() = true; 1647 RawHandlers.release(); 1648 return Owned(CXXTryStmt::Create(Context, TryLoc, 1649 static_cast<Stmt*>(TryBlock.release()), 1650 Handlers, NumHandlers)); 1651} 1652