SemaStmt.cpp revision 1fe379f0fa6fbc0a6057e8966253aea2957ca953
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This file implements semantic analysis for statements. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "Sema.h" 15f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner#include "clang/AST/ASTContext.h" 16c4a1dea2dc56bd1357ec91b829a0b9e68229a13eDaniel Dunbar#include "clang/AST/DeclObjC.h" 175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/Expr.h" 186fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson#include "clang/Basic/TargetInfo.h" 195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/Diagnostic.h" 205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 221b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::StmtResult Sema::ActOnExprStmt(ExprTy *expr) { 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Expr *E = static_cast<Expr*>(expr); 241b273c403734d343d720acb28f04011807c8aa56Steve Naroff assert(E && "ActOnExprStmt(): missing expression"); 25834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner 26834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner // C99 6.8.3p2: The expression in an expression statement is evaluated as a 27834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner // void expression for its side effects. Conversion to void allows any 28834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner // operand, even incomplete types. 29834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner 30834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner // Same thing in for stmt first clause (when expr) and third clause. 315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return E; 325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 351b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc) { 365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return new NullStmt(SemiLoc); 375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3981c018d9482e7cc2addadc6202dcf162a01faefdChris LattnerSema::StmtResult Sema::ActOnDeclStmt(DeclTy *decl, SourceLocation StartLoc, 4081c018d9482e7cc2addadc6202dcf162a01faefdChris Lattner SourceLocation EndLoc) { 4181c018d9482e7cc2addadc6202dcf162a01faefdChris Lattner if (decl == 0) 4281c018d9482e7cc2addadc6202dcf162a01faefdChris Lattner return true; 4381c018d9482e7cc2addadc6202dcf162a01faefdChris Lattner 4481c018d9482e7cc2addadc6202dcf162a01faefdChris Lattner ScopedDecl *SD = cast<ScopedDecl>(static_cast<Decl *>(decl)); 4581c018d9482e7cc2addadc6202dcf162a01faefdChris Lattner return new DeclStmt(SD, StartLoc, EndLoc); 465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 491b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnCompoundStmt(SourceLocation L, SourceLocation R, 5098414c1b7d1944a57156d52e29bd41c005de09acChris Lattner StmtTy **elts, unsigned NumElts, bool isStmtExpr) { 51c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner Stmt **Elts = reinterpret_cast<Stmt**>(elts); 52c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner // If we're in C89 mode, check that we don't have any decls after stmts. If 53c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner // so, emit an extension diagnostic. 54c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) { 55c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner // Note that __extension__ can be around a decl. 56c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner unsigned i = 0; 57c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner // Skip over all declarations. 58c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i) 59c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner /*empty*/; 60c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner 61c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner // We found the end of the list or a statement. Scan for another declstmt. 62c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i) 63c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner /*empty*/; 64c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner 65c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner if (i != NumElts) { 668e74c93ddaa8268a999e1b25c723dc1984a434b4Steve Naroff ScopedDecl *D = cast<DeclStmt>(Elts[i])->getDecl(); 67c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner Diag(D->getLocation(), diag::ext_mixed_decls_code); 68c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner } 69c30ebfbf23d6a471146e3c68c2cf7f170b7e55dcChris Lattner } 7098414c1b7d1944a57156d52e29bd41c005de09acChris Lattner // Warn about unused expressions in statements. 7198414c1b7d1944a57156d52e29bd41c005de09acChris Lattner for (unsigned i = 0; i != NumElts; ++i) { 7298414c1b7d1944a57156d52e29bd41c005de09acChris Lattner Expr *E = dyn_cast<Expr>(Elts[i]); 7398414c1b7d1944a57156d52e29bd41c005de09acChris Lattner if (!E) continue; 7498414c1b7d1944a57156d52e29bd41c005de09acChris Lattner 7598414c1b7d1944a57156d52e29bd41c005de09acChris Lattner // Warn about expressions with unused results. 7698414c1b7d1944a57156d52e29bd41c005de09acChris Lattner if (E->hasLocalSideEffect() || E->getType()->isVoidType()) 7798414c1b7d1944a57156d52e29bd41c005de09acChris Lattner continue; 7898414c1b7d1944a57156d52e29bd41c005de09acChris Lattner 7998414c1b7d1944a57156d52e29bd41c005de09acChris Lattner // The last expr in a stmt expr really is used. 8098414c1b7d1944a57156d52e29bd41c005de09acChris Lattner if (isStmtExpr && i == NumElts-1) 8198414c1b7d1944a57156d52e29bd41c005de09acChris Lattner continue; 8298414c1b7d1944a57156d52e29bd41c005de09acChris Lattner 8398414c1b7d1944a57156d52e29bd41c005de09acChris Lattner /// DiagnoseDeadExpr - This expression is side-effect free and evaluated in 8498414c1b7d1944a57156d52e29bd41c005de09acChris Lattner /// a context where the result is unused. Emit a diagnostic to warn about 8598414c1b7d1944a57156d52e29bd41c005de09acChris Lattner /// this. 8698414c1b7d1944a57156d52e29bd41c005de09acChris Lattner if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) 8798414c1b7d1944a57156d52e29bd41c005de09acChris Lattner Diag(BO->getOperatorLoc(), diag::warn_unused_expr, 8898414c1b7d1944a57156d52e29bd41c005de09acChris Lattner BO->getLHS()->getSourceRange(), BO->getRHS()->getSourceRange()); 8998414c1b7d1944a57156d52e29bd41c005de09acChris Lattner else if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) 9098414c1b7d1944a57156d52e29bd41c005de09acChris Lattner Diag(UO->getOperatorLoc(), diag::warn_unused_expr, 9198414c1b7d1944a57156d52e29bd41c005de09acChris Lattner UO->getSubExpr()->getSourceRange()); 9298414c1b7d1944a57156d52e29bd41c005de09acChris Lattner else 9398414c1b7d1944a57156d52e29bd41c005de09acChris Lattner Diag(E->getExprLoc(), diag::warn_unused_expr, E->getSourceRange()); 9498414c1b7d1944a57156d52e29bd41c005de09acChris Lattner } 9598414c1b7d1944a57156d52e29bd41c005de09acChris Lattner 96b5a69586f1b8855ee4c1f0bb7a8f0ff4fe32ce09Steve Naroff return new CompoundStmt(Elts, NumElts, L, R); 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 1001b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnCaseStmt(SourceLocation CaseLoc, ExprTy *lhsval, 1016c36be5b383875b490684bcf439d6d427298c1afChris Lattner SourceLocation DotDotDotLoc, ExprTy *rhsval, 1020fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner SourceLocation ColonLoc, StmtTy *subStmt) { 1030fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner Stmt *SubStmt = static_cast<Stmt*>(subStmt); 1048a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner Expr *LHSVal = ((Expr *)lhsval), *RHSVal = ((Expr *)rhsval); 1055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert((LHSVal != 0) && "missing expression in case statement"); 106c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 1075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation ExpLoc; 1085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.4.2p3: The expression shall be an integer constant. 1090fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner if (!LHSVal->isIntegerConstantExpr(Context, &ExpLoc)) { 1100fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner Diag(ExpLoc, diag::err_case_label_not_integer_constant_expr, 1110fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner LHSVal->getSourceRange()); 1120fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner return SubStmt; 1130fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner } 1145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1156c36be5b383875b490684bcf439d6d427298c1afChris Lattner // GCC extension: The expression shall be an integer constant. 1160fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner if (RHSVal && !RHSVal->isIntegerConstantExpr(Context, &ExpLoc)) { 1170fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner Diag(ExpLoc, diag::err_case_label_not_integer_constant_expr, 1180fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner RHSVal->getSourceRange()); 119f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner RHSVal = 0; // Recover by just forgetting about it. 1206c36be5b383875b490684bcf439d6d427298c1afChris Lattner } 1218a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner 1228a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner if (SwitchStack.empty()) { 1238a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner Diag(CaseLoc, diag::err_case_not_in_switch); 1248a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner return SubStmt; 1258a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner } 1265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 127b5a69586f1b8855ee4c1f0bb7a8f0ff4fe32ce09Steve Naroff CaseStmt *CS = new CaseStmt(LHSVal, RHSVal, SubStmt, CaseLoc); 1288a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner SwitchStack.back()->addSwitchCase(CS); 129c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson return CS; 1305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 1331b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc, 1340fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner StmtTy *subStmt, Scope *CurScope) { 1350fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner Stmt *SubStmt = static_cast<Stmt*>(subStmt); 1366c36be5b383875b490684bcf439d6d427298c1afChris Lattner 1378a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner if (SwitchStack.empty()) { 1380fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner Diag(DefaultLoc, diag::err_default_not_in_switch); 1390fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner return SubStmt; 1400fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner } 1410fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner 1420fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner DefaultStmt *DS = new DefaultStmt(DefaultLoc, SubStmt); 1438a87e57beb96212ee61dc08a5f691cd7f7710703Chris Lattner SwitchStack.back()->addSwitchCase(DS); 144c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 1456c36be5b383875b490684bcf439d6d427298c1afChris Lattner return DS; 1465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 1491b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnLabelStmt(SourceLocation IdentLoc, IdentifierInfo *II, 1500fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner SourceLocation ColonLoc, StmtTy *subStmt) { 1510fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner Stmt *SubStmt = static_cast<Stmt*>(subStmt); 1525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Look up the record for this label identifier. 1535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LabelStmt *&LabelDecl = LabelMap[II]; 1545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If not forward referenced or defined already, just create a new LabelStmt. 1565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (LabelDecl == 0) 1570fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner return LabelDecl = new LabelStmt(IdentLoc, II, SubStmt); 1585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(LabelDecl->getID() == II && "Label mismatch!"); 1605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, this label was either forward reference or multiply defined. If 1625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // multiply defined, reject it now. 1635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (LabelDecl->getSubStmt()) { 1645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(IdentLoc, diag::err_redefinition_of_label, LabelDecl->getName()); 1655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(LabelDecl->getIdentLoc(), diag::err_previous_definition); 1660fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner return SubStmt; 1675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, this label was forward declared, and we just found its real 1705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // definition. Fill in the forward definition and return it. 1715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LabelDecl->setIdentLoc(IdentLoc); 1720fa152e72bb71c4aa184d0edd91caa9cbebbf70eChris Lattner LabelDecl->setSubStmt(SubStmt); 1735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return LabelDecl; 1745f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 1771b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnIfStmt(SourceLocation IfLoc, ExprTy *CondVal, 1785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StmtTy *ThenVal, SourceLocation ElseLoc, 1795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer StmtTy *ElseVal) { 1805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Expr *condExpr = (Expr *)CondVal; 1812d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson Stmt *thenStmt = (Stmt *)ThenVal; 1822d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson 1831b273c403734d343d720acb28f04011807c8aa56Steve Naroff assert(condExpr && "ActOnIfStmt(): missing expression"); 1845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 185c80b4eefa221f10871e7fed0ab9dc7d9d3d07dd0Steve Naroff DefaultFunctionArrayConversion(condExpr); 186c80b4eefa221f10871e7fed0ab9dc7d9d3d07dd0Steve Naroff QualType condType = condExpr->getType(); 1875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!condType->isScalarType()) // C99 6.8.4.1p1 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Diag(IfLoc, diag::err_typecheck_statement_requires_scalar, 1905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer condType.getAsString(), condExpr->getSourceRange()); 1915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1922d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson // Warn if the if block has a null body without an else value. 1932d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson // this helps prevent bugs due to typos, such as 1942d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson // if (condition); 1952d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson // do_stuff(); 1962d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson if (!ElseVal) { 1972d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt)) 1982d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson Diag(stmt->getSemiLoc(), diag::warn_empty_if_body); 1992d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson } 2002d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson 2012d85f8ba62fd6fdcf0ae303d77112b413d412caeAnders Carlsson return new IfStmt(IfLoc, condExpr, thenStmt, (Stmt*)ElseVal); 2025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 2051b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnStartOfSwitchStmt(ExprTy *cond) { 206f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Expr *Cond = static_cast<Expr*>(cond); 207f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 208f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr. 209f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner UsualUnaryConversions(Cond); 210f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 211f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner SwitchStmt *SS = new SwitchStmt(Cond); 212c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson SwitchStack.push_back(SS); 213c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson return SS; 214c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson} 2156c36be5b383875b490684bcf439d6d427298c1afChris Lattner 216f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have 217f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner/// the specified width and sign. If an overflow occurs, detect it and emit 218f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner/// the specified diagnostic. 219f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattnervoid Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val, 220f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner unsigned NewWidth, bool NewSign, 221f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner SourceLocation Loc, 222f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner unsigned DiagID) { 223f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // Perform a conversion to the promoted condition type if needed. 224f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner if (NewWidth > Val.getBitWidth()) { 225f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // If this is an extension, just do it. 226f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner llvm::APSInt OldVal(Val); 227f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Val.extend(NewWidth); 228f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 229f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // If the input was signed and negative and the output is unsigned, 230f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // warn. 231f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner if (!NewSign && OldVal.isSigned() && OldVal.isNegative()) 2329aa77f137b9b368f5bf46e2ab7bc7bd1d5755a5bChris Lattner Diag(Loc, DiagID, OldVal.toString(10), Val.toString(10)); 233f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 234f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Val.setIsSigned(NewSign); 235f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner } else if (NewWidth < Val.getBitWidth()) { 236f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // If this is a truncation, check for overflow. 237f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner llvm::APSInt ConvVal(Val); 238f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner ConvVal.trunc(NewWidth); 239b2137ae3f1bd0aadb0552189af2824a324ffaa69Chris Lattner ConvVal.setIsSigned(NewSign); 240f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner ConvVal.extend(Val.getBitWidth()); 241b2137ae3f1bd0aadb0552189af2824a324ffaa69Chris Lattner ConvVal.setIsSigned(Val.isSigned()); 242f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner if (ConvVal != Val) 2439aa77f137b9b368f5bf46e2ab7bc7bd1d5755a5bChris Lattner Diag(Loc, DiagID, Val.toString(10), ConvVal.toString(10)); 244f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 245f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // Regardless of whether a diagnostic was emitted, really do the 246f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // truncation. 247f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Val.trunc(NewWidth); 248b2137ae3f1bd0aadb0552189af2824a324ffaa69Chris Lattner Val.setIsSigned(NewSign); 249f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner } else if (NewSign != Val.isSigned()) { 250f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // Convert the sign to match the sign of the condition. This can cause 251f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // overflow as well: unsigned(INTMIN) 252f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner llvm::APSInt OldVal(Val); 253f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Val.setIsSigned(NewSign); 254f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 255f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner if (Val.isNegative()) // Sign bit changes meaning. 2569aa77f137b9b368f5bf46e2ab7bc7bd1d5755a5bChris Lattner Diag(Loc, DiagID, OldVal.toString(10), Val.toString(10)); 257f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner } 258f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner} 259f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 2600471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattnernamespace { 2610471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner struct CaseCompareFunctor { 2620471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 2630471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner const llvm::APSInt &RHS) { 2640471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner return LHS.first < RHS; 2650471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner } 2660e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS, 2670e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 2680e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner return LHS.first < RHS.first; 2690e85a2761ace912c66663d779dd230f88cf77fe0Chris Lattner } 2700471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner bool operator()(const llvm::APSInt &LHS, 2710471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner const std::pair<llvm::APSInt, CaseStmt*> &RHS) { 2720471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner return LHS < RHS.first; 2730471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner } 2740471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner }; 2750471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner} 2760471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner 277764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner/// CmpCaseVals - Comparison predicate for sorting case values. 278764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner/// 279764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattnerstatic bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs, 280764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner const std::pair<llvm::APSInt, CaseStmt*>& rhs) { 281764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner if (lhs.first < rhs.first) 282764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner return true; 283764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner 284764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner if (lhs.first == rhs.first && 285764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner lhs.second->getCaseLoc().getRawEncoding() 286764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner < rhs.second->getCaseLoc().getRawEncoding()) 287764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner return true; 288764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner return false; 289764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner} 290764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner 291c1fcb7762673be706b0a40477d5e93411e918f93Anders CarlssonAction::StmtResult 292764a7ce5217f9569e100a3445f47496ee82daf86Chris LattnerSema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, StmtTy *Switch, 293764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner ExprTy *Body) { 294c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson Stmt *BodyStmt = (Stmt*)Body; 295c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 296c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson SwitchStmt *SS = SwitchStack.back(); 297c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson assert(SS == (SwitchStmt*)Switch && "switch stack missing push/pop!"); 298c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 2999dcbfa450d751bd68fc4af8b75da381d4f6984b9Steve Naroff SS->setBody(BodyStmt, SwitchLoc); 300c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson SwitchStack.pop_back(); 301c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 302f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Expr *CondExpr = SS->getCond(); 303f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner QualType CondType = CondExpr->getType(); 3046c36be5b383875b490684bcf439d6d427298c1afChris Lattner 305f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner if (!CondType->isIntegerType()) { // C99 6.8.4.2p1 306c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson Diag(SwitchLoc, diag::err_typecheck_statement_requires_integer, 307f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner CondType.getAsString(), CondExpr->getSourceRange()); 308f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner return true; 309c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson } 310f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 311f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // Get the bitwidth of the switched-on value before promotions. We must 312f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // convert the integer case values to this width before comparison. 31398be4943e8dc4f3905629a7102668960873cf863Chris Lattner unsigned CondWidth = static_cast<unsigned>(Context.getTypeSize(CondType)); 314f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner bool CondIsSigned = CondType->isSignedIntegerType(); 315f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 316f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // Accumulate all of the case values in a vector so that we can sort them 317f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // and detect duplicates. This vector contains the APInt for the case after 318f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // it has been converted to the condition type. 3190471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner typedef llvm::SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy; 3200471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner CaseValsTy CaseVals; 321f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 322f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // Keep track of any GNU case ranges we see. The APSInt is the low value. 323f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRanges; 324f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 325f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner DefaultStmt *TheDefaultStmt = 0; 326c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 327b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner bool CaseListIsErroneous = false; 328b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 329b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner for (SwitchCase *SC = SS->getSwitchCaseList(); SC; 330c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson SC = SC->getNextSwitchCase()) { 331b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 332c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) { 333f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner if (TheDefaultStmt) { 334f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined); 335f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner Diag(TheDefaultStmt->getDefaultLoc(), diag::err_first_label); 336c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 337f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // FIXME: Remove the default statement from the switch block so that 338f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // we'll return a valid AST. This requires recursing down the 339f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // AST and finding it, not something we are set up to do right now. For 340f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // now, just lop the entire switch stmt out of the AST. 341b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner CaseListIsErroneous = true; 342c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson } 343f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner TheDefaultStmt = DS; 344c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson 345f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner } else { 346f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner CaseStmt *CS = cast<CaseStmt>(SC); 347f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 348f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // We already verified that the expression has a i-c-e value (C99 349f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // 6.8.4.2p3) - get that value now. 3501e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner Expr *Lo = CS->getLHS(); 35132442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar llvm::APSInt LoVal = Lo->getIntegerConstantExprValue(Context); 352f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 353f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner // Convert the value to the same width/sign as the condition. 354f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned, 355f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner CS->getLHS()->getLocStart(), 356f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner diag::warn_case_value_overflow); 3576c36be5b383875b490684bcf439d6d427298c1afChris Lattner 3581e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner // If the LHS is not the same type as the condition, insert an implicit 3591e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner // cast. 3601e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner ImpCastExprToType(Lo, CondType); 3611e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner CS->setLHS(Lo); 3621e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner 363b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // If this is a case range, remember it in CaseRanges, otherwise CaseVals. 364f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner if (CS->getRHS()) 365f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner CaseRanges.push_back(std::make_pair(LoVal, CS)); 366b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner else 367b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner CaseVals.push_back(std::make_pair(LoVal, CS)); 368f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner } 369f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner } 370f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 371b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // Sort all the scalar case values so we can easily detect duplicates. 372764a7ce5217f9569e100a3445f47496ee82daf86Chris Lattner std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals); 373b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 374f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner if (!CaseVals.empty()) { 375f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner for (unsigned i = 0, e = CaseVals.size()-1; i != e; ++i) { 376f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner if (CaseVals[i].first == CaseVals[i+1].first) { 377f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner // If we have a duplicate, report it. 378f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner Diag(CaseVals[i+1].second->getLHS()->getLocStart(), 3799aa77f137b9b368f5bf46e2ab7bc7bd1d5755a5bChris Lattner diag::err_duplicate_case, CaseVals[i].first.toString(10)); 380f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner Diag(CaseVals[i].second->getLHS()->getLocStart(), 381f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner diag::err_duplicate_case_prev); 382f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner // FIXME: We really want to remove the bogus case stmt from the substmt, 383f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner // but we have no way to do this right now. 384f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner CaseListIsErroneous = true; 385f334850cd2fc2d4ac9b585f80d97b4f0097a0348Chris Lattner } 386b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner } 387b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner } 388f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 389b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // Detect duplicate case ranges, which usually don't exist at all in the first 390b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // place. 391b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner if (!CaseRanges.empty()) { 392b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // Sort all the case ranges by their low value so we can easily detect 393b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // overlaps between ranges. 3940471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner std::stable_sort(CaseRanges.begin(), CaseRanges.end()); 395b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 396b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // Scan the ranges, computing the high values and removing empty ranges. 397b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner std::vector<llvm::APSInt> HiVals; 3986efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 399b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner CaseStmt *CR = CaseRanges[i].second; 4001e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner Expr *Hi = CR->getRHS(); 40132442bbc98bafa512fa42d46fedf60ed7d79f574Daniel Dunbar llvm::APSInt HiVal = Hi->getIntegerConstantExprValue(Context); 402b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 403b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // Convert the value to the same width/sign as the condition. 404b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned, 405b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner CR->getRHS()->getLocStart(), 406b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner diag::warn_case_value_overflow); 407b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 4081e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner // If the LHS is not the same type as the condition, insert an implicit 4091e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner // cast. 4101e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner ImpCastExprToType(Hi, CondType); 4111e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner CR->setRHS(Hi); 4121e0a39012467b4f409142c32148036a9ee05e1d7Chris Lattner 4136efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner // If the low value is bigger than the high value, the case is empty. 4146efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner if (CaseRanges[i].first > HiVal) { 4156efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range, 4166efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner SourceRange(CR->getLHS()->getLocStart(), 4176efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner CR->getRHS()->getLocEnd())); 4186efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner CaseRanges.erase(CaseRanges.begin()+i); 4196efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner --i, --e; 4206efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner continue; 4216efc4d3659632ddcea4a58cb62e9ee54ca4a373eChris Lattner } 422b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner HiVals.push_back(HiVal); 423b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner } 424b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 425b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // Rescan the ranges, looking for overlap with singleton values and other 4260471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // ranges. Since the range list is sorted, we only need to compare case 4270471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // ranges with their neighbors. 428b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) { 4290471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner llvm::APSInt &CRLo = CaseRanges[i].first; 4300471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner llvm::APSInt &CRHi = HiVals[i]; 4310471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner CaseStmt *CR = CaseRanges[i].second; 4320471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner 4330471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // Check to see whether the case range overlaps with any singleton cases. 4340471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner CaseStmt *OverlapStmt = 0; 4350471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner llvm::APSInt OverlapVal(32); 4360471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner 4370471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // Find the smallest value >= the lower bound. If I is in the case range, 4380471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // then we have overlap. 4390471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(), 4400471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner CaseVals.end(), CRLo, 4410471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner CaseCompareFunctor()); 4420471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner if (I != CaseVals.end() && I->first < CRHi) { 4430471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner OverlapVal = I->first; // Found overlap with scalar. 4440471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner OverlapStmt = I->second; 4450471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner } 4460471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner 4470471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // Find the smallest value bigger than the upper bound. 4480471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor()); 4490471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner if (I != CaseVals.begin() && (I-1)->first >= CRLo) { 4500471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner OverlapVal = (I-1)->first; // Found overlap with scalar. 4510471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner OverlapStmt = (I-1)->second; 4520471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner } 4530471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner 4540471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // Check to see if this case stmt overlaps with the subsequent case range. 4550471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner if (i && CRLo <= HiVals[i-1]) { 4560471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner OverlapVal = HiVals[i-1]; // Found overlap with range. 4570471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner OverlapStmt = CaseRanges[i-1].second; 4580471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner } 459b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner 4600471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner if (OverlapStmt) { 4610471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // If we have a duplicate, report it. 4620471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner Diag(CR->getLHS()->getLocStart(), 4639aa77f137b9b368f5bf46e2ab7bc7bd1d5755a5bChris Lattner diag::err_duplicate_case, OverlapVal.toString(10)); 4640471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner Diag(OverlapStmt->getLHS()->getLocStart(), 4650471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner diag::err_duplicate_case_prev); 4660471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // FIXME: We really want to remove the bogus case stmt from the substmt, 4670471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner // but we have no way to do this right now. 4680471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner CaseListIsErroneous = true; 4690471f5bc8191e39cdb61fabcaf1870e2af2d42e8Chris Lattner } 470b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner } 471b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner } 472f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 473b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // FIXME: If the case list was broken is some way, we don't have a good system 474b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner // to patch it up. Instead, just return the whole substmt as broken. 475b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner if (CaseListIsErroneous) 476b2ec9d6fede9cccc170a202de7bf7f523dea8be4Chris Lattner return true; 477f4021e7d5228a2be5a380269dffa0331a6c78b95Chris Lattner 478c1fcb7762673be706b0a40477d5e93411e918f93Anders Carlsson return SS; 4795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 4821b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnWhileStmt(SourceLocation WhileLoc, ExprTy *Cond, StmtTy *Body) { 4835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Expr *condExpr = (Expr *)Cond; 4841b273c403734d343d720acb28f04011807c8aa56Steve Naroff assert(condExpr && "ActOnWhileStmt(): missing expression"); 4855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 486c80b4eefa221f10871e7fed0ab9dc7d9d3d07dd0Steve Naroff DefaultFunctionArrayConversion(condExpr); 487c80b4eefa221f10871e7fed0ab9dc7d9d3d07dd0Steve Naroff QualType condType = condExpr->getType(); 4885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!condType->isScalarType()) // C99 6.8.5p2 4905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Diag(WhileLoc, diag::err_typecheck_statement_requires_scalar, 4915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer condType.getAsString(), condExpr->getSourceRange()); 4925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 493b5a69586f1b8855ee4c1f0bb7a8f0ff4fe32ce09Steve Naroff return new WhileStmt(condExpr, (Stmt*)Body, WhileLoc); 4945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 4971b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnDoStmt(SourceLocation DoLoc, StmtTy *Body, 4985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer SourceLocation WhileLoc, ExprTy *Cond) { 4995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Expr *condExpr = (Expr *)Cond; 5001b273c403734d343d720acb28f04011807c8aa56Steve Naroff assert(condExpr && "ActOnDoStmt(): missing expression"); 5015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 502c80b4eefa221f10871e7fed0ab9dc7d9d3d07dd0Steve Naroff DefaultFunctionArrayConversion(condExpr); 503c80b4eefa221f10871e7fed0ab9dc7d9d3d07dd0Steve Naroff QualType condType = condExpr->getType(); 5045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!condType->isScalarType()) // C99 6.8.5p2 5065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Diag(DoLoc, diag::err_typecheck_statement_requires_scalar, 5075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer condType.getAsString(), condExpr->getSourceRange()); 5085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 509b5a69586f1b8855ee4c1f0bb7a8f0ff4fe32ce09Steve Naroff return new DoStmt((Stmt*)Body, condExpr, DoLoc); 5105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 5131b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, 51436c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner StmtTy *first, ExprTy *second, ExprTy *third, 51536c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner SourceLocation RParenLoc, StmtTy *body) { 51636c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner Stmt *First = static_cast<Stmt*>(first); 51736c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner Expr *Second = static_cast<Expr*>(second); 51836c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner Expr *Third = static_cast<Expr*>(third); 51936c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner Stmt *Body = static_cast<Stmt*>(body); 52036c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner 521ae3b701f59e78e058b83344be17206af3bf5d277Chris Lattner if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) { 522ae3b701f59e78e058b83344be17206af3bf5d277Chris Lattner // C99 6.8.5p3: The declaration part of a 'for' statement shall only declare 523ae3b701f59e78e058b83344be17206af3bf5d277Chris Lattner // identifiers for objects having storage class 'auto' or 'register'. 524909cd267dd8f66867c0aaef3bef052dc27bde47cTed Kremenek for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end(); 525909cd267dd8f66867c0aaef3bef052dc27bde47cTed Kremenek DI!=DE; ++DI) { 526909cd267dd8f66867c0aaef3bef052dc27bde47cTed Kremenek VarDecl *VD = dyn_cast<VarDecl>(*DI); 527248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (VD && VD->isBlockVarDecl() && !VD->hasLocalStorage()) 528248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff VD = 0; 529248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (VD == 0) 530909cd267dd8f66867c0aaef3bef052dc27bde47cTed Kremenek Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for); 531ae3b701f59e78e058b83344be17206af3bf5d277Chris Lattner // FIXME: mark decl erroneous! 532ae3b701f59e78e058b83344be17206af3bf5d277Chris Lattner } 5335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 5345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Second) { 53536c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner DefaultFunctionArrayConversion(Second); 53636c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner QualType SecondType = Second->getType(); 5375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 53836c4b0ec13453bc003bbac380770b45ae35ef19cChris Lattner if (!SecondType->isScalarType()) // C99 6.8.5p2 5395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Diag(ForLoc, diag::err_typecheck_statement_requires_scalar, 540834a72ac74cf4ff07ba6215545dba3db578f8a07Chris Lattner SecondType.getAsString(), Second->getSourceRange()); 5415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 542b5a69586f1b8855ee4c1f0bb7a8f0ff4fe32ce09Steve Naroff return new ForStmt(First, Second, Third, Body, ForLoc); 5435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 5445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5453ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz JahanianAction::StmtResult 5467571228ec9b31de7733ae96352ee4eaa8afcf2b5Fariborz JahanianSema::ActOnObjCForCollectionStmt(SourceLocation ForLoc, 5473ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian SourceLocation LParenLoc, 5483ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian StmtTy *first, ExprTy *second, 5493ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian SourceLocation RParenLoc, StmtTy *body) { 5503ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian Stmt *First = static_cast<Stmt*>(first); 5513ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian Expr *Second = static_cast<Expr*>(second); 5523ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian Stmt *Body = static_cast<Stmt*>(body); 55320552d2842245692b649e0d25380670922f954a2Fariborz Jahanian if (First) { 55420552d2842245692b649e0d25380670922f954a2Fariborz Jahanian QualType FirstType; 55520552d2842245692b649e0d25380670922f954a2Fariborz Jahanian if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) { 55620552d2842245692b649e0d25380670922f954a2Fariborz Jahanian FirstType = cast<ValueDecl>(DS->getDecl())->getType(); 55720552d2842245692b649e0d25380670922f954a2Fariborz Jahanian // C99 6.8.5p3: The declaration part of a 'for' statement shall only declare 55820552d2842245692b649e0d25380670922f954a2Fariborz Jahanian // identifiers for objects having storage class 'auto' or 'register'. 55920552d2842245692b649e0d25380670922f954a2Fariborz Jahanian ScopedDecl *D = DS->getDecl(); 560248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff VarDecl *VD = cast<VarDecl>(D); 561248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff if (VD->isBlockVarDecl() && !VD->hasLocalStorage()) 562248a753f6b670692523c99afaeb8fe98f7ae3ca7Steve Naroff return Diag(VD->getLocation(), diag::err_non_variable_decl_in_for); 56320552d2842245692b649e0d25380670922f954a2Fariborz Jahanian if (D->getNextDeclarator()) 56420552d2842245692b649e0d25380670922f954a2Fariborz Jahanian return Diag(D->getLocation(), diag::err_toomany_element_decls); 5651fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson } else { 5661fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson Expr::isLvalueResult lval = cast<Expr>(First)->isLvalue(Context); 5671fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson 5681fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson if (lval != Expr::LV_Valid) 5691fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson return Diag(First->getLocStart(), diag::err_selector_element_not_lvalue, 5701fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson First->getSourceRange()); 5711fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson 5721fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson FirstType = static_cast<Expr*>(first)->getType(); 5731fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson } 574b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek if (!Context.isObjCObjectPointerType(FirstType)) 57520552d2842245692b649e0d25380670922f954a2Fariborz Jahanian Diag(ForLoc, diag::err_selector_element_type, 5761fe379f0fa6fbc0a6057e8966253aea2957ca953Anders Carlsson FirstType.getAsString(), First->getSourceRange()); 5773ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian } 5783ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian if (Second) { 5793ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian DefaultFunctionArrayConversion(Second); 5803ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian QualType SecondType = Second->getType(); 581b6ccaac65ca72f72954eb3893bbd940bedd23f00Ted Kremenek if (!Context.isObjCObjectPointerType(SecondType)) 5827571228ec9b31de7733ae96352ee4eaa8afcf2b5Fariborz Jahanian Diag(ForLoc, diag::err_collection_expr_type, 5831f990d67c2d24cb330434f42dd62a3a0cc4aa6e9Fariborz Jahanian SecondType.getAsString(), Second->getSourceRange()); 5843ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian } 5857571228ec9b31de7733ae96352ee4eaa8afcf2b5Fariborz Jahanian return new ObjCForCollectionStmt(First, Second, Body, ForLoc, RParenLoc); 5863ba5a0f90a03d5e13d02cbee9abd2a1ba01b18bcFariborz Jahanian} 5875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 5891b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc, 5905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IdentifierInfo *LabelII) { 5915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Look up the record for this label identifier. 5925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LabelStmt *&LabelDecl = LabelMap[LabelII]; 5935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 5945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If we haven't seen this label yet, create a forward reference. 5955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (LabelDecl == 0) 5965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer LabelDecl = new LabelStmt(LabelLoc, LabelII, 0); 5975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 59861f62165220e75694fe333179c78815e2e48d71fTed Kremenek return new GotoStmt(LabelDecl, GotoLoc, LabelLoc); 5995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 6021b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnIndirectGotoStmt(SourceLocation GotoLoc,SourceLocation StarLoc, 6035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ExprTy *DestExp) { 6045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: Verify that the operand is convertible to void*. 6055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return new IndirectGotoStmt((Expr*)DestExp); 6075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 6101b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) { 6115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Scope *S = CurScope->getContinueParent(); 6125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!S) { 6135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.6.2p1: A break shall appear only in or as a loop body. 6145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(ContinueLoc, diag::err_continue_not_in_loop); 6155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 6165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 6175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 618507f2d5811bd7da1a4d9d2f4960f32177dfab9deSteve Naroff return new ContinueStmt(ContinueLoc); 6195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 6221b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) { 6235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Scope *S = CurScope->getBreakParent(); 6245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!S) { 6255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body. 6265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(BreakLoc, diag::err_break_not_in_loop_or_switch); 6275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return true; 6285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 6295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 630507f2d5811bd7da1a4d9d2f4960f32177dfab9deSteve Naroff return new BreakStmt(BreakLoc); 6315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerAction::StmtResult 6351b273c403734d343d720acb28f04011807c8aa56Steve NaroffSema::ActOnReturnStmt(SourceLocation ReturnLoc, ExprTy *rex) { 63690045e8ebabf50d6f1b3a67081a621b20b5e5341Steve Naroff Expr *RetValExp = static_cast<Expr *>(rex); 63753d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis QualType FnRetType = 63853d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis getCurFunctionDecl() ? getCurFunctionDecl()->getResultType() : 63953d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis getCurMethodDecl()->getResultType(); 6405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6415cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner if (FnRetType->isVoidType()) { 6425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (RetValExp) // C99 6.8.6.4p1 (ext_ since GCC warns) 643b107ce82d425939ce32fc3c02faf7c2364abc1a3Fariborz Jahanian Diag(ReturnLoc, diag::ext_return_has_expr, 64453d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis ( getCurFunctionDecl() ? 64553d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis getCurFunctionDecl()->getIdentifier()->getName() : 64653d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis getCurMethodDecl()->getSelector().getName() ), 64790045e8ebabf50d6f1b3a67081a621b20b5e5341Steve Naroff RetValExp->getSourceRange()); 648507f2d5811bd7da1a4d9d2f4960f32177dfab9deSteve Naroff return new ReturnStmt(ReturnLoc, RetValExp); 6495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 6505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!RetValExp) { 65153d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis const char *funcName = 65253d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis getCurFunctionDecl() ? 65353d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis getCurFunctionDecl()->getIdentifier()->getName() : 65453d0ea5f5bfa647ec23418bf3a3b7c183b51e4bdArgyrios Kyrtzidis getCurMethodDecl()->getSelector().getName().c_str(); 6555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (getLangOptions().C99) // C99 6.8.6.4p1 (ext_ since GCC warns) 6565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(ReturnLoc, diag::ext_return_missing_expr, funcName); 6575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else // C90 6.6.6.4p4 6585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(ReturnLoc, diag::warn_return_missing_expr, funcName); 659507f2d5811bd7da1a4d9d2f4960f32177dfab9deSteve Naroff return new ReturnStmt(ReturnLoc, (Expr*)0); 6605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 6615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 6625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // we have a non-void function with an expression, continue checking 6635cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner QualType RetValType = RetValExp->getType(); 6645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.8.6.4p3(136): The return statement is not an assignment. The 6665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // overlap restriction of subclause 6.5.16.1 does not apply to the case of 6675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // function return. 6685cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner AssignConvertType ConvTy = CheckSingleAssignmentConstraints(FnRetType, 6695cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner RetValExp); 6705cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner if (DiagnoseAssignmentResult(ConvTy, ReturnLoc, FnRetType, 6715cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner RetValType, RetValExp, "returning")) 6725cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner return true; 67306de276fff91264437fa75111ed76de43097e089Ted Kremenek 6745cf216b7fa64b933b60743b0b26053e8e7aa87beChris Lattner if (RetValExp) CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc); 67506de276fff91264437fa75111ed76de43097e089Ted Kremenek 676507f2d5811bd7da1a4d9d2f4960f32177dfab9deSteve Naroff return new ReturnStmt(ReturnLoc, (Expr*)RetValExp); 6775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 6785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 6796a0ef4b83c91a6d6d5acb4ed5577c4659fe022a3Anders CarlssonSema::StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, 680dfab34a696d1dba8622248c31aaf605906cb6109Anders Carlsson bool IsSimple, 68139c47b56f45437bbc49c9568b7308a400234a730Anders Carlsson bool IsVolatile, 682b235fc2cf37621c7fc6511bb2b8788c95f9fb9fcAnders Carlsson unsigned NumOutputs, 683b235fc2cf37621c7fc6511bb2b8788c95f9fb9fcAnders Carlsson unsigned NumInputs, 684b235fc2cf37621c7fc6511bb2b8788c95f9fb9fcAnders Carlsson std::string *Names, 6851708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner ExprTy **constraints, 6861708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner ExprTy **exprs, 6876bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner ExprTy *asmString, 688b235fc2cf37621c7fc6511bb2b8788c95f9fb9fcAnders Carlsson unsigned NumClobbers, 6891708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner ExprTy **clobbers, 690fe795956194141c91ae555985c9b930595bff43fChris Lattner SourceLocation RParenLoc) { 6911708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner StringLiteral **Constraints = reinterpret_cast<StringLiteral**>(constraints); 6921708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner Expr **Exprs = reinterpret_cast<Expr **>(exprs); 6936bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner StringLiteral *AsmString = cast<StringLiteral>((Expr *)asmString); 6941708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers); 6951708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner 6961708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner // The parser verifies that there is a string literal here. 6976bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner if (AsmString->isWide()) 6986bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner // FIXME: We currently leak memory here. 6996bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner return Diag(AsmString->getLocStart(), diag::err_asm_wide_character, 7006bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner AsmString->getSourceRange()); 7016bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner 7026bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner 7031708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner for (unsigned i = 0; i != NumOutputs; i++) { 7041708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner StringLiteral *Literal = Constraints[i]; 7056bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner if (Literal->isWide()) 7066bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner // FIXME: We currently leak memory here. 7076bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner return Diag(Literal->getLocStart(), diag::err_asm_wide_character, 7086bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner Literal->getSourceRange()); 7096bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner 710d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson std::string OutputConstraint(Literal->getStrData(), 711d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson Literal->getByteLength()); 712d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson 713d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson TargetInfo::ConstraintInfo info; 7146bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner if (!Context.Target.validateOutputConstraint(OutputConstraint.c_str(),info)) 715d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson // FIXME: We currently leak memory here. 7166bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner return Diag(Literal->getLocStart(), 7171708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner diag::err_asm_invalid_output_constraint, OutputConstraint); 718d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson 719d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson // Check that the output exprs are valid lvalues. 7201708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner ParenExpr *OutputExpr = cast<ParenExpr>(Exprs[i]); 72128be73f74c9e241a23ea24fe5756623de6bf1084Chris Lattner Expr::isLvalueResult Result = OutputExpr->isLvalue(Context); 72204728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson if (Result != Expr::LV_Valid) { 72304728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson // FIXME: We currently leak memory here. 7241708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner return Diag(OutputExpr->getSubExpr()->getLocStart(), 7251708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner diag::err_asm_invalid_lvalue_in_output, 7261708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner OutputExpr->getSubExpr()->getSourceRange()); 72704728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson } 72804728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson } 72904728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson 73004728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) { 7311708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner StringLiteral *Literal = Constraints[i]; 7326bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner if (Literal->isWide()) 7336bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner // FIXME: We currently leak memory here. 7346bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner return Diag(Literal->getLocStart(), diag::err_asm_wide_character, 7356bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner Literal->getSourceRange()); 736d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson 737d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson std::string InputConstraint(Literal->getStrData(), 738d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson Literal->getByteLength()); 739d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson 740d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson TargetInfo::ConstraintInfo info; 741d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson if (!Context.Target.validateInputConstraint(InputConstraint.c_str(), 7421708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner NumOutputs, info)) { 743d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson // FIXME: We currently leak memory here. 7446bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner return Diag(Literal->getLocStart(), 7451708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner diag::err_asm_invalid_input_constraint, InputConstraint); 746d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson } 74704728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson 748d04c6e23f2e10eeb9936778d67f4a1c4a14cc4f6Anders Carlsson // Check that the input exprs aren't of type void. 7491708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner ParenExpr *InputExpr = cast<ParenExpr>(Exprs[i]); 75004728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson if (InputExpr->getType()->isVoidType()) { 75104728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson 75204728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson // FIXME: We currently leak memory here. 7531708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner return Diag(InputExpr->getSubExpr()->getLocStart(), 7541708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner diag::err_asm_invalid_type_in_input, 7551708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner InputExpr->getType().getAsString(), InputConstraint, 7561708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner InputExpr->getSubExpr()->getSourceRange()); 75704728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson } 75804728b7ea928b029f165fc67d32ced40e6868b31Anders Carlsson } 759b235fc2cf37621c7fc6511bb2b8788c95f9fb9fcAnders Carlsson 7606fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson // Check that the clobbers are valid. 7611708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner for (unsigned i = 0; i != NumClobbers; i++) { 7621708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner StringLiteral *Literal = Clobbers[i]; 7636bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner if (Literal->isWide()) 7646bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner // FIXME: We currently leak memory here. 7656bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner return Diag(Literal->getLocStart(), diag::err_asm_wide_character, 7666bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner Literal->getSourceRange()); 7676fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson 7686fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson llvm::SmallString<16> Clobber(Literal->getStrData(), 7696fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson Literal->getStrData() + 7706fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson Literal->getByteLength()); 7716fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson 7726bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner if (!Context.Target.isValidGCCRegisterName(Clobber.c_str())) 7736fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson // FIXME: We currently leak memory here. 7746bc52112dbc54551bd8e215d95bba4791b2275f7Chris Lattner return Diag(Literal->getLocStart(), 7751708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner diag::err_asm_unknown_register_name, Clobber.c_str()); 7766fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson } 7776fa9086043b0338d895a4cdb0ec8542530af90d7Anders Carlsson 7781708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner return new AsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs, NumInputs, 7791708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner Names, Constraints, Exprs, AsmString, NumClobbers, 7801708b963a014b48103e78131f960a13ee1aa6d0cChris Lattner Clobbers, RParenLoc); 781fe795956194141c91ae555985c9b930595bff43fChris Lattner} 7823b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian 7833b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz JahanianAction::StmtResult 784a526c5c67e5a0473c340903ee542ce570119665fTed KremenekSema::ActOnObjCAtCatchStmt(SourceLocation AtLoc, 7853b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian SourceLocation RParen, StmtTy *Parm, 7863b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian StmtTy *Body, StmtTy *CatchList) { 787a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCAtCatchStmt *CS = new ObjCAtCatchStmt(AtLoc, RParen, 7883b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian static_cast<Stmt*>(Parm), static_cast<Stmt*>(Body), 7893b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian static_cast<Stmt*>(CatchList)); 7903b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian return CatchList ? CatchList : CS; 7913b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian} 7923b1191d7eaf2f4984564e01ab84b6713a9d80e70Fariborz Jahanian 793161a9c5afaafb4d527b7efba9675a8b2cbbe32e0Fariborz JahanianAction::StmtResult 794a526c5c67e5a0473c340903ee542ce570119665fTed KremenekSema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, StmtTy *Body) { 795a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCAtFinallyStmt *FS = new ObjCAtFinallyStmt(AtLoc, 796161a9c5afaafb4d527b7efba9675a8b2cbbe32e0Fariborz Jahanian static_cast<Stmt*>(Body)); 797161a9c5afaafb4d527b7efba9675a8b2cbbe32e0Fariborz Jahanian return FS; 798161a9c5afaafb4d527b7efba9675a8b2cbbe32e0Fariborz Jahanian} 799bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian 800bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz JahanianAction::StmtResult 801a526c5c67e5a0473c340903ee542ce570119665fTed KremenekSema::ActOnObjCAtTryStmt(SourceLocation AtLoc, 802bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian StmtTy *Try, StmtTy *Catch, StmtTy *Finally) { 803a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCAtTryStmt *TS = new ObjCAtTryStmt(AtLoc, static_cast<Stmt*>(Try), 804bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian static_cast<Stmt*>(Catch), 805bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian static_cast<Stmt*>(Finally)); 806bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian return TS; 807bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian} 808bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian 80939f8f159c488a900e5958d5aab3e467af9ec8a2bFariborz JahanianAction::StmtResult 810a526c5c67e5a0473c340903ee542ce570119665fTed KremenekSema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, StmtTy *Throw) { 811a526c5c67e5a0473c340903ee542ce570119665fTed Kremenek ObjCAtThrowStmt *TS = new ObjCAtThrowStmt(AtLoc, static_cast<Stmt*>(Throw)); 81239f8f159c488a900e5958d5aab3e467af9ec8a2bFariborz Jahanian return TS; 81339f8f159c488a900e5958d5aab3e467af9ec8a2bFariborz Jahanian} 814bd49a647afd9cc534fef13cadf652d4e9c396e2bFariborz Jahanian 815fa3ee8e6776634caf064ba5928ca7699d317a280Fariborz JahanianAction::StmtResult 816fa3ee8e6776634caf064ba5928ca7699d317a280Fariborz JahanianSema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, ExprTy *SynchExpr, 817fa3ee8e6776634caf064ba5928ca7699d317a280Fariborz Jahanian StmtTy *SynchBody) { 818fa3ee8e6776634caf064ba5928ca7699d317a280Fariborz Jahanian ObjCAtSynchronizedStmt *SS = new ObjCAtSynchronizedStmt(AtLoc, 819a0f55792409289d1d343023fa8292cff6355e538Fariborz Jahanian static_cast<Stmt*>(SynchExpr), static_cast<Stmt*>(SynchBody)); 820fa3ee8e6776634caf064ba5928ca7699d317a280Fariborz Jahanian return SS; 821fa3ee8e6776634caf064ba5928ca7699d317a280Fariborz Jahanian} 822