SemaStmt.cpp revision 248a753f6b670692523c99afaeb8fe98f7ae3ca7
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 = CurFunctionDecl ? CurFunctionDecl->getResultType() : 630 CurMethodDecl->getResultType(); 631 632 if (FnRetType->isVoidType()) { 633 if (RetValExp) // C99 6.8.6.4p1 (ext_ since GCC warns) 634 Diag(ReturnLoc, diag::ext_return_has_expr, 635 (CurFunctionDecl ? CurFunctionDecl->getIdentifier()->getName() : 636 CurMethodDecl->getSelector().getName()), 637 RetValExp->getSourceRange()); 638 return new ReturnStmt(ReturnLoc, RetValExp); 639 } else { 640 if (!RetValExp) { 641 const char *funcName = CurFunctionDecl ? 642 CurFunctionDecl->getIdentifier()->getName() : 643 CurMethodDecl->getSelector().getName().c_str(); 644 if (getLangOptions().C99) // C99 6.8.6.4p1 (ext_ since GCC warns) 645 Diag(ReturnLoc, diag::ext_return_missing_expr, funcName); 646 else // C90 6.6.6.4p4 647 Diag(ReturnLoc, diag::warn_return_missing_expr, funcName); 648 return new ReturnStmt(ReturnLoc, (Expr*)0); 649 } 650 } 651 // we have a non-void function with an expression, continue checking 652 QualType RetValType = RetValExp->getType(); 653 654 // C99 6.8.6.4p3(136): The return statement is not an assignment. The 655 // overlap restriction of subclause 6.5.16.1 does not apply to the case of 656 // function return. 657 AssignConvertType ConvTy = CheckSingleAssignmentConstraints(FnRetType, 658 RetValExp); 659 if (DiagnoseAssignmentResult(ConvTy, ReturnLoc, FnRetType, 660 RetValType, RetValExp, "returning")) 661 return true; 662 663 if (RetValExp) CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc); 664 665 return new ReturnStmt(ReturnLoc, (Expr*)RetValExp); 666} 667 668Sema::StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, 669 bool IsSimple, 670 bool IsVolatile, 671 unsigned NumOutputs, 672 unsigned NumInputs, 673 std::string *Names, 674 ExprTy **Constraints, 675 ExprTy **Exprs, 676 ExprTy *AsmString, 677 unsigned NumClobbers, 678 ExprTy **Clobbers, 679 SourceLocation RParenLoc) { 680 Expr *E = (Expr *)AsmString; 681 682 for (unsigned i = 0; i < NumOutputs; i++) { 683 StringLiteral *Literal = cast<StringLiteral>((Expr *)Constraints[i]); 684 assert(!Literal->isWide() && 685 "Output constraint strings should not be wide!"); 686 687 std::string OutputConstraint(Literal->getStrData(), 688 Literal->getByteLength()); 689 690 TargetInfo::ConstraintInfo info; 691 if (!Context.Target.validateOutputConstraint(OutputConstraint.c_str(), 692 info)) { 693 // FIXME: We currently leak memory here. 694 Diag(Literal->getLocStart(), 695 diag::err_invalid_output_constraint_in_asm); 696 return true; 697 } 698 699 // Check that the output exprs are valid lvalues. 700 Expr *OutputExpr = (Expr *)Exprs[i]; 701 Expr::isLvalueResult Result = OutputExpr->isLvalue(); 702 if (Result != Expr::LV_Valid) { 703 ParenExpr *PE = cast<ParenExpr>(OutputExpr); 704 705 Diag(PE->getSubExpr()->getLocStart(), 706 diag::err_invalid_lvalue_in_asm_output, 707 PE->getSubExpr()->getSourceRange()); 708 709 // FIXME: We currently leak memory here. 710 return true; 711 } 712 } 713 714 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) { 715 StringLiteral *Literal = cast<StringLiteral>((Expr *)Constraints[i]); 716 assert(!Literal->isWide() && 717 "Output constraint strings should not be wide!"); 718 719 std::string InputConstraint(Literal->getStrData(), 720 Literal->getByteLength()); 721 722 TargetInfo::ConstraintInfo info; 723 if (!Context.Target.validateInputConstraint(InputConstraint.c_str(), 724 NumOutputs, 725 info)) { 726 // FIXME: We currently leak memory here. 727 Diag(Literal->getLocStart(), 728 diag::err_invalid_input_constraint_in_asm); 729 return true; 730 } 731 732 // Check that the input exprs aren't of type void. 733 Expr *InputExpr = (Expr *)Exprs[i]; 734 if (InputExpr->getType()->isVoidType()) { 735 ParenExpr *PE = cast<ParenExpr>(InputExpr); 736 737 Diag(PE->getSubExpr()->getLocStart(), 738 diag::err_invalid_type_in_asm_input, 739 PE->getType().getAsString(), 740 PE->getSubExpr()->getSourceRange()); 741 742 // FIXME: We currently leak memory here. 743 return true; 744 } 745 } 746 747 // Check that the clobbers are valid. 748 for (unsigned i = 0; i < NumClobbers; i++) { 749 StringLiteral *Literal = cast<StringLiteral>((Expr *)Clobbers[i]); 750 assert(!Literal->isWide() && "Clobber strings should not be wide!"); 751 752 llvm::SmallString<16> Clobber(Literal->getStrData(), 753 Literal->getStrData() + 754 Literal->getByteLength()); 755 756 if (!Context.Target.isValidGCCRegisterName(Clobber.c_str())) { 757 Diag(Literal->getLocStart(), 758 diag::err_unknown_register_name_in_asm, 759 Clobber.c_str()); 760 761 // FIXME: We currently leak memory here. 762 return true; 763 } 764 } 765 766 return new AsmStmt(AsmLoc, 767 IsSimple, 768 IsVolatile, 769 NumOutputs, 770 NumInputs, 771 Names, 772 reinterpret_cast<StringLiteral**>(Constraints), 773 reinterpret_cast<Expr**>(Exprs), 774 cast<StringLiteral>(E), 775 NumClobbers, 776 reinterpret_cast<StringLiteral**>(Clobbers), 777 RParenLoc); 778} 779 780Action::StmtResult 781Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc, 782 SourceLocation RParen, StmtTy *Parm, 783 StmtTy *Body, StmtTy *CatchList) { 784 ObjCAtCatchStmt *CS = new ObjCAtCatchStmt(AtLoc, RParen, 785 static_cast<Stmt*>(Parm), static_cast<Stmt*>(Body), 786 static_cast<Stmt*>(CatchList)); 787 return CatchList ? CatchList : CS; 788} 789 790Action::StmtResult 791Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, StmtTy *Body) { 792 ObjCAtFinallyStmt *FS = new ObjCAtFinallyStmt(AtLoc, 793 static_cast<Stmt*>(Body)); 794 return FS; 795} 796 797Action::StmtResult 798Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, 799 StmtTy *Try, StmtTy *Catch, StmtTy *Finally) { 800 ObjCAtTryStmt *TS = new ObjCAtTryStmt(AtLoc, static_cast<Stmt*>(Try), 801 static_cast<Stmt*>(Catch), 802 static_cast<Stmt*>(Finally)); 803 return TS; 804} 805 806Action::StmtResult 807Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, StmtTy *Throw) { 808 ObjCAtThrowStmt *TS = new ObjCAtThrowStmt(AtLoc, static_cast<Stmt*>(Throw)); 809 return TS; 810} 811 812Action::StmtResult 813Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, ExprTy *SynchExpr, 814 StmtTy *SynchBody) { 815 ObjCAtSynchronizedStmt *SS = new ObjCAtSynchronizedStmt(AtLoc, 816 static_cast<Stmt*>(SynchExpr), static_cast<Stmt*>(SynchBody)); 817 return SS; 818} 819 820 821