1 //===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for statements.
12 //===----------------------------------------------------------------------===//
15 #include "clang/AST/APValue.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/StmtObjC.h"
20 #include "clang/AST/StmtCXX.h"
21 #include "clang/Basic/TargetInfo.h"
22 using namespace clang;
24 Sema::OwningStmtResult Sema::ActOnExprStmt(FullExprArg expr) {
25 Expr *E = expr->takeAs<Expr>();
26 assert(E && "ActOnExprStmt(): missing expression");
28 // C99 6.8.3p2: The expression in an expression statement is evaluated as a
29 // void expression for its side effects. Conversion to void allows any
30 // operand, even incomplete types.
32 // Same thing in for stmt first clause (when expr) and third clause.
33 return Owned(static_cast<Stmt*>(E));
37 Sema::OwningStmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc) {
38 return Owned(new (Context) NullStmt(SemiLoc));
41 Sema::OwningStmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg,
42 SourceLocation StartLoc,
43 SourceLocation EndLoc) {
44 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
46 // If we have an invalid decl, just return an error.
47 if (DG.isNull()) return StmtError();
49 return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
52 Action::OwningStmtResult
53 Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
54 MultiStmtArg elts, bool isStmtExpr) {
55 unsigned NumElts = elts.size();
56 Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
57 // If we're in C89 mode, check that we don't have any decls after stmts. If
58 // so, emit an extension diagnostic.
59 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) {
60 // Note that __extension__ can be around a decl.
62 // Skip over all declarations.
63 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
66 // We found the end of the list or a statement. Scan for another declstmt.
67 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
71 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
72 Diag(D->getLocation(), diag::ext_mixed_decls_code);
75 // Warn about unused expressions in statements.
76 for (unsigned i = 0; i != NumElts; ++i) {
77 Expr *E = dyn_cast<Expr>(Elts[i]);
80 // Warn about expressions with unused results if they are non-void and if
81 // this not the last stmt in a stmt expr.
82 if (E->getType()->isVoidType() || (isStmtExpr && i == NumElts-1))
87 if (!E->isUnusedResultAWarning(Loc, R1, R2))
90 Diag(Loc, diag::warn_unused_expr) << R1 << R2;
93 return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
96 Action::OwningStmtResult
97 Sema::ActOnCaseStmt(SourceLocation CaseLoc, ExprArg lhsval,
98 SourceLocation DotDotDotLoc, ExprArg rhsval,
99 SourceLocation ColonLoc) {
100 assert((lhsval.get() != 0) && "missing expression in case statement");
102 // C99 6.8.4.2p3: The expression shall be an integer constant.
103 // However, GCC allows any evaluatable integer expression.
104 Expr *LHSVal = static_cast<Expr*>(lhsval.get());
105 if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent() &&
106 VerifyIntegerConstantExpression(LHSVal))
109 // GCC extension: The expression shall be an integer constant.
111 Expr *RHSVal = static_cast<Expr*>(rhsval.get());
112 if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent() &&
113 VerifyIntegerConstantExpression(RHSVal)) {
114 RHSVal = 0; // Recover by just forgetting about it.
118 if (getSwitchStack().empty()) {
119 Diag(CaseLoc, diag::err_case_not_in_switch);
123 // Only now release the smart pointers.
126 CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
128 getSwitchStack().back()->addSwitchCase(CS);
132 /// ActOnCaseStmtBody - This installs a statement as the body of a case.
133 void Sema::ActOnCaseStmtBody(StmtTy *caseStmt, StmtArg subStmt) {
134 CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
135 Stmt *SubStmt = subStmt.takeAs<Stmt>();
136 CS->setSubStmt(SubStmt);
139 Action::OwningStmtResult
140 Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
141 StmtArg subStmt, Scope *CurScope) {
142 Stmt *SubStmt = subStmt.takeAs<Stmt>();
144 if (getSwitchStack().empty()) {
145 Diag(DefaultLoc, diag::err_default_not_in_switch);
146 return Owned(SubStmt);
149 DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
150 getSwitchStack().back()->addSwitchCase(DS);
154 Action::OwningStmtResult
155 Sema::ActOnLabelStmt(SourceLocation IdentLoc, IdentifierInfo *II,
156 SourceLocation ColonLoc, StmtArg subStmt) {
157 Stmt *SubStmt = subStmt.takeAs<Stmt>();
158 // Look up the record for this label identifier.
159 LabelStmt *&LabelDecl = getLabelMap()[II];
161 // If not forward referenced or defined already, just create a new LabelStmt.
163 return Owned(LabelDecl = new (Context) LabelStmt(IdentLoc, II, SubStmt));
165 assert(LabelDecl->getID() == II && "Label mismatch!");
167 // Otherwise, this label was either forward reference or multiply defined. If
168 // multiply defined, reject it now.
169 if (LabelDecl->getSubStmt()) {
170 Diag(IdentLoc, diag::err_redefinition_of_label) << LabelDecl->getID();
171 Diag(LabelDecl->getIdentLoc(), diag::note_previous_definition);
172 return Owned(SubStmt);
175 // Otherwise, this label was forward declared, and we just found its real
176 // definition. Fill in the forward definition and return it.
177 LabelDecl->setIdentLoc(IdentLoc);
178 LabelDecl->setSubStmt(SubStmt);
179 return Owned(LabelDecl);
182 Action::OwningStmtResult
183 Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal,
184 StmtArg ThenVal, SourceLocation ElseLoc,
186 OwningExprResult CondResult(CondVal.release());
188 Expr *condExpr = CondResult.takeAs<Expr>();
190 assert(condExpr && "ActOnIfStmt(): missing expression");
192 if (!condExpr->isTypeDependent()) {
193 DefaultFunctionArrayConversion(condExpr);
194 // Take ownership again until we're past the error checking.
195 CondResult = condExpr;
196 QualType condType = condExpr->getType();
198 if (getLangOptions().CPlusPlus) {
199 if (CheckCXXBooleanCondition(condExpr)) // C++ 6.4p4
201 } else if (!condType->isScalarType()) // C99 6.8.4.1p1
202 return StmtError(Diag(IfLoc,
203 diag::err_typecheck_statement_requires_scalar)
204 << condType << condExpr->getSourceRange());
207 Stmt *thenStmt = ThenVal.takeAs<Stmt>();
209 // Warn if the if block has a null body without an else value.
210 // this helps prevent bugs due to typos, such as
213 if (!ElseVal.get()) {
214 if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt))
215 Diag(stmt->getSemiLoc(), diag::warn_empty_if_body);
218 CondResult.release();
219 return Owned(new (Context) IfStmt(IfLoc, condExpr, thenStmt,
220 ElseLoc, ElseVal.takeAs<Stmt>()));
223 Action::OwningStmtResult
224 Sema::ActOnStartOfSwitchStmt(ExprArg cond) {
225 Expr *Cond = cond.takeAs<Expr>();
227 if (getLangOptions().CPlusPlus) {
229 // The condition shall be of integral type, enumeration type, or of a class
230 // type for which a single conversion function to integral or enumeration
231 // type exists (12.3). If the condition is of class type, the condition is
232 // converted by calling that conversion function, and the result of the
233 // conversion is used in place of the original condition for the remainder
234 // of this section. Integral promotions are performed.
235 if (!Cond->isTypeDependent()) {
236 QualType Ty = Cond->getType();
238 // FIXME: Handle class types.
240 // If the type is wrong a diagnostic will be emitted later at
241 // ActOnFinishSwitchStmt.
242 if (Ty->isIntegralType() || Ty->isEnumeralType()) {
243 // Integral promotions are performed.
244 // FIXME: Integral promotions for C++ are not complete.
245 UsualUnaryConversions(Cond);
249 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
250 UsualUnaryConversions(Cond);
253 SwitchStmt *SS = new (Context) SwitchStmt(Cond);
254 getSwitchStack().push_back(SS);
258 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
259 /// the specified width and sign. If an overflow occurs, detect it and emit
260 /// the specified diagnostic.
261 void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
262 unsigned NewWidth, bool NewSign,
265 // Perform a conversion to the promoted condition type if needed.
266 if (NewWidth > Val.getBitWidth()) {
267 // If this is an extension, just do it.
268 llvm::APSInt OldVal(Val);
269 Val.extend(NewWidth);
271 // If the input was signed and negative and the output is unsigned,
273 if (!NewSign && OldVal.isSigned() && OldVal.isNegative())
274 Diag(Loc, DiagID) << OldVal.toString(10) << Val.toString(10);
276 Val.setIsSigned(NewSign);
277 } else if (NewWidth < Val.getBitWidth()) {
278 // If this is a truncation, check for overflow.
279 llvm::APSInt ConvVal(Val);
280 ConvVal.trunc(NewWidth);
281 ConvVal.setIsSigned(NewSign);
282 ConvVal.extend(Val.getBitWidth());
283 ConvVal.setIsSigned(Val.isSigned());
285 Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
287 // Regardless of whether a diagnostic was emitted, really do the
290 Val.setIsSigned(NewSign);
291 } else if (NewSign != Val.isSigned()) {
292 // Convert the sign to match the sign of the condition. This can cause
293 // overflow as well: unsigned(INTMIN)
294 llvm::APSInt OldVal(Val);
295 Val.setIsSigned(NewSign);
297 if (Val.isNegative()) // Sign bit changes meaning.
298 Diag(Loc, DiagID) << OldVal.toString(10) << Val.toString(10);
303 struct CaseCompareFunctor {
304 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
305 const llvm::APSInt &RHS) {
306 return LHS.first < RHS;
308 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
309 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
310 return LHS.first < RHS.first;
312 bool operator()(const llvm::APSInt &LHS,
313 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
314 return LHS < RHS.first;
319 /// CmpCaseVals - Comparison predicate for sorting case values.
321 static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
322 const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
323 if (lhs.first < rhs.first)
326 if (lhs.first == rhs.first &&
327 lhs.second->getCaseLoc().getRawEncoding()
328 < rhs.second->getCaseLoc().getRawEncoding())
333 Action::OwningStmtResult
334 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, StmtArg Switch,
336 Stmt *BodyStmt = Body.takeAs<Stmt>();
338 SwitchStmt *SS = getSwitchStack().back();
339 assert(SS == (SwitchStmt*)Switch.get() && "switch stack missing push/pop!");
341 SS->setBody(BodyStmt, SwitchLoc);
342 getSwitchStack().pop_back();
344 Expr *CondExpr = SS->getCond();
345 QualType CondType = CondExpr->getType();
347 if (!CondExpr->isTypeDependent() &&
348 !CondType->isIntegerType()) { // C99 6.8.4.2p1
349 Diag(SwitchLoc, diag::err_typecheck_statement_requires_integer)
350 << CondType << CondExpr->getSourceRange();
354 // Get the bitwidth of the switched-on value before promotions. We must
355 // convert the integer case values to this width before comparison.
356 bool HasDependentValue
357 = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
359 = HasDependentValue? 0
360 : static_cast<unsigned>(Context.getTypeSize(CondType));
361 bool CondIsSigned = CondType->isSignedIntegerType();
363 // Accumulate all of the case values in a vector so that we can sort them
364 // and detect duplicates. This vector contains the APInt for the case after
365 // it has been converted to the condition type.
366 typedef llvm::SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
369 // Keep track of any GNU case ranges we see. The APSInt is the low value.
370 std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRanges;
372 DefaultStmt *TheDefaultStmt = 0;
374 bool CaseListIsErroneous = false;
376 for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
377 SC = SC->getNextSwitchCase()) {
379 if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
380 if (TheDefaultStmt) {
381 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
382 Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
384 // FIXME: Remove the default statement from the switch block so that
385 // we'll return a valid AST. This requires recursing down the AST and
386 // finding it, not something we are set up to do right now. For now,
387 // just lop the entire switch stmt out of the AST.
388 CaseListIsErroneous = true;
393 CaseStmt *CS = cast<CaseStmt>(SC);
395 // We already verified that the expression has a i-c-e value (C99
396 // 6.8.4.2p3) - get that value now.
397 Expr *Lo = CS->getLHS();
399 if (Lo->isTypeDependent() || Lo->isValueDependent()) {
400 HasDependentValue = true;
404 llvm::APSInt LoVal = Lo->EvaluateAsInt(Context);
406 // Convert the value to the same width/sign as the condition.
407 ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
408 CS->getLHS()->getLocStart(),
409 diag::warn_case_value_overflow);
411 // If the LHS is not the same type as the condition, insert an implicit
413 ImpCastExprToType(Lo, CondType);
416 // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
418 if (CS->getRHS()->isTypeDependent() ||
419 CS->getRHS()->isValueDependent()) {
420 HasDependentValue = true;
423 CaseRanges.push_back(std::make_pair(LoVal, CS));
425 CaseVals.push_back(std::make_pair(LoVal, CS));
429 if (!HasDependentValue) {
430 // Sort all the scalar case values so we can easily detect duplicates.
431 std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
433 if (!CaseVals.empty()) {
434 for (unsigned i = 0, e = CaseVals.size()-1; i != e; ++i) {
435 if (CaseVals[i].first == CaseVals[i+1].first) {
436 // If we have a duplicate, report it.
437 Diag(CaseVals[i+1].second->getLHS()->getLocStart(),
438 diag::err_duplicate_case) << CaseVals[i].first.toString(10);
439 Diag(CaseVals[i].second->getLHS()->getLocStart(),
440 diag::note_duplicate_case_prev);
441 // FIXME: We really want to remove the bogus case stmt from the
442 // substmt, but we have no way to do this right now.
443 CaseListIsErroneous = true;
448 // Detect duplicate case ranges, which usually don't exist at all in
450 if (!CaseRanges.empty()) {
451 // Sort all the case ranges by their low value so we can easily detect
452 // overlaps between ranges.
453 std::stable_sort(CaseRanges.begin(), CaseRanges.end());
455 // Scan the ranges, computing the high values and removing empty ranges.
456 std::vector<llvm::APSInt> HiVals;
457 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
458 CaseStmt *CR = CaseRanges[i].second;
459 Expr *Hi = CR->getRHS();
460 llvm::APSInt HiVal = Hi->EvaluateAsInt(Context);
462 // Convert the value to the same width/sign as the condition.
463 ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
464 CR->getRHS()->getLocStart(),
465 diag::warn_case_value_overflow);
467 // If the LHS is not the same type as the condition, insert an implicit
469 ImpCastExprToType(Hi, CondType);
472 // If the low value is bigger than the high value, the case is empty.
473 if (CaseRanges[i].first > HiVal) {
474 Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
475 << SourceRange(CR->getLHS()->getLocStart(),
476 CR->getRHS()->getLocEnd());
477 CaseRanges.erase(CaseRanges.begin()+i);
481 HiVals.push_back(HiVal);
484 // Rescan the ranges, looking for overlap with singleton values and other
485 // ranges. Since the range list is sorted, we only need to compare case
486 // ranges with their neighbors.
487 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
488 llvm::APSInt &CRLo = CaseRanges[i].first;
489 llvm::APSInt &CRHi = HiVals[i];
490 CaseStmt *CR = CaseRanges[i].second;
492 // Check to see whether the case range overlaps with any
494 CaseStmt *OverlapStmt = 0;
495 llvm::APSInt OverlapVal(32);
497 // Find the smallest value >= the lower bound. If I is in the
498 // case range, then we have overlap.
499 CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
500 CaseVals.end(), CRLo,
501 CaseCompareFunctor());
502 if (I != CaseVals.end() && I->first < CRHi) {
503 OverlapVal = I->first; // Found overlap with scalar.
504 OverlapStmt = I->second;
507 // Find the smallest value bigger than the upper bound.
508 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
509 if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
510 OverlapVal = (I-1)->first; // Found overlap with scalar.
511 OverlapStmt = (I-1)->second;
514 // Check to see if this case stmt overlaps with the subsequent
516 if (i && CRLo <= HiVals[i-1]) {
517 OverlapVal = HiVals[i-1]; // Found overlap with range.
518 OverlapStmt = CaseRanges[i-1].second;
522 // If we have a duplicate, report it.
523 Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
524 << OverlapVal.toString(10);
525 Diag(OverlapStmt->getLHS()->getLocStart(),
526 diag::note_duplicate_case_prev);
527 // FIXME: We really want to remove the bogus case stmt from the
528 // substmt, but we have no way to do this right now.
529 CaseListIsErroneous = true;
535 // FIXME: If the case list was broken is some way, we don't have a good system
536 // to patch it up. Instead, just return the whole substmt as broken.
537 if (CaseListIsErroneous)
544 Action::OwningStmtResult
545 Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond, StmtArg Body) {
546 ExprArg CondArg(Cond.release());
547 Expr *condExpr = CondArg.takeAs<Expr>();
548 assert(condExpr && "ActOnWhileStmt(): missing expression");
550 if (!condExpr->isTypeDependent()) {
551 DefaultFunctionArrayConversion(condExpr);
553 QualType condType = condExpr->getType();
555 if (getLangOptions().CPlusPlus) {
556 if (CheckCXXBooleanCondition(condExpr)) // C++ 6.4p4
558 } else if (!condType->isScalarType()) // C99 6.8.5p2
559 return StmtError(Diag(WhileLoc,
560 diag::err_typecheck_statement_requires_scalar)
561 << condType << condExpr->getSourceRange());
565 return Owned(new (Context) WhileStmt(condExpr, Body.takeAs<Stmt>(),
569 Action::OwningStmtResult
570 Sema::ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
571 SourceLocation WhileLoc, SourceLocation CondLParen,
572 ExprArg Cond, SourceLocation CondRParen) {
573 Expr *condExpr = Cond.takeAs<Expr>();
574 assert(condExpr && "ActOnDoStmt(): missing expression");
576 if (!condExpr->isTypeDependent()) {
577 DefaultFunctionArrayConversion(condExpr);
579 QualType condType = condExpr->getType();
581 if (getLangOptions().CPlusPlus) {
582 if (CheckCXXBooleanCondition(condExpr)) // C++ 6.4p4
584 } else if (!condType->isScalarType()) // C99 6.8.5p2
585 return StmtError(Diag(DoLoc,
586 diag::err_typecheck_statement_requires_scalar)
587 << condType << condExpr->getSourceRange());
591 return Owned(new (Context) DoStmt(Body.takeAs<Stmt>(), condExpr, DoLoc,
592 WhileLoc, CondRParen));
595 Action::OwningStmtResult
596 Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
597 StmtArg first, ExprArg second, ExprArg third,
598 SourceLocation RParenLoc, StmtArg body) {
599 Stmt *First = static_cast<Stmt*>(first.get());
600 Expr *Second = static_cast<Expr*>(second.get());
601 Expr *Third = static_cast<Expr*>(third.get());
602 Stmt *Body = static_cast<Stmt*>(body.get());
604 if (!getLangOptions().CPlusPlus) {
605 if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
606 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
607 // declare identifiers for objects having storage class 'auto' or
609 for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
611 VarDecl *VD = dyn_cast<VarDecl>(*DI);
612 if (VD && VD->isBlockVarDecl() && !VD->hasLocalStorage())
615 Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
616 // FIXME: mark decl erroneous!
620 if (Second && !Second->isTypeDependent()) {
621 DefaultFunctionArrayConversion(Second);
622 QualType SecondType = Second->getType();
624 if (getLangOptions().CPlusPlus) {
625 if (CheckCXXBooleanCondition(Second)) // C++ 6.4p4
627 } else if (!SecondType->isScalarType()) // C99 6.8.5p2
628 return StmtError(Diag(ForLoc,
629 diag::err_typecheck_statement_requires_scalar)
630 << SecondType << Second->getSourceRange());
636 return Owned(new (Context) ForStmt(First, Second, Third, Body, ForLoc,
637 LParenLoc, RParenLoc));
640 Action::OwningStmtResult
641 Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
642 SourceLocation LParenLoc,
643 StmtArg first, ExprArg second,
644 SourceLocation RParenLoc, StmtArg body) {
645 Stmt *First = static_cast<Stmt*>(first.get());
646 Expr *Second = static_cast<Expr*>(second.get());
647 Stmt *Body = static_cast<Stmt*>(body.get());
650 if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
651 if (!DS->isSingleDecl())
652 return StmtError(Diag((*DS->decl_begin())->getLocation(),
653 diag::err_toomany_element_decls));
655 Decl *D = DS->getSingleDecl();
656 FirstType = cast<ValueDecl>(D)->getType();
657 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
658 // declare identifiers for objects having storage class 'auto' or
660 VarDecl *VD = cast<VarDecl>(D);
661 if (VD->isBlockVarDecl() && !VD->hasLocalStorage())
662 return StmtError(Diag(VD->getLocation(),
663 diag::err_non_variable_decl_in_for));
665 if (cast<Expr>(First)->isLvalue(Context) != Expr::LV_Valid)
666 return StmtError(Diag(First->getLocStart(),
667 diag::err_selector_element_not_lvalue)
668 << First->getSourceRange());
670 FirstType = static_cast<Expr*>(First)->getType();
672 if (!Context.isObjCObjectPointerType(FirstType))
673 Diag(ForLoc, diag::err_selector_element_type)
674 << FirstType << First->getSourceRange();
677 DefaultFunctionArrayConversion(Second);
678 QualType SecondType = Second->getType();
679 if (!Context.isObjCObjectPointerType(SecondType))
680 Diag(ForLoc, diag::err_collection_expr_type)
681 << SecondType << Second->getSourceRange();
686 return Owned(new (Context) ObjCForCollectionStmt(First, Second, Body,
690 Action::OwningStmtResult
691 Sema::ActOnGotoStmt(SourceLocation GotoLoc, SourceLocation LabelLoc,
692 IdentifierInfo *LabelII) {
693 // If we are in a block, reject all gotos for now.
695 return StmtError(Diag(GotoLoc, diag::err_goto_in_block));
697 // Look up the record for this label identifier.
698 LabelStmt *&LabelDecl = getLabelMap()[LabelII];
700 // If we haven't seen this label yet, create a forward reference.
702 LabelDecl = new (Context) LabelStmt(LabelLoc, LabelII, 0);
704 return Owned(new (Context) GotoStmt(LabelDecl, GotoLoc, LabelLoc));
707 Action::OwningStmtResult
708 Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
710 // Convert operand to void*
711 Expr* E = DestExp.takeAs<Expr>();
712 if (!E->isTypeDependent()) {
713 QualType ETy = E->getType();
714 AssignConvertType ConvTy =
715 CheckSingleAssignmentConstraints(Context.VoidPtrTy, E);
716 if (DiagnoseAssignmentResult(ConvTy, StarLoc, Context.VoidPtrTy, ETy,
720 return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
723 Action::OwningStmtResult
724 Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
725 Scope *S = CurScope->getContinueParent();
727 // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
728 return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
731 return Owned(new (Context) ContinueStmt(ContinueLoc));
734 Action::OwningStmtResult
735 Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
736 Scope *S = CurScope->getBreakParent();
738 // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
739 return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
742 return Owned(new (Context) BreakStmt(BreakLoc));
745 /// ActOnBlockReturnStmt - Utility routine to figure out block's return type.
747 Action::OwningStmtResult
748 Sema::ActOnBlockReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
749 // If this is the first return we've seen in the block, infer the type of
750 // the block from it.
751 if (CurBlock->ReturnType.isNull()) {
753 // Don't call UsualUnaryConversions(), since we don't want to do
754 // integer promotions here.
755 DefaultFunctionArrayConversion(RetValExp);
756 CurBlock->ReturnType = RetValExp->getType();
757 if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(RetValExp)) {
758 // We have to remove a 'const' added to copied-in variable which was
759 // part of the implementation spec. and not the actual qualifier for
761 if (CDRE->isConstQualAdded())
762 CurBlock->ReturnType.removeConst();
765 CurBlock->ReturnType = Context.VoidTy;
767 QualType FnRetType = CurBlock->ReturnType;
769 if (CurBlock->TheDecl->hasAttr<NoReturnAttr>()) {
770 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr)
771 << getCurFunctionOrMethodDecl()->getDeclName();
775 // Otherwise, verify that this result type matches the previous one. We are
776 // pickier with blocks than for normal functions because we don't have GCC
777 // compatibility to worry about here.
778 if (CurBlock->ReturnType->isVoidType()) {
780 Diag(ReturnLoc, diag::err_return_block_has_expr);
781 RetValExp->Destroy(Context);
784 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
788 return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
790 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
791 // we have a non-void block with an expression, continue checking
792 QualType RetValType = RetValExp->getType();
794 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
795 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
798 // In C++ the return statement is handled via a copy initialization.
799 // the C version of which boils down to CheckSingleAssignmentConstraints.
800 // FIXME: Leaks RetValExp.
801 if (PerformCopyInitialization(RetValExp, FnRetType, "returning"))
804 if (RetValExp) CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
807 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
810 /// IsReturnCopyElidable - Whether returning @p RetExpr from a function that
811 /// returns a @p RetType fulfills the criteria for copy elision (C++0x 12.8p15).
812 static bool IsReturnCopyElidable(ASTContext &Ctx, QualType RetType,
814 QualType ExprType = RetExpr->getType();
815 // - in a return statement in a function with ...
816 // ... a class return type ...
817 if (!RetType->isRecordType())
819 // ... the same cv-unqualified type as the function return type ...
820 if (Ctx.getCanonicalType(RetType).getUnqualifiedType() !=
821 Ctx.getCanonicalType(ExprType).getUnqualifiedType())
823 // ... the expression is the name of a non-volatile automatic object ...
824 // We ignore parentheses here.
825 // FIXME: Is this compliant?
826 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(RetExpr->IgnoreParens());
829 const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
832 return VD->hasLocalStorage() && !VD->getType()->isReferenceType()
833 && !VD->getType().isVolatileQualified();
836 Action::OwningStmtResult
837 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, FullExprArg rex) {
838 Expr *RetValExp = rex->takeAs<Expr>();
840 return ActOnBlockReturnStmt(ReturnLoc, RetValExp);
843 if (const FunctionDecl *FD = getCurFunctionDecl()) {
844 FnRetType = FD->getResultType();
845 if (FD->hasAttr<NoReturnAttr>())
846 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
847 << getCurFunctionOrMethodDecl()->getDeclName();
848 } else if (ObjCMethodDecl *MD = getCurMethodDecl())
849 FnRetType = MD->getResultType();
850 else // If we don't have a function/method context, bail.
853 if (FnRetType->isVoidType()) {
854 if (RetValExp) {// C99 6.8.6.4p1 (ext_ since GCC warns)
855 unsigned D = diag::ext_return_has_expr;
856 if (RetValExp->getType()->isVoidType())
857 D = diag::ext_return_has_void_expr;
859 // return (some void expression); is legal in C++.
860 if (D != diag::ext_return_has_void_expr ||
861 !getLangOptions().CPlusPlus) {
862 NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
864 << CurDecl->getDeclName() << isa<ObjCMethodDecl>(CurDecl)
865 << RetValExp->getSourceRange();
868 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
871 if (!RetValExp && !FnRetType->isDependentType()) {
872 unsigned DiagID = diag::warn_return_missing_expr; // C90 6.6.6.4p4
873 // C99 6.8.6.4p1 (ext_ since GCC warns)
874 if (getLangOptions().C99) DiagID = diag::ext_return_missing_expr;
876 if (FunctionDecl *FD = getCurFunctionDecl())
877 Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
879 Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
880 return Owned(new (Context) ReturnStmt(ReturnLoc, (Expr*)0));
883 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
884 // we have a non-void function with an expression, continue checking
886 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
887 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
890 // C++0x 12.8p15: When certain criteria are met, an implementation is
891 // allowed to omit the copy construction of a class object, [...]
892 // - in a return statement in a function with a class return type, when
893 // the expression is the name of a non-volatile automatic object with
894 // the same cv-unqualified type as the function return type, the copy
895 // operation can be omitted [...]
896 // C++0x 12.8p16: When the criteria for elision of a copy operation are met
897 // and the object to be copied is designated by an lvalue, overload
898 // resolution to select the constructor for the copy is first performed
899 // as if the object were designated by an rvalue.
900 // Note that we only compute Elidable if we're in C++0x, since we don't
902 bool Elidable = getLangOptions().CPlusPlus0x ?
903 IsReturnCopyElidable(Context, FnRetType, RetValExp) :
906 // In C++ the return statement is handled via a copy initialization.
907 // the C version of which boils down to CheckSingleAssignmentConstraints.
908 // FIXME: Leaks RetValExp on error.
909 if (PerformCopyInitialization(RetValExp, FnRetType, "returning", Elidable))
912 if (RetValExp) CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
915 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
918 /// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
919 /// ignore "noop" casts in places where an lvalue is required by an inline asm.
920 /// We emulate this behavior when -fheinous-gnu-extensions is specified, but
921 /// provide a strong guidance to not use it.
923 /// This method checks to see if the argument is an acceptable l-value and
924 /// returns false if it is a case we can handle.
925 static bool CheckAsmLValue(const Expr *E, Sema &S) {
926 if (E->isLvalue(S.Context) == Expr::LV_Valid)
927 return false; // Cool, this is an lvalue.
929 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
930 // are supposed to allow.
931 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
932 if (E != E2 && E2->isLvalue(S.Context) == Expr::LV_Valid) {
933 if (!S.getLangOptions().HeinousExtensions)
934 S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
935 << E->getSourceRange();
937 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
938 << E->getSourceRange();
939 // Accept, even if we emitted an error diagnostic.
943 // None of the above, just randomly invalid non-lvalue.
948 Sema::OwningStmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc,
954 MultiExprArg constraints,
957 MultiExprArg clobbers,
958 SourceLocation RParenLoc) {
959 unsigned NumClobbers = clobbers.size();
960 StringLiteral **Constraints =
961 reinterpret_cast<StringLiteral**>(constraints.get());
962 Expr **Exprs = reinterpret_cast<Expr **>(exprs.get());
963 StringLiteral *AsmString = cast<StringLiteral>((Expr *)asmString.get());
964 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
966 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
968 // The parser verifies that there is a string literal here.
969 if (AsmString->isWide())
970 return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
971 << AsmString->getSourceRange());
973 for (unsigned i = 0; i != NumOutputs; i++) {
974 StringLiteral *Literal = Constraints[i];
975 if (Literal->isWide())
976 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
977 << Literal->getSourceRange());
979 TargetInfo::ConstraintInfo Info(Literal->getStrData(),
980 Literal->getByteLength(),
982 if (!Context.Target.validateOutputConstraint(Info))
983 return StmtError(Diag(Literal->getLocStart(),
984 diag::err_asm_invalid_output_constraint)
985 << Info.getConstraintStr());
987 // Check that the output exprs are valid lvalues.
988 Expr *OutputExpr = Exprs[i];
989 if (CheckAsmLValue(OutputExpr, *this)) {
990 return StmtError(Diag(OutputExpr->getLocStart(),
991 diag::err_asm_invalid_lvalue_in_output)
992 << OutputExpr->getSourceRange());
995 OutputConstraintInfos.push_back(Info);
998 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
1000 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
1001 StringLiteral *Literal = Constraints[i];
1002 if (Literal->isWide())
1003 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1004 << Literal->getSourceRange());
1006 TargetInfo::ConstraintInfo Info(Literal->getStrData(),
1007 Literal->getByteLength(),
1009 if (!Context.Target.validateInputConstraint(OutputConstraintInfos.data(),
1010 NumOutputs, Info)) {
1011 return StmtError(Diag(Literal->getLocStart(),
1012 diag::err_asm_invalid_input_constraint)
1013 << Info.getConstraintStr());
1016 Expr *InputExpr = Exprs[i];
1018 // Only allow void types for memory constraints.
1019 if (Info.allowsMemory() && !Info.allowsRegister()) {
1020 if (CheckAsmLValue(InputExpr, *this))
1021 return StmtError(Diag(InputExpr->getLocStart(),
1022 diag::err_asm_invalid_lvalue_in_input)
1023 << Info.getConstraintStr()
1024 << InputExpr->getSourceRange());
1027 if (Info.allowsRegister()) {
1028 if (InputExpr->getType()->isVoidType()) {
1029 return StmtError(Diag(InputExpr->getLocStart(),
1030 diag::err_asm_invalid_type_in_input)
1031 << InputExpr->getType() << Info.getConstraintStr()
1032 << InputExpr->getSourceRange());
1036 DefaultFunctionArrayConversion(Exprs[i]);
1038 InputConstraintInfos.push_back(Info);
1041 // Check that the clobbers are valid.
1042 for (unsigned i = 0; i != NumClobbers; i++) {
1043 StringLiteral *Literal = Clobbers[i];
1044 if (Literal->isWide())
1045 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1046 << Literal->getSourceRange());
1048 llvm::SmallString<16> Clobber(Literal->getStrData(),
1049 Literal->getStrData() +
1050 Literal->getByteLength());
1052 if (!Context.Target.isValidGCCRegisterName(Clobber.c_str()))
1053 return StmtError(Diag(Literal->getLocStart(),
1054 diag::err_asm_unknown_register_name) << Clobber.c_str());
1057 constraints.release();
1059 asmString.release();
1062 new (Context) AsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs, NumInputs,
1063 Names, Constraints, Exprs, AsmString, NumClobbers,
1064 Clobbers, RParenLoc);
1065 // Validate the asm string, ensuring it makes sense given the operands we
1067 llvm::SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
1069 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
1070 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
1071 << AsmString->getSourceRange();
1076 // Validate tied input operands for type mismatches.
1077 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
1078 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1080 // If this is a tied constraint, verify that the output and input have
1081 // either exactly the same type, or that they are int/ptr operands with the
1082 // same size (int/long, int*/long, are ok etc).
1083 if (!Info.hasTiedOperand()) continue;
1085 unsigned TiedTo = Info.getTiedOperand();
1086 Expr *OutputExpr = Exprs[TiedTo];
1087 Expr *InputExpr = Exprs[i+NumOutputs];
1088 QualType InTy = InputExpr->getType();
1089 QualType OutTy = OutputExpr->getType();
1090 if (Context.hasSameType(InTy, OutTy))
1091 continue; // All types can be tied to themselves.
1093 // Int/ptr operands have some special cases that we allow.
1094 if ((OutTy->isIntegerType() || OutTy->isPointerType()) &&
1095 (InTy->isIntegerType() || InTy->isPointerType())) {
1097 // They are ok if they are the same size. Tying void* to int is ok if
1098 // they are the same size, for example. This also allows tying void* to
1100 uint64_t OutSize = Context.getTypeSize(OutTy);
1101 uint64_t InSize = Context.getTypeSize(InTy);
1102 if (OutSize == InSize)
1105 // If the smaller input/output operand is not mentioned in the asm string,
1106 // then we can promote it and the asm string won't notice. Check this
1108 bool SmallerValueMentioned = false;
1109 for (unsigned p = 0, e = Pieces.size(); p != e; ++p) {
1110 AsmStmt::AsmStringPiece &Piece = Pieces[p];
1111 if (!Piece.isOperand()) continue;
1113 // If this is a reference to the input and if the input was the smaller
1114 // one, then we have to reject this asm.
1115 if (Piece.getOperandNo() == i+NumOutputs) {
1116 if (InSize < OutSize) {
1117 SmallerValueMentioned = true;
1122 // If this is a reference to the input and if the input was the smaller
1123 // one, then we have to reject this asm.
1124 if (Piece.getOperandNo() == TiedTo) {
1125 if (InSize > OutSize) {
1126 SmallerValueMentioned = true;
1132 // If the smaller value wasn't mentioned in the asm string, and if the
1133 // output was a register, just extend the shorter one to the size of the
1135 if (!SmallerValueMentioned &&
1136 OutputConstraintInfos[TiedTo].allowsRegister())
1140 Diag(InputExpr->getLocStart(),
1141 diag::err_asm_tying_incompatible_types)
1142 << InTy << OutTy << OutputExpr->getSourceRange()
1143 << InputExpr->getSourceRange();
1151 Action::OwningStmtResult
1152 Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1153 SourceLocation RParen, DeclPtrTy Parm,
1154 StmtArg Body, StmtArg catchList) {
1155 Stmt *CatchList = catchList.takeAs<Stmt>();
1156 ParmVarDecl *PVD = cast_or_null<ParmVarDecl>(Parm.getAs<Decl>());
1158 // PVD == 0 implies @catch(...).
1160 // If we already know the decl is invalid, reject it.
1161 if (PVD->isInvalidDecl())
1164 if (!Context.isObjCObjectPointerType(PVD->getType()))
1165 return StmtError(Diag(PVD->getLocation(),
1166 diag::err_catch_param_not_objc_type));
1167 if (PVD->getType()->isObjCQualifiedIdType())
1168 return StmtError(Diag(PVD->getLocation(),
1169 diag::err_illegal_qualifiers_on_catch_parm));
1172 ObjCAtCatchStmt *CS = new (Context) ObjCAtCatchStmt(AtLoc, RParen,
1173 PVD, Body.takeAs<Stmt>(), CatchList);
1174 return Owned(CatchList ? CatchList : CS);
1177 Action::OwningStmtResult
1178 Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, StmtArg Body) {
1179 return Owned(new (Context) ObjCAtFinallyStmt(AtLoc,
1180 static_cast<Stmt*>(Body.release())));
1183 Action::OwningStmtResult
1184 Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc,
1185 StmtArg Try, StmtArg Catch, StmtArg Finally) {
1186 CurFunctionNeedsScopeChecking = true;
1187 return Owned(new (Context) ObjCAtTryStmt(AtLoc, Try.takeAs<Stmt>(),
1188 Catch.takeAs<Stmt>(),
1189 Finally.takeAs<Stmt>()));
1192 Action::OwningStmtResult
1193 Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, ExprArg expr,Scope *CurScope) {
1194 Expr *ThrowExpr = expr.takeAs<Expr>();
1196 // @throw without an expression designates a rethrow (which much occur
1197 // in the context of an @catch clause).
1198 Scope *AtCatchParent = CurScope;
1199 while (AtCatchParent && !AtCatchParent->isAtCatchScope())
1200 AtCatchParent = AtCatchParent->getParent();
1202 return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
1204 QualType ThrowType = ThrowExpr->getType();
1205 // Make sure the expression type is an ObjC pointer or "void *".
1206 if (!Context.isObjCObjectPointerType(ThrowType)) {
1207 const PointerType *PT = ThrowType->getAsPointerType();
1208 if (!PT || !PT->getPointeeType()->isVoidType())
1209 return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
1210 << ThrowExpr->getType() << ThrowExpr->getSourceRange());
1213 return Owned(new (Context) ObjCAtThrowStmt(AtLoc, ThrowExpr));
1216 Action::OwningStmtResult
1217 Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, ExprArg SynchExpr,
1218 StmtArg SynchBody) {
1219 CurFunctionNeedsScopeChecking = true;
1221 // Make sure the expression type is an ObjC pointer or "void *".
1222 Expr *SyncExpr = static_cast<Expr*>(SynchExpr.get());
1223 if (!Context.isObjCObjectPointerType(SyncExpr->getType())) {
1224 const PointerType *PT = SyncExpr->getType()->getAsPointerType();
1225 if (!PT || !PT->getPointeeType()->isVoidType())
1226 return StmtError(Diag(AtLoc, diag::error_objc_synchronized_expects_object)
1227 << SyncExpr->getType() << SyncExpr->getSourceRange());
1230 return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc,
1231 SynchExpr.takeAs<Stmt>(),
1232 SynchBody.takeAs<Stmt>()));
1235 /// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
1236 /// and creates a proper catch handler from them.
1237 Action::OwningStmtResult
1238 Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, DeclPtrTy ExDecl,
1239 StmtArg HandlerBlock) {
1240 // There's nothing to test that ActOnExceptionDecl didn't already test.
1241 return Owned(new (Context) CXXCatchStmt(CatchLoc,
1242 cast_or_null<VarDecl>(ExDecl.getAs<Decl>()),
1243 HandlerBlock.takeAs<Stmt>()));
1246 /// ActOnCXXTryBlock - Takes a try compound-statement and a number of
1247 /// handlers and creates a try statement from them.
1248 Action::OwningStmtResult
1249 Sema::ActOnCXXTryBlock(SourceLocation TryLoc, StmtArg TryBlock,
1250 MultiStmtArg RawHandlers) {
1251 unsigned NumHandlers = RawHandlers.size();
1252 assert(NumHandlers > 0 &&
1253 "The parser shouldn't call this if there are no handlers.");
1254 Stmt **Handlers = reinterpret_cast<Stmt**>(RawHandlers.get());
1256 for(unsigned i = 0; i < NumHandlers - 1; ++i) {
1257 CXXCatchStmt *Handler = llvm::cast<CXXCatchStmt>(Handlers[i]);
1258 if (!Handler->getExceptionDecl())
1259 return StmtError(Diag(Handler->getLocStart(), diag::err_early_catch_all));
1261 // FIXME: We should detect handlers for the same type as an earlier one.
1262 // This one is rather easy.
1263 // FIXME: We should detect handlers that cannot catch anything because an
1264 // earlier handler catches a superclass. Need to find a method that is not
1265 // quadratic for this.
1266 // Neither of these are explicitly forbidden, but every compiler detects them
1269 CurFunctionNeedsScopeChecking = true;
1270 RawHandlers.release();
1271 return Owned(new (Context) CXXTryStmt(TryLoc,
1272 static_cast<Stmt*>(TryBlock.release()),
1273 Handlers, NumHandlers));