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 == 0) {
753 // Don't call UsualUnaryConversions(), since we don't want to do
754 // integer promotions here.
755 DefaultFunctionArrayConversion(RetValExp);
756 CurBlock->ReturnType = RetValExp->getType().getTypePtr();
758 CurBlock->ReturnType = Context.VoidTy.getTypePtr();
760 QualType FnRetType = QualType(CurBlock->ReturnType, 0);
762 if (CurBlock->TheDecl->hasAttr<NoReturnAttr>()) {
763 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr)
764 << getCurFunctionOrMethodDecl()->getDeclName();
768 // Otherwise, verify that this result type matches the previous one. We are
769 // pickier with blocks than for normal functions because we don't have GCC
770 // compatibility to worry about here.
771 if (CurBlock->ReturnType->isVoidType()) {
773 Diag(ReturnLoc, diag::err_return_block_has_expr);
774 RetValExp->Destroy(Context);
777 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
781 return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
783 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
784 // we have a non-void block with an expression, continue checking
785 QualType RetValType = RetValExp->getType();
787 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
788 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
791 // In C++ the return statement is handled via a copy initialization.
792 // the C version of which boils down to CheckSingleAssignmentConstraints.
793 // FIXME: Leaks RetValExp.
794 if (PerformCopyInitialization(RetValExp, FnRetType, "returning"))
797 if (RetValExp) CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
800 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
803 /// IsReturnCopyElidable - Whether returning @p RetExpr from a function that
804 /// returns a @p RetType fulfills the criteria for copy elision (C++0x 12.8p15).
805 static bool IsReturnCopyElidable(ASTContext &Ctx, QualType RetType,
807 QualType ExprType = RetExpr->getType();
808 // - in a return statement in a function with ...
809 // ... a class return type ...
810 if (!RetType->isRecordType())
812 // ... the same cv-unqualified type as the function return type ...
813 if (Ctx.getCanonicalType(RetType).getUnqualifiedType() !=
814 Ctx.getCanonicalType(ExprType).getUnqualifiedType())
816 // ... the expression is the name of a non-volatile automatic object ...
817 // We ignore parentheses here.
818 // FIXME: Is this compliant?
819 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(RetExpr->IgnoreParens());
822 const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
825 return VD->hasLocalStorage() && !VD->getType()->isReferenceType()
826 && !VD->getType().isVolatileQualified();
829 Action::OwningStmtResult
830 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, FullExprArg rex) {
831 Expr *RetValExp = rex->takeAs<Expr>();
833 return ActOnBlockReturnStmt(ReturnLoc, RetValExp);
836 if (const FunctionDecl *FD = getCurFunctionDecl()) {
837 FnRetType = FD->getResultType();
838 if (FD->hasAttr<NoReturnAttr>())
839 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
840 << getCurFunctionOrMethodDecl()->getDeclName();
841 } else if (ObjCMethodDecl *MD = getCurMethodDecl())
842 FnRetType = MD->getResultType();
843 else // If we don't have a function/method context, bail.
846 if (FnRetType->isVoidType()) {
847 if (RetValExp) {// C99 6.8.6.4p1 (ext_ since GCC warns)
848 unsigned D = diag::ext_return_has_expr;
849 if (RetValExp->getType()->isVoidType())
850 D = diag::ext_return_has_void_expr;
852 // return (some void expression); is legal in C++.
853 if (D != diag::ext_return_has_void_expr ||
854 !getLangOptions().CPlusPlus) {
855 NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
857 << CurDecl->getDeclName() << isa<ObjCMethodDecl>(CurDecl)
858 << RetValExp->getSourceRange();
861 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
864 if (!RetValExp && !FnRetType->isDependentType()) {
865 unsigned DiagID = diag::warn_return_missing_expr; // C90 6.6.6.4p4
866 // C99 6.8.6.4p1 (ext_ since GCC warns)
867 if (getLangOptions().C99) DiagID = diag::ext_return_missing_expr;
869 if (FunctionDecl *FD = getCurFunctionDecl())
870 Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
872 Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
873 return Owned(new (Context) ReturnStmt(ReturnLoc, (Expr*)0));
876 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
877 // we have a non-void function with an expression, continue checking
879 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
880 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
883 // C++0x 12.8p15: When certain criteria are met, an implementation is
884 // allowed to omit the copy construction of a class object, [...]
885 // - in a return statement in a function with a class return type, when
886 // the expression is the name of a non-volatile automatic object with
887 // the same cv-unqualified type as the function return type, the copy
888 // operation can be omitted [...]
889 // C++0x 12.8p16: When the criteria for elision of a copy operation are met
890 // and the object to be copied is designated by an lvalue, overload
891 // resolution to select the constructor for the copy is first performed
892 // as if the object were designated by an rvalue.
893 // Note that we only compute Elidable if we're in C++0x, since we don't
895 bool Elidable = getLangOptions().CPlusPlus0x ?
896 IsReturnCopyElidable(Context, FnRetType, RetValExp) :
899 // In C++ the return statement is handled via a copy initialization.
900 // the C version of which boils down to CheckSingleAssignmentConstraints.
901 // FIXME: Leaks RetValExp on error.
902 if (PerformCopyInitialization(RetValExp, FnRetType, "returning", Elidable))
905 if (RetValExp) CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
908 return Owned(new (Context) ReturnStmt(ReturnLoc, RetValExp));
911 /// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
912 /// ignore "noop" casts in places where an lvalue is required by an inline asm.
913 /// We emulate this behavior when -fheinous-gnu-extensions is specified, but
914 /// provide a strong guidance to not use it.
916 /// This method checks to see if the argument is an acceptable l-value and
917 /// returns false if it is a case we can handle.
918 static bool CheckAsmLValue(const Expr *E, Sema &S) {
919 if (E->isLvalue(S.Context) == Expr::LV_Valid)
920 return false; // Cool, this is an lvalue.
922 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
923 // are supposed to allow.
924 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
925 if (E != E2 && E2->isLvalue(S.Context) == Expr::LV_Valid) {
926 if (!S.getLangOptions().HeinousExtensions)
927 S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
928 << E->getSourceRange();
930 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
931 << E->getSourceRange();
932 // Accept, even if we emitted an error diagnostic.
936 // None of the above, just randomly invalid non-lvalue.
941 Sema::OwningStmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc,
947 MultiExprArg constraints,
950 MultiExprArg clobbers,
951 SourceLocation RParenLoc) {
952 unsigned NumClobbers = clobbers.size();
953 StringLiteral **Constraints =
954 reinterpret_cast<StringLiteral**>(constraints.get());
955 Expr **Exprs = reinterpret_cast<Expr **>(exprs.get());
956 StringLiteral *AsmString = cast<StringLiteral>((Expr *)asmString.get());
957 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
959 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
961 // The parser verifies that there is a string literal here.
962 if (AsmString->isWide())
963 return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
964 << AsmString->getSourceRange());
966 for (unsigned i = 0; i != NumOutputs; i++) {
967 StringLiteral *Literal = Constraints[i];
968 if (Literal->isWide())
969 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
970 << Literal->getSourceRange());
972 TargetInfo::ConstraintInfo Info(Literal->getStrData(),
973 Literal->getByteLength(),
975 if (!Context.Target.validateOutputConstraint(Info))
976 return StmtError(Diag(Literal->getLocStart(),
977 diag::err_asm_invalid_output_constraint)
978 << Info.getConstraintStr());
980 // Check that the output exprs are valid lvalues.
981 Expr *OutputExpr = Exprs[i];
982 if (CheckAsmLValue(OutputExpr, *this)) {
983 return StmtError(Diag(OutputExpr->getLocStart(),
984 diag::err_asm_invalid_lvalue_in_output)
985 << OutputExpr->getSourceRange());
988 OutputConstraintInfos.push_back(Info);
991 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
993 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
994 StringLiteral *Literal = Constraints[i];
995 if (Literal->isWide())
996 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
997 << Literal->getSourceRange());
999 TargetInfo::ConstraintInfo Info(Literal->getStrData(),
1000 Literal->getByteLength(),
1002 if (!Context.Target.validateInputConstraint(OutputConstraintInfos.data(),
1003 NumOutputs, Info)) {
1004 return StmtError(Diag(Literal->getLocStart(),
1005 diag::err_asm_invalid_input_constraint)
1006 << Info.getConstraintStr());
1009 Expr *InputExpr = Exprs[i];
1011 // Only allow void types for memory constraints.
1012 if (Info.allowsMemory() && !Info.allowsRegister()) {
1013 if (CheckAsmLValue(InputExpr, *this))
1014 return StmtError(Diag(InputExpr->getLocStart(),
1015 diag::err_asm_invalid_lvalue_in_input)
1016 << Info.getConstraintStr()
1017 << InputExpr->getSourceRange());
1020 if (Info.allowsRegister()) {
1021 if (InputExpr->getType()->isVoidType()) {
1022 return StmtError(Diag(InputExpr->getLocStart(),
1023 diag::err_asm_invalid_type_in_input)
1024 << InputExpr->getType() << Info.getConstraintStr()
1025 << InputExpr->getSourceRange());
1029 DefaultFunctionArrayConversion(Exprs[i]);
1031 InputConstraintInfos.push_back(Info);
1034 // Check that the clobbers are valid.
1035 for (unsigned i = 0; i != NumClobbers; i++) {
1036 StringLiteral *Literal = Clobbers[i];
1037 if (Literal->isWide())
1038 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1039 << Literal->getSourceRange());
1041 llvm::SmallString<16> Clobber(Literal->getStrData(),
1042 Literal->getStrData() +
1043 Literal->getByteLength());
1045 if (!Context.Target.isValidGCCRegisterName(Clobber.c_str()))
1046 return StmtError(Diag(Literal->getLocStart(),
1047 diag::err_asm_unknown_register_name) << Clobber.c_str());
1050 constraints.release();
1052 asmString.release();
1055 new (Context) AsmStmt(AsmLoc, IsSimple, IsVolatile, NumOutputs, NumInputs,
1056 Names, Constraints, Exprs, AsmString, NumClobbers,
1057 Clobbers, RParenLoc);
1058 // Validate the asm string, ensuring it makes sense given the operands we
1060 llvm::SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
1062 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
1063 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
1064 << AsmString->getSourceRange();
1069 // Validate tied input operands for type mismatches.
1070 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
1071 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1073 // If this is a tied constraint, verify that the output and input have
1074 // either exactly the same type, or that they are int/ptr operands with the
1075 // same size (int/long, int*/long, are ok etc).
1076 if (!Info.hasTiedOperand()) continue;
1078 unsigned TiedTo = Info.getTiedOperand();
1079 Expr *OutputExpr = Exprs[TiedTo];
1080 Expr *InputExpr = Exprs[i+NumOutputs];
1081 QualType InTy = InputExpr->getType();
1082 QualType OutTy = OutputExpr->getType();
1083 if (Context.hasSameType(InTy, OutTy))
1084 continue; // All types can be tied to themselves.
1086 // Int/ptr operands have some special cases that we allow.
1087 if ((OutTy->isIntegerType() || OutTy->isPointerType()) &&
1088 (InTy->isIntegerType() || InTy->isPointerType())) {
1090 // They are ok if they are the same size. Tying void* to int is ok if
1091 // they are the same size, for example. This also allows tying void* to
1093 uint64_t OutSize = Context.getTypeSize(OutTy);
1094 uint64_t InSize = Context.getTypeSize(InTy);
1095 if (OutSize == InSize)
1098 // If the smaller input/output operand is not mentioned in the asm string,
1099 // then we can promote it and the asm string won't notice. Check this
1101 bool SmallerValueMentioned = false;
1102 for (unsigned p = 0, e = Pieces.size(); p != e; ++p) {
1103 AsmStmt::AsmStringPiece &Piece = Pieces[p];
1104 if (!Piece.isOperand()) continue;
1106 // If this is a reference to the input and if the input was the smaller
1107 // one, then we have to reject this asm.
1108 if (Piece.getOperandNo() == i+NumOutputs) {
1109 if (InSize < OutSize) {
1110 SmallerValueMentioned = true;
1115 // If this is a reference to the input and if the input was the smaller
1116 // one, then we have to reject this asm.
1117 if (Piece.getOperandNo() == TiedTo) {
1118 if (InSize > OutSize) {
1119 SmallerValueMentioned = true;
1125 // If the smaller value wasn't mentioned in the asm string, and if the
1126 // output was a register, just extend the shorter one to the size of the
1128 if (!SmallerValueMentioned &&
1129 OutputConstraintInfos[TiedTo].allowsRegister())
1133 Diag(InputExpr->getLocStart(),
1134 diag::err_asm_tying_incompatible_types)
1135 << InTy << OutTy << OutputExpr->getSourceRange()
1136 << InputExpr->getSourceRange();
1144 Action::OwningStmtResult
1145 Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1146 SourceLocation RParen, DeclPtrTy Parm,
1147 StmtArg Body, StmtArg catchList) {
1148 Stmt *CatchList = catchList.takeAs<Stmt>();
1149 ParmVarDecl *PVD = cast_or_null<ParmVarDecl>(Parm.getAs<Decl>());
1151 // PVD == 0 implies @catch(...).
1153 // If we already know the decl is invalid, reject it.
1154 if (PVD->isInvalidDecl())
1157 if (!Context.isObjCObjectPointerType(PVD->getType()))
1158 return StmtError(Diag(PVD->getLocation(),
1159 diag::err_catch_param_not_objc_type));
1160 if (PVD->getType()->isObjCQualifiedIdType())
1161 return StmtError(Diag(PVD->getLocation(),
1162 diag::err_illegal_qualifiers_on_catch_parm));
1165 ObjCAtCatchStmt *CS = new (Context) ObjCAtCatchStmt(AtLoc, RParen,
1166 PVD, Body.takeAs<Stmt>(), CatchList);
1167 return Owned(CatchList ? CatchList : CS);
1170 Action::OwningStmtResult
1171 Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, StmtArg Body) {
1172 return Owned(new (Context) ObjCAtFinallyStmt(AtLoc,
1173 static_cast<Stmt*>(Body.release())));
1176 Action::OwningStmtResult
1177 Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc,
1178 StmtArg Try, StmtArg Catch, StmtArg Finally) {
1179 CurFunctionNeedsScopeChecking = true;
1180 return Owned(new (Context) ObjCAtTryStmt(AtLoc, Try.takeAs<Stmt>(),
1181 Catch.takeAs<Stmt>(),
1182 Finally.takeAs<Stmt>()));
1185 Action::OwningStmtResult
1186 Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, ExprArg expr,Scope *CurScope) {
1187 Expr *ThrowExpr = expr.takeAs<Expr>();
1189 // @throw without an expression designates a rethrow (which much occur
1190 // in the context of an @catch clause).
1191 Scope *AtCatchParent = CurScope;
1192 while (AtCatchParent && !AtCatchParent->isAtCatchScope())
1193 AtCatchParent = AtCatchParent->getParent();
1195 return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
1197 QualType ThrowType = ThrowExpr->getType();
1198 // Make sure the expression type is an ObjC pointer or "void *".
1199 if (!Context.isObjCObjectPointerType(ThrowType)) {
1200 const PointerType *PT = ThrowType->getAsPointerType();
1201 if (!PT || !PT->getPointeeType()->isVoidType())
1202 return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
1203 << ThrowExpr->getType() << ThrowExpr->getSourceRange());
1206 return Owned(new (Context) ObjCAtThrowStmt(AtLoc, ThrowExpr));
1209 Action::OwningStmtResult
1210 Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, ExprArg SynchExpr,
1211 StmtArg SynchBody) {
1212 CurFunctionNeedsScopeChecking = true;
1214 // Make sure the expression type is an ObjC pointer or "void *".
1215 Expr *SyncExpr = static_cast<Expr*>(SynchExpr.get());
1216 if (!Context.isObjCObjectPointerType(SyncExpr->getType())) {
1217 const PointerType *PT = SyncExpr->getType()->getAsPointerType();
1218 if (!PT || !PT->getPointeeType()->isVoidType())
1219 return StmtError(Diag(AtLoc, diag::error_objc_synchronized_expects_object)
1220 << SyncExpr->getType() << SyncExpr->getSourceRange());
1223 return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc,
1224 SynchExpr.takeAs<Stmt>(),
1225 SynchBody.takeAs<Stmt>()));
1228 /// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
1229 /// and creates a proper catch handler from them.
1230 Action::OwningStmtResult
1231 Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, DeclPtrTy ExDecl,
1232 StmtArg HandlerBlock) {
1233 // There's nothing to test that ActOnExceptionDecl didn't already test.
1234 return Owned(new (Context) CXXCatchStmt(CatchLoc,
1235 cast_or_null<VarDecl>(ExDecl.getAs<Decl>()),
1236 HandlerBlock.takeAs<Stmt>()));
1239 /// ActOnCXXTryBlock - Takes a try compound-statement and a number of
1240 /// handlers and creates a try statement from them.
1241 Action::OwningStmtResult
1242 Sema::ActOnCXXTryBlock(SourceLocation TryLoc, StmtArg TryBlock,
1243 MultiStmtArg RawHandlers) {
1244 unsigned NumHandlers = RawHandlers.size();
1245 assert(NumHandlers > 0 &&
1246 "The parser shouldn't call this if there are no handlers.");
1247 Stmt **Handlers = reinterpret_cast<Stmt**>(RawHandlers.get());
1249 for(unsigned i = 0; i < NumHandlers - 1; ++i) {
1250 CXXCatchStmt *Handler = llvm::cast<CXXCatchStmt>(Handlers[i]);
1251 if (!Handler->getExceptionDecl())
1252 return StmtError(Diag(Handler->getLocStart(), diag::err_early_catch_all));
1254 // FIXME: We should detect handlers for the same type as an earlier one.
1255 // This one is rather easy.
1256 // FIXME: We should detect handlers that cannot catch anything because an
1257 // earlier handler catches a superclass. Need to find a method that is not
1258 // quadratic for this.
1259 // Neither of these are explicitly forbidden, but every compiler detects them
1262 CurFunctionNeedsScopeChecking = true;
1263 RawHandlers.release();
1264 return Owned(new (Context) CXXTryStmt(TryLoc,
1265 static_cast<Stmt*>(TryBlock.release()),
1266 Handlers, NumHandlers));