SemaStmt.cpp revision 6bc52112dbc54551bd8e215d95bba4791b2275f7
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/ASTContext.h" 16#include "clang/AST/Expr.h" 17#include "clang/AST/Stmt.h" 18#include "clang/Parse/Scope.h" 19#include "clang/Basic/TargetInfo.h" 20#include "clang/Basic/Diagnostic.h" 21#include "clang/Basic/LangOptions.h" 22#include "llvm/ADT/SmallString.h" 23using namespace clang; 24 25Sema::StmtResult Sema::ActOnExprStmt(ExprTy *expr) { 26 Expr *E = static_cast<Expr*>(expr); 27 assert(E && "ActOnExprStmt(): missing expression"); 28 return E; 29} 30 31 32Sema::StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc) { 33 return new NullStmt(SemiLoc); 34} 35 36Sema::StmtResult Sema::ActOnDeclStmt(DeclTy *decl, SourceLocation StartLoc, 37 SourceLocation EndLoc) { 38 if (decl == 0) 39 return true; 40 41 ScopedDecl *SD = cast<ScopedDecl>(static_cast<Decl *>(decl)); 42 return new DeclStmt(SD, StartLoc, EndLoc); 43} 44 45Action::StmtResult 46Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R, 47 StmtTy **elts, unsigned NumElts, bool isStmtExpr) { 48 Stmt **Elts = reinterpret_cast<Stmt**>(elts); 49 // If we're in C89 mode, check that we don't have any decls after stmts. If 50 // so, emit an extension diagnostic. 51 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) { 52 // Note that __extension__ can be around a decl. 53 unsigned i = 0; 54 // Skip over all declarations. 55 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i) 56 /*empty*/; 57 58 // We found the end of the list or a statement. Scan for another declstmt. 59 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i) 60 /*empty*/; 61 62 if (i != NumElts) { 63 ScopedDecl *D = cast<DeclStmt>(Elts[i])->getDecl(); 64 Diag(D->getLocation(), diag::ext_mixed_decls_code); 65 } 66 } 67 // Warn about unused expressions in statements. 68 for (unsigned i = 0; i != NumElts; ++i) { 69 Expr *E = dyn_cast<Expr>(Elts[i]); 70 if (!E) continue; 71 72 // Warn about expressions with unused results. 73 if (E->hasLocalSideEffect() || E->getType()->isVoidType()) 74 continue; 75 76 // The last expr in a stmt expr really is used. 77 if (isStmtExpr && i == NumElts-1) 78 continue; 79 80 /// DiagnoseDeadExpr - This expression is side-effect free and evaluated in 81 /// a context where the result is unused. Emit a diagnostic to warn about 82 /// this. 83 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) 84 Diag(BO->getOperatorLoc(), diag::warn_unused_expr, 85 BO->getLHS()->getSourceRange(), BO->getRHS()->getSourceRange()); 86 else if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) 87 Diag(UO->getOperatorLoc(), diag::warn_unused_expr, 88 UO->getSubExpr()->getSourceRange()); 89 else 90 Diag(E->getExprLoc(), diag::warn_unused_expr, E->getSourceRange()); 91 } 92 93 return new CompoundStmt(Elts, NumElts, L, R); 94} 95 96Action::StmtResult 97Sema::ActOnCaseStmt(SourceLocation CaseLoc, ExprTy *lhsval, 98 SourceLocation DotDotDotLoc, ExprTy *rhsval, 99 SourceLocation ColonLoc, StmtTy *subStmt) { 100 Stmt *SubStmt = static_cast<Stmt*>(subStmt); 101 Expr *LHSVal = ((Expr *)lhsval), *RHSVal = ((Expr *)rhsval); 102 assert((LHSVal != 0) && "missing expression in case statement"); 103 104 SourceLocation ExpLoc; 105 // C99 6.8.4.2p3: The expression shall be an integer constant. 106 if (!LHSVal->isIntegerConstantExpr(Context, &ExpLoc)) { 107 Diag(ExpLoc, diag::err_case_label_not_integer_constant_expr, 108 LHSVal->getSourceRange()); 109 return SubStmt; 110 } 111 112 // GCC extension: The expression shall be an integer constant. 113 if (RHSVal && !RHSVal->isIntegerConstantExpr(Context, &ExpLoc)) { 114 Diag(ExpLoc, diag::err_case_label_not_integer_constant_expr, 115 RHSVal->getSourceRange()); 116 RHSVal = 0; // Recover by just forgetting about it. 117 } 118 119 if (SwitchStack.empty()) { 120 Diag(CaseLoc, diag::err_case_not_in_switch); 121 return SubStmt; 122 } 123 124 CaseStmt *CS = new CaseStmt(LHSVal, RHSVal, SubStmt, CaseLoc); 125 SwitchStack.back()->addSwitchCase(CS); 126 return CS; 127} 128 129Action::StmtResult 130Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, 131 StmtTy *subStmt, Scope *CurScope) { 132 Stmt *SubStmt = static_cast<Stmt*>(subStmt); 133 134 if (SwitchStack.empty()) { 135 Diag(DefaultLoc, diag::err_default_not_in_switch); 136 return SubStmt; 137 } 138 139 DefaultStmt *DS = new DefaultStmt(DefaultLoc, SubStmt); 140 SwitchStack.back()->addSwitchCase(DS); 141 142 return DS; 143} 144 145Action::StmtResult 146Sema::ActOnLabelStmt(SourceLocation IdentLoc, IdentifierInfo *II, 147 SourceLocation ColonLoc, StmtTy *subStmt) { 148 Stmt *SubStmt = static_cast<Stmt*>(subStmt); 149 // Look up the record for this label identifier. 150 LabelStmt *&LabelDecl = LabelMap[II]; 151 152 // If not forward referenced or defined already, just create a new LabelStmt. 153 if (LabelDecl == 0) 154 return LabelDecl = new LabelStmt(IdentLoc, II, SubStmt); 155 156 assert(LabelDecl->getID() == II && "Label mismatch!"); 157 158 // Otherwise, this label was either forward reference or multiply defined. If 159 // multiply defined, reject it now. 160 if (LabelDecl->getSubStmt()) { 161 Diag(IdentLoc, diag::err_redefinition_of_label, LabelDecl->getName()); 162 Diag(LabelDecl->getIdentLoc(), diag::err_previous_definition); 163 return SubStmt; 164 } 165 166 // Otherwise, this label was forward declared, and we just found its real 167 // definition. Fill in the forward definition and return it. 168 LabelDecl->setIdentLoc(IdentLoc); 169 LabelDecl->setSubStmt(SubStmt); 170 return LabelDecl; 171} 172 173Action::StmtResult 174Sema::ActOnIfStmt(SourceLocation IfLoc, ExprTy *CondVal, 175 StmtTy *ThenVal, SourceLocation ElseLoc, 176 StmtTy *ElseVal) { 177 Expr *condExpr = (Expr *)CondVal; 178 Stmt *thenStmt = (Stmt *)ThenVal; 179 180 assert(condExpr && "ActOnIfStmt(): missing expression"); 181 182 DefaultFunctionArrayConversion(condExpr); 183 QualType condType = condExpr->getType(); 184 185 if (!condType->isScalarType()) // C99 6.8.4.1p1 186 return Diag(IfLoc, diag::err_typecheck_statement_requires_scalar, 187 condType.getAsString(), condExpr->getSourceRange()); 188 189 // Warn if the if block has a null body without an else value. 190 // this helps prevent bugs due to typos, such as 191 // if (condition); 192 // do_stuff(); 193 if (!ElseVal) { 194 if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt)) 195 Diag(stmt->getSemiLoc(), diag::warn_empty_if_body); 196 } 197 198 return new IfStmt(IfLoc, condExpr, thenStmt, (Stmt*)ElseVal); 199} 200 201Action::StmtResult 202Sema::ActOnStartOfSwitchStmt(ExprTy *cond) { 203 Expr *Cond = static_cast<Expr*>(cond); 204 205 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr. 206 UsualUnaryConversions(Cond); 207 208 SwitchStmt *SS = new SwitchStmt(Cond); 209 SwitchStack.push_back(SS); 210 return SS; 211} 212 213/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have 214/// the specified width and sign. If an overflow occurs, detect it and emit 215/// the specified diagnostic. 216void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val, 217 unsigned NewWidth, bool NewSign, 218 SourceLocation Loc, 219 unsigned DiagID) { 220 // Perform a conversion to the promoted condition type if needed. 221 if (NewWidth > Val.getBitWidth()) { 222 // If this is an extension, just do it. 223 llvm::APSInt OldVal(Val); 224 Val.extend(NewWidth); 225 226 // If the input was signed and negative and the output is unsigned, 227 // warn. 228 if (!NewSign && OldVal.isSigned() && OldVal.isNegative()) 229 Diag(Loc, DiagID, OldVal.toString(), Val.toString()); 230 231 Val.setIsSigned(NewSign); 232 } else if (NewWidth < Val.getBitWidth()) { 233 // If this is a truncation, check for overflow. 234 llvm::APSInt ConvVal(Val); 235 ConvVal.trunc(NewWidth); 236 ConvVal.setIsSigned(NewSign); 237 ConvVal.extend(Val.getBitWidth()); 238 ConvVal.setIsSigned(Val.isSigned()); 239 if (ConvVal != Val) 240 Diag(Loc, DiagID, Val.toString(), ConvVal.toString()); 241 242 // Regardless of whether a diagnostic was emitted, really do the 243 // truncation. 244 Val.trunc(NewWidth); 245 Val.setIsSigned(NewSign); 246 } else if (NewSign != Val.isSigned()) { 247 // Convert the sign to match the sign of the condition. This can cause 248 // overflow as well: unsigned(INTMIN) 249 llvm::APSInt OldVal(Val); 250 Val.setIsSigned(NewSign); 251 252 if (Val.isNegative()) // Sign bit changes meaning. 253 Diag(Loc, DiagID, OldVal.toString(), Val.toString()); 254 } 255} 256 257namespace { 258 struct CaseCompareFunctor { 259 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 260 const llvm::APSInt &RHS) { 261 return LHS.first < RHS; 262 } 263 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 264 const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 265 return LHS.first < RHS.first; 266 } 267 bool operator()(const llvm::APSInt &LHS, 268 const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 269 return LHS < RHS.first; 270 } 271 }; 272} 273 274/// CmpCaseVals - Comparison predicate for sorting case values. 275/// 276static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs, 277 const std::pair<llvm::APSInt, CaseStmt*>& rhs) { 278 if (lhs.first < rhs.first) 279 return true; 280 281 if (lhs.first == rhs.first && 282 lhs.second->getCaseLoc().getRawEncoding() 283 < rhs.second->getCaseLoc().getRawEncoding()) 284 return true; 285 return false; 286} 287 288Action::StmtResult 289Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, StmtTy *Switch, 290 ExprTy *Body) { 291 Stmt *BodyStmt = (Stmt*)Body; 292 293 SwitchStmt *SS = SwitchStack.back(); 294 assert(SS == (SwitchStmt*)Switch && "switch stack missing push/pop!"); 295 296 SS->setBody(BodyStmt, SwitchLoc); 297 SwitchStack.pop_back(); 298 299 Expr *CondExpr = SS->getCond(); 300 QualType CondType = CondExpr->getType(); 301 302 if (!CondType->isIntegerType()) { // C99 6.8.4.2p1 303 Diag(SwitchLoc, diag::err_typecheck_statement_requires_integer, 304 CondType.getAsString(), CondExpr->getSourceRange()); 305 return true; 306 } 307 308 // Get the bitwidth of the switched-on value before promotions. We must 309 // convert the integer case values to this width before comparison. 310 unsigned CondWidth = static_cast<unsigned>(Context.getTypeSize(CondType)); 311 bool CondIsSigned = CondType->isSignedIntegerType(); 312 313 // Accumulate all of the case values in a vector so that we can sort them 314 // and detect duplicates. This vector contains the APInt for the case after 315 // it has been converted to the condition type. 316 typedef llvm::SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy; 317 CaseValsTy CaseVals; 318 319 // Keep track of any GNU case ranges we see. The APSInt is the low value. 320 std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRanges; 321 322 DefaultStmt *TheDefaultStmt = 0; 323 324 bool CaseListIsErroneous = false; 325 326 for (SwitchCase *SC = SS->getSwitchCaseList(); SC; 327 SC = SC->getNextSwitchCase()) { 328 329 if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) { 330 if (TheDefaultStmt) { 331 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined); 332 Diag(TheDefaultStmt->getDefaultLoc(), diag::err_first_label); 333 334 // FIXME: Remove the default statement from the switch block so that 335 // we'll return a valid AST. This requires recursing down the 336 // AST and finding it, not something we are set up to do right now. For 337 // now, just lop the entire switch stmt out of the AST. 338 CaseListIsErroneous = true; 339 } 340 TheDefaultStmt = DS; 341 342 } else { 343 CaseStmt *CS = cast<CaseStmt>(SC); 344 345 // We already verified that the expression has a i-c-e value (C99 346 // 6.8.4.2p3) - get that value now. 347 llvm::APSInt LoVal(32); 348 Expr *Lo = CS->getLHS(); 349 Lo->isIntegerConstantExpr(LoVal, Context); 350 351 // Convert the value to the same width/sign as the condition. 352 ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned, 353 CS->getLHS()->getLocStart(), 354 diag::warn_case_value_overflow); 355 356 // If the LHS is not the same type as the condition, insert an implicit 357 // cast. 358 ImpCastExprToType(Lo, CondType); 359 CS->setLHS(Lo); 360 361 // If this is a case range, remember it in CaseRanges, otherwise CaseVals. 362 if (CS->getRHS()) 363 CaseRanges.push_back(std::make_pair(LoVal, CS)); 364 else 365 CaseVals.push_back(std::make_pair(LoVal, CS)); 366 } 367 } 368 369 // Sort all the scalar case values so we can easily detect duplicates. 370 std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals); 371 372 if (!CaseVals.empty()) { 373 for (unsigned i = 0, e = CaseVals.size()-1; i != e; ++i) { 374 if (CaseVals[i].first == CaseVals[i+1].first) { 375 // If we have a duplicate, report it. 376 Diag(CaseVals[i+1].second->getLHS()->getLocStart(), 377 diag::err_duplicate_case, CaseVals[i].first.toString()); 378 Diag(CaseVals[i].second->getLHS()->getLocStart(), 379 diag::err_duplicate_case_prev); 380 // FIXME: We really want to remove the bogus case stmt from the substmt, 381 // but we have no way to do this right now. 382 CaseListIsErroneous = true; 383 } 384 } 385 } 386 387 // Detect duplicate case ranges, which usually don't exist at all in the first 388 // place. 389 if (!CaseRanges.empty()) { 390 // Sort all the case ranges by their low value so we can easily detect 391 // overlaps between ranges. 392 std::stable_sort(CaseRanges.begin(), CaseRanges.end()); 393 394 // Scan the ranges, computing the high values and removing empty ranges. 395 std::vector<llvm::APSInt> HiVals; 396 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 397 CaseStmt *CR = CaseRanges[i].second; 398 llvm::APSInt HiVal(32); 399 Expr *Hi = CR->getRHS(); 400 Hi->isIntegerConstantExpr(HiVal, Context); 401 402 // Convert the value to the same width/sign as the condition. 403 ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned, 404 CR->getRHS()->getLocStart(), 405 diag::warn_case_value_overflow); 406 407 // If the LHS is not the same type as the condition, insert an implicit 408 // cast. 409 ImpCastExprToType(Hi, CondType); 410 CR->setRHS(Hi); 411 412 // If the low value is bigger than the high value, the case is empty. 413 if (CaseRanges[i].first > HiVal) { 414 Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range, 415 SourceRange(CR->getLHS()->getLocStart(), 416 CR->getRHS()->getLocEnd())); 417 CaseRanges.erase(CaseRanges.begin()+i); 418 --i, --e; 419 continue; 420 } 421 HiVals.push_back(HiVal); 422 } 423 424 // Rescan the ranges, looking for overlap with singleton values and other 425 // ranges. Since the range list is sorted, we only need to compare case 426 // ranges with their neighbors. 427 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 428 llvm::APSInt &CRLo = CaseRanges[i].first; 429 llvm::APSInt &CRHi = HiVals[i]; 430 CaseStmt *CR = CaseRanges[i].second; 431 432 // Check to see whether the case range overlaps with any singleton cases. 433 CaseStmt *OverlapStmt = 0; 434 llvm::APSInt OverlapVal(32); 435 436 // Find the smallest value >= the lower bound. If I is in the case range, 437 // then we have overlap. 438 CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(), 439 CaseVals.end(), CRLo, 440 CaseCompareFunctor()); 441 if (I != CaseVals.end() && I->first < CRHi) { 442 OverlapVal = I->first; // Found overlap with scalar. 443 OverlapStmt = I->second; 444 } 445 446 // Find the smallest value bigger than the upper bound. 447 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor()); 448 if (I != CaseVals.begin() && (I-1)->first >= CRLo) { 449 OverlapVal = (I-1)->first; // Found overlap with scalar. 450 OverlapStmt = (I-1)->second; 451 } 452 453 // Check to see if this case stmt overlaps with the subsequent case range. 454 if (i && CRLo <= HiVals[i-1]) { 455 OverlapVal = HiVals[i-1]; // Found overlap with range. 456 OverlapStmt = CaseRanges[i-1].second; 457 } 458 459 if (OverlapStmt) { 460 // If we have a duplicate, report it. 461 Diag(CR->getLHS()->getLocStart(), 462 diag::err_duplicate_case, OverlapVal.toString()); 463 Diag(OverlapStmt->getLHS()->getLocStart(), 464 diag::err_duplicate_case_prev); 465 // FIXME: We really want to remove the bogus case stmt from the substmt, 466 // but we have no way to do this right now. 467 CaseListIsErroneous = true; 468 } 469 } 470 } 471 472 // FIXME: If the case list was broken is some way, we don't have a good system 473 // to patch it up. Instead, just return the whole substmt as broken. 474 if (CaseListIsErroneous) 475 return true; 476 477 return SS; 478} 479 480Action::StmtResult 481Sema::ActOnWhileStmt(SourceLocation WhileLoc, ExprTy *Cond, StmtTy *Body) { 482 Expr *condExpr = (Expr *)Cond; 483 assert(condExpr && "ActOnWhileStmt(): missing expression"); 484 485 DefaultFunctionArrayConversion(condExpr); 486 QualType condType = condExpr->getType(); 487 488 if (!condType->isScalarType()) // C99 6.8.5p2 489 return Diag(WhileLoc, diag::err_typecheck_statement_requires_scalar, 490 condType.getAsString(), condExpr->getSourceRange()); 491 492 return new WhileStmt(condExpr, (Stmt*)Body, WhileLoc); 493} 494 495Action::StmtResult 496Sema::ActOnDoStmt(SourceLocation DoLoc, StmtTy *Body, 497 SourceLocation WhileLoc, ExprTy *Cond) { 498 Expr *condExpr = (Expr *)Cond; 499 assert(condExpr && "ActOnDoStmt(): missing expression"); 500 501 DefaultFunctionArrayConversion(condExpr); 502 QualType condType = condExpr->getType(); 503 504 if (!condType->isScalarType()) // C99 6.8.5p2 505 return Diag(DoLoc, diag::err_typecheck_statement_requires_scalar, 506 condType.getAsString(), condExpr->getSourceRange()); 507 508 return new DoStmt((Stmt*)Body, condExpr, DoLoc); 509} 510 511Action::StmtResult 512Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, 513 StmtTy *first, ExprTy *second, ExprTy *third, 514 SourceLocation RParenLoc, StmtTy *body) { 515 Stmt *First = static_cast<Stmt*>(first); 516 Expr *Second = static_cast<Expr*>(second); 517 Expr *Third = static_cast<Expr*>(third); 518 Stmt *Body = static_cast<Stmt*>(body); 519 520 if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) { 521 // C99 6.8.5p3: The declaration part of a 'for' statement shall only declare 522 // identifiers for objects having storage class 'auto' or 'register'. 523 for (ScopedDecl *D = DS->getDecl(); D; D = D->getNextDeclarator()) { 524 VarDecl *VD = dyn_cast<VarDecl>(D); 525 if (VD && VD->isBlockVarDecl() && !VD->hasLocalStorage()) 526 VD = 0; 527 if (VD == 0) 528 Diag(dyn_cast<ScopedDecl>(D)->getLocation(), 529 diag::err_non_variable_decl_in_for); 530 // FIXME: mark decl erroneous! 531 } 532 } 533 if (Second) { 534 DefaultFunctionArrayConversion(Second); 535 QualType SecondType = Second->getType(); 536 537 if (!SecondType->isScalarType()) // C99 6.8.5p2 538 return Diag(ForLoc, diag::err_typecheck_statement_requires_scalar, 539 SecondType.getAsString(), Second->getSourceRange()); 540 } 541 return new ForStmt(First, Second, Third, Body, ForLoc); 542} 543 544Action::StmtResult 545Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc, 546 SourceLocation LParenLoc, 547 StmtTy *first, ExprTy *second, 548 SourceLocation RParenLoc, StmtTy *body) { 549 Stmt *First = static_cast<Stmt*>(first); 550 Expr *Second = static_cast<Expr*>(second); 551 Stmt *Body = static_cast<Stmt*>(body); 552 if (First) { 553 QualType FirstType; 554 if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) { 555 FirstType = cast<ValueDecl>(DS->getDecl())->getType(); 556 // C99 6.8.5p3: The declaration part of a 'for' statement shall only declare 557 // identifiers for objects having storage class 'auto' or 'register'. 558 ScopedDecl *D = DS->getDecl(); 559 VarDecl *VD = cast<VarDecl>(D); 560 if (VD->isBlockVarDecl() && !VD->hasLocalStorage()) 561 return Diag(VD->getLocation(), diag::err_non_variable_decl_in_for); 562 if (D->getNextDeclarator()) 563 return Diag(D->getLocation(), diag::err_toomany_element_decls); 564 } else 565 FirstType = static_cast<Expr*>(first)->getType(); 566 if (!isObjCObjectPointerType(FirstType)) 567 Diag(ForLoc, diag::err_selector_element_type, 568 FirstType.getAsString(), First->getSourceRange()); 569 } 570 if (Second) { 571 DefaultFunctionArrayConversion(Second); 572 QualType SecondType = Second->getType(); 573 if (!isObjCObjectPointerType(SecondType)) 574 Diag(ForLoc, diag::err_collection_expr_type, 575 SecondType.getAsString(), Second->getSourceRange()); 576 } 577 return new ObjCForCollectionStmt(First, Second, Body, ForLoc, RParenLoc); 578} 579 580Action::StmtResult 581Sema::ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, 582 IdentifierInfo *LabelII) { 583 // Look up the record for this label identifier. 584 LabelStmt *&LabelDecl = LabelMap[LabelII]; 585 586 // If we haven't seen this label yet, create a forward reference. 587 if (LabelDecl == 0) 588 LabelDecl = new LabelStmt(LabelLoc, LabelII, 0); 589 590 return new GotoStmt(LabelDecl, GotoLoc, LabelLoc); 591} 592 593Action::StmtResult 594Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc,SourceLocation StarLoc, 595 ExprTy *DestExp) { 596 // FIXME: Verify that the operand is convertible to void*. 597 598 return new IndirectGotoStmt((Expr*)DestExp); 599} 600 601Action::StmtResult 602Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) { 603 Scope *S = CurScope->getContinueParent(); 604 if (!S) { 605 // C99 6.8.6.2p1: A break shall appear only in or as a loop body. 606 Diag(ContinueLoc, diag::err_continue_not_in_loop); 607 return true; 608 } 609 610 return new ContinueStmt(ContinueLoc); 611} 612 613Action::StmtResult 614Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) { 615 Scope *S = CurScope->getBreakParent(); 616 if (!S) { 617 // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body. 618 Diag(BreakLoc, diag::err_break_not_in_loop_or_switch); 619 return true; 620 } 621 622 return new BreakStmt(BreakLoc); 623} 624 625 626Action::StmtResult 627Sema::ActOnReturnStmt(SourceLocation ReturnLoc, ExprTy *rex) { 628 Expr *RetValExp = static_cast<Expr *>(rex); 629 QualType FnRetType = 630 getCurFunctionDecl() ? getCurFunctionDecl()->getResultType() : 631 getCurMethodDecl()->getResultType(); 632 633 if (FnRetType->isVoidType()) { 634 if (RetValExp) // C99 6.8.6.4p1 (ext_ since GCC warns) 635 Diag(ReturnLoc, diag::ext_return_has_expr, 636 ( getCurFunctionDecl() ? 637 getCurFunctionDecl()->getIdentifier()->getName() : 638 getCurMethodDecl()->getSelector().getName() ), 639 RetValExp->getSourceRange()); 640 return new ReturnStmt(ReturnLoc, RetValExp); 641 } else { 642 if (!RetValExp) { 643 const char *funcName = 644 getCurFunctionDecl() ? 645 getCurFunctionDecl()->getIdentifier()->getName() : 646 getCurMethodDecl()->getSelector().getName().c_str(); 647 if (getLangOptions().C99) // C99 6.8.6.4p1 (ext_ since GCC warns) 648 Diag(ReturnLoc, diag::ext_return_missing_expr, funcName); 649 else // C90 6.6.6.4p4 650 Diag(ReturnLoc, diag::warn_return_missing_expr, funcName); 651 return new ReturnStmt(ReturnLoc, (Expr*)0); 652 } 653 } 654 // we have a non-void function with an expression, continue checking 655 QualType RetValType = RetValExp->getType(); 656 657 // C99 6.8.6.4p3(136): The return statement is not an assignment. The 658 // overlap restriction of subclause 6.5.16.1 does not apply to the case of 659 // function return. 660 AssignConvertType ConvTy = CheckSingleAssignmentConstraints(FnRetType, 661 RetValExp); 662 if (DiagnoseAssignmentResult(ConvTy, ReturnLoc, FnRetType, 663 RetValType, RetValExp, "returning")) 664 return true; 665 666 if (RetValExp) CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc); 667 668 return new ReturnStmt(ReturnLoc, (Expr*)RetValExp); 669} 670 671Sema::StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, 672 bool IsSimple, 673 bool IsVolatile, 674 unsigned NumOutputs, 675 unsigned NumInputs, 676 std::string *Names, 677 ExprTy **Constraints, 678 ExprTy **Exprs, 679 ExprTy *asmString, 680 unsigned NumClobbers, 681 ExprTy **Clobbers, 682 SourceLocation RParenLoc) { 683 // The parser verifies that there is a string literal here. 684 StringLiteral *AsmString = cast<StringLiteral>((Expr *)asmString); 685 if (AsmString->isWide()) 686 // FIXME: We currently leak memory here. 687 return Diag(AsmString->getLocStart(), diag::err_asm_wide_character, 688 AsmString->getSourceRange()); 689 690 691 for (unsigned i = 0; i < NumOutputs; i++) { 692 StringLiteral *Literal = cast<StringLiteral>((Expr *)Constraints[i]); 693 if (Literal->isWide()) 694 // FIXME: We currently leak memory here. 695 return Diag(Literal->getLocStart(), diag::err_asm_wide_character, 696 Literal->getSourceRange()); 697 698 std::string OutputConstraint(Literal->getStrData(), 699 Literal->getByteLength()); 700 701 TargetInfo::ConstraintInfo info; 702 if (!Context.Target.validateOutputConstraint(OutputConstraint.c_str(),info)) 703 // FIXME: We currently leak memory here. 704 return Diag(Literal->getLocStart(), 705 diag::err_invalid_output_constraint_in_asm); 706 707 // Check that the output exprs are valid lvalues. 708 Expr *OutputExpr = (Expr *)Exprs[i]; 709 Expr::isLvalueResult Result = OutputExpr->isLvalue(); 710 if (Result != Expr::LV_Valid) { 711 ParenExpr *PE = cast<ParenExpr>(OutputExpr); 712 713 // FIXME: We currently leak memory here. 714 return Diag(PE->getSubExpr()->getLocStart(), 715 diag::err_invalid_lvalue_in_asm_output, 716 PE->getSubExpr()->getSourceRange()); 717 } 718 } 719 720 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) { 721 StringLiteral *Literal = cast<StringLiteral>((Expr *)Constraints[i]); 722 if (Literal->isWide()) 723 // FIXME: We currently leak memory here. 724 return Diag(Literal->getLocStart(), diag::err_asm_wide_character, 725 Literal->getSourceRange()); 726 727 std::string InputConstraint(Literal->getStrData(), 728 Literal->getByteLength()); 729 730 TargetInfo::ConstraintInfo info; 731 if (!Context.Target.validateInputConstraint(InputConstraint.c_str(), 732 NumOutputs, 733 info)) { 734 // FIXME: We currently leak memory here. 735 return Diag(Literal->getLocStart(), 736 diag::err_invalid_input_constraint_in_asm); 737 } 738 739 // Check that the input exprs aren't of type void. 740 Expr *InputExpr = (Expr *)Exprs[i]; 741 if (InputExpr->getType()->isVoidType()) { 742 ParenExpr *PE = cast<ParenExpr>(InputExpr); 743 744 // FIXME: We currently leak memory here. 745 return Diag(PE->getSubExpr()->getLocStart(), 746 diag::err_invalid_type_in_asm_input, 747 PE->getType().getAsString(), 748 PE->getSubExpr()->getSourceRange()); 749 } 750 } 751 752 // Check that the clobbers are valid. 753 for (unsigned i = 0; i < NumClobbers; i++) { 754 StringLiteral *Literal = cast<StringLiteral>((Expr *)Clobbers[i]); 755 if (Literal->isWide()) 756 // FIXME: We currently leak memory here. 757 return Diag(Literal->getLocStart(), diag::err_asm_wide_character, 758 Literal->getSourceRange()); 759 760 llvm::SmallString<16> Clobber(Literal->getStrData(), 761 Literal->getStrData() + 762 Literal->getByteLength()); 763 764 if (!Context.Target.isValidGCCRegisterName(Clobber.c_str())) 765 // FIXME: We currently leak memory here. 766 return Diag(Literal->getLocStart(), 767 diag::err_unknown_register_name_in_asm, Clobber.c_str()); 768 } 769 770 return new AsmStmt(AsmLoc, 771 IsSimple, 772 IsVolatile, 773 NumOutputs, 774 NumInputs, 775 Names, 776 reinterpret_cast<StringLiteral**>(Constraints), 777 reinterpret_cast<Expr**>(Exprs), 778 AsmString, NumClobbers, 779 reinterpret_cast<StringLiteral**>(Clobbers), 780 RParenLoc); 781} 782 783Action::StmtResult 784Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc, 785 SourceLocation RParen, StmtTy *Parm, 786 StmtTy *Body, StmtTy *CatchList) { 787 ObjCAtCatchStmt *CS = new ObjCAtCatchStmt(AtLoc, RParen, 788 static_cast<Stmt*>(Parm), static_cast<Stmt*>(Body), 789 static_cast<Stmt*>(CatchList)); 790 return CatchList ? CatchList : CS; 791} 792 793Action::StmtResult 794Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, StmtTy *Body) { 795 ObjCAtFinallyStmt *FS = new ObjCAtFinallyStmt(AtLoc, 796 static_cast<Stmt*>(Body)); 797 return FS; 798} 799 800Action::StmtResult 801Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, 802 StmtTy *Try, StmtTy *Catch, StmtTy *Finally) { 803 ObjCAtTryStmt *TS = new ObjCAtTryStmt(AtLoc, static_cast<Stmt*>(Try), 804 static_cast<Stmt*>(Catch), 805 static_cast<Stmt*>(Finally)); 806 return TS; 807} 808 809Action::StmtResult 810Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, StmtTy *Throw) { 811 ObjCAtThrowStmt *TS = new ObjCAtThrowStmt(AtLoc, static_cast<Stmt*>(Throw)); 812 return TS; 813} 814 815Action::StmtResult 816Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, ExprTy *SynchExpr, 817 StmtTy *SynchBody) { 818 ObjCAtSynchronizedStmt *SS = new ObjCAtSynchronizedStmt(AtLoc, 819 static_cast<Stmt*>(SynchExpr), static_cast<Stmt*>(SynchBody)); 820 return SS; 821} 822