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