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 //===----------------------------------------------------------------------===//
14 #include "clang/Sema/SemaInternal.h"
15 #include "clang/Sema/Scope.h"
16 #include "clang/Sema/ScopeInfo.h"
17 #include "clang/Sema/Initialization.h"
18 #include "clang/Sema/Lookup.h"
19 #include "clang/AST/APValue.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/ExprObjC.h"
24 #include "clang/AST/StmtObjC.h"
25 #include "clang/AST/StmtCXX.h"
26 #include "clang/AST/TypeLoc.h"
27 #include "clang/Lex/Preprocessor.h"
28 #include "clang/Basic/TargetInfo.h"
29 #include "llvm/ADT/ArrayRef.h"
30 #include "llvm/ADT/STLExtras.h"
31 #include "llvm/ADT/SmallVector.h"
32 using namespace clang;
35 StmtResult Sema::ActOnExprStmt(FullExprArg expr) {
37 if (!E) // FIXME: FullExprArg has no error state?
40 // C99 6.8.3p2: The expression in an expression statement is evaluated as a
41 // void expression for its side effects. Conversion to void allows any
42 // operand, even incomplete types.
44 // Same thing in for stmt first clause (when expr) and third clause.
45 return Owned(static_cast<Stmt*>(E));
49 StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
50 SourceLocation LeadingEmptyMacroLoc) {
51 return Owned(new (Context) NullStmt(SemiLoc, LeadingEmptyMacroLoc));
54 StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
55 SourceLocation EndLoc) {
56 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
58 // If we have an invalid decl, just return an error.
59 if (DG.isNull()) return StmtError();
61 return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
64 void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
65 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
67 // If we have an invalid decl, just return.
68 if (DG.isNull() || !DG.isSingleDecl()) return;
69 VarDecl *var = cast<VarDecl>(DG.getSingleDecl());
71 // suppress any potential 'unused variable' warning.
74 // foreach variables are never actually initialized in the way that
75 // the parser came up with.
78 // In ARC, we don't need to retain the iteration variable of a fast
79 // enumeration loop. Rather than actually trying to catch that
80 // during declaration processing, we remove the consequences here.
81 if (getLangOptions().ObjCAutoRefCount) {
82 QualType type = var->getType();
84 // Only do this if we inferred the lifetime. Inferred lifetime
85 // will show up as a local qualifier because explicit lifetime
86 // should have shown up as an AttributedType instead.
87 if (type.getLocalQualifiers().getObjCLifetime() == Qualifiers::OCL_Strong) {
88 // Add 'const' and mark the variable as pseudo-strong.
89 var->setType(type.withConst());
90 var->setARCPseudoStrong(true);
95 void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
96 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
97 return DiagnoseUnusedExprResult(Label->getSubStmt());
99 const Expr *E = dyn_cast_or_null<Expr>(S);
105 if (!E->isUnusedResultAWarning(Loc, R1, R2, Context))
108 // Okay, we have an unused result. Depending on what the base expression is,
109 // we might want to make a more specific diagnostic. Check for one of these
111 unsigned DiagID = diag::warn_unused_expr;
112 if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E))
113 E = Temps->getSubExpr();
114 if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
115 E = TempExpr->getSubExpr();
117 E = E->IgnoreParenImpCasts();
118 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
119 if (E->getType()->isVoidType())
122 // If the callee has attribute pure, const, or warn_unused_result, warn with
123 // a more specific message to make it clear what is happening.
124 if (const Decl *FD = CE->getCalleeDecl()) {
125 if (FD->getAttr<WarnUnusedResultAttr>()) {
126 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result";
129 if (FD->getAttr<PureAttr>()) {
130 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
133 if (FD->getAttr<ConstAttr>()) {
134 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
138 } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
139 if (getLangOptions().ObjCAutoRefCount && ME->isDelegateInitCall()) {
140 Diag(Loc, diag::err_arc_unused_init_message) << R1;
143 const ObjCMethodDecl *MD = ME->getMethodDecl();
144 if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
145 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result";
148 } else if (isa<ObjCPropertyRefExpr>(E)) {
149 DiagID = diag::warn_unused_property_expr;
150 } else if (const CXXFunctionalCastExpr *FC
151 = dyn_cast<CXXFunctionalCastExpr>(E)) {
152 if (isa<CXXConstructExpr>(FC->getSubExpr()) ||
153 isa<CXXTemporaryObjectExpr>(FC->getSubExpr()))
156 // Diagnose "(void*) blah" as a typo for "(void) blah".
157 else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
158 TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
159 QualType T = TI->getType();
161 // We really do want to use the non-canonical type here.
162 if (T == Context.VoidPtrTy) {
163 PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
165 Diag(Loc, diag::warn_unused_voidptr)
166 << FixItHint::CreateRemoval(TL.getStarLoc());
171 DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
175 Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
176 MultiStmtArg elts, bool isStmtExpr) {
177 unsigned NumElts = elts.size();
178 Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
179 // If we're in C89 mode, check that we don't have any decls after stmts. If
180 // so, emit an extension diagnostic.
181 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) {
182 // Note that __extension__ can be around a decl.
184 // Skip over all declarations.
185 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
188 // We found the end of the list or a statement. Scan for another declstmt.
189 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
193 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
194 Diag(D->getLocation(), diag::ext_mixed_decls_code);
197 // Warn about unused expressions in statements.
198 for (unsigned i = 0; i != NumElts; ++i) {
199 // Ignore statements that are last in a statement expression.
200 if (isStmtExpr && i == NumElts - 1)
203 DiagnoseUnusedExprResult(Elts[i]);
206 return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
210 Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
211 SourceLocation DotDotDotLoc, Expr *RHSVal,
212 SourceLocation ColonLoc) {
213 assert((LHSVal != 0) && "missing expression in case statement");
215 // C99 6.8.4.2p3: The expression shall be an integer constant.
216 // However, GCC allows any evaluatable integer expression.
217 if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent() &&
218 VerifyIntegerConstantExpression(LHSVal))
221 // GCC extension: The expression shall be an integer constant.
223 if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent() &&
224 VerifyIntegerConstantExpression(RHSVal)) {
225 RHSVal = 0; // Recover by just forgetting about it.
228 if (getCurFunction()->SwitchStack.empty()) {
229 Diag(CaseLoc, diag::err_case_not_in_switch);
233 CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
235 getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
239 /// ActOnCaseStmtBody - This installs a statement as the body of a case.
240 void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
241 CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
242 CS->setSubStmt(SubStmt);
246 Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
247 Stmt *SubStmt, Scope *CurScope) {
248 if (getCurFunction()->SwitchStack.empty()) {
249 Diag(DefaultLoc, diag::err_default_not_in_switch);
250 return Owned(SubStmt);
253 DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
254 getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
259 Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
260 SourceLocation ColonLoc, Stmt *SubStmt) {
262 // If the label was multiply defined, reject it now.
263 if (TheDecl->getStmt()) {
264 Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
265 Diag(TheDecl->getLocation(), diag::note_previous_definition);
266 return Owned(SubStmt);
269 // Otherwise, things are good. Fill in the declaration and return it.
270 LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
271 TheDecl->setStmt(LS);
272 if (!TheDecl->isGnuLocal())
273 TheDecl->setLocation(IdentLoc);
278 Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
279 Stmt *thenStmt, SourceLocation ElseLoc,
281 ExprResult CondResult(CondVal.release());
283 VarDecl *ConditionVar = 0;
285 ConditionVar = cast<VarDecl>(CondVar);
286 CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
287 if (CondResult.isInvalid())
290 Expr *ConditionExpr = CondResult.takeAs<Expr>();
294 DiagnoseUnusedExprResult(thenStmt);
296 // Warn if the if block has a null body without an else value.
297 // this helps prevent bugs due to typos, such as
302 if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt))
303 // But do not warn if the body is a macro that expands to nothing, e.g:
309 if (!stmt->hasLeadingEmptyMacro())
310 Diag(stmt->getSemiLoc(), diag::warn_empty_if_body);
313 DiagnoseUnusedExprResult(elseStmt);
315 return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
316 thenStmt, ElseLoc, elseStmt));
319 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
320 /// the specified width and sign. If an overflow occurs, detect it and emit
321 /// the specified diagnostic.
322 void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
323 unsigned NewWidth, bool NewSign,
326 // Perform a conversion to the promoted condition type if needed.
327 if (NewWidth > Val.getBitWidth()) {
328 // If this is an extension, just do it.
329 Val = Val.extend(NewWidth);
330 Val.setIsSigned(NewSign);
332 // If the input was signed and negative and the output is
333 // unsigned, don't bother to warn: this is implementation-defined
335 // FIXME: Introduce a second, default-ignored warning for this case?
336 } else if (NewWidth < Val.getBitWidth()) {
337 // If this is a truncation, check for overflow.
338 llvm::APSInt ConvVal(Val);
339 ConvVal = ConvVal.trunc(NewWidth);
340 ConvVal.setIsSigned(NewSign);
341 ConvVal = ConvVal.extend(Val.getBitWidth());
342 ConvVal.setIsSigned(Val.isSigned());
344 Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
346 // Regardless of whether a diagnostic was emitted, really do the
348 Val = Val.trunc(NewWidth);
349 Val.setIsSigned(NewSign);
350 } else if (NewSign != Val.isSigned()) {
351 // Convert the sign to match the sign of the condition. This can cause
352 // overflow as well: unsigned(INTMIN)
353 // We don't diagnose this overflow, because it is implementation-defined
355 // FIXME: Introduce a second, default-ignored warning for this case?
356 llvm::APSInt OldVal(Val);
357 Val.setIsSigned(NewSign);
362 struct CaseCompareFunctor {
363 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
364 const llvm::APSInt &RHS) {
365 return LHS.first < RHS;
367 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
368 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
369 return LHS.first < RHS.first;
371 bool operator()(const llvm::APSInt &LHS,
372 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
373 return LHS < RHS.first;
378 /// CmpCaseVals - Comparison predicate for sorting case values.
380 static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
381 const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
382 if (lhs.first < rhs.first)
385 if (lhs.first == rhs.first &&
386 lhs.second->getCaseLoc().getRawEncoding()
387 < rhs.second->getCaseLoc().getRawEncoding())
392 /// CmpEnumVals - Comparison predicate for sorting enumeration values.
394 static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
395 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
397 return lhs.first < rhs.first;
400 /// EqEnumVals - Comparison preficate for uniqing enumeration values.
402 static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
403 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
405 return lhs.first == rhs.first;
408 /// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
409 /// potentially integral-promoted expression @p expr.
410 static QualType GetTypeBeforeIntegralPromotion(const Expr* expr) {
411 if (const CastExpr *ImplicitCast = dyn_cast<ImplicitCastExpr>(expr)) {
412 const Expr *ExprBeforePromotion = ImplicitCast->getSubExpr();
413 QualType TypeBeforePromotion = ExprBeforePromotion->getType();
414 if (TypeBeforePromotion->isIntegralOrEnumerationType()) {
415 return TypeBeforePromotion;
418 return expr->getType();
422 Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
424 ExprResult CondResult;
426 VarDecl *ConditionVar = 0;
428 ConditionVar = cast<VarDecl>(CondVar);
429 CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
430 if (CondResult.isInvalid())
433 Cond = CondResult.release();
440 = ConvertToIntegralOrEnumerationType(SwitchLoc, Cond,
441 PDiag(diag::err_typecheck_statement_requires_integer),
442 PDiag(diag::err_switch_incomplete_class_type)
443 << Cond->getSourceRange(),
444 PDiag(diag::err_switch_explicit_conversion),
445 PDiag(diag::note_switch_conversion),
446 PDiag(diag::err_switch_multiple_conversions),
447 PDiag(diag::note_switch_conversion),
449 if (CondResult.isInvalid()) return StmtError();
450 Cond = CondResult.take();
453 CheckImplicitConversions(Cond, SwitchLoc);
454 CondResult = MaybeCreateExprWithCleanups(Cond);
455 if (CondResult.isInvalid())
457 Cond = CondResult.take();
460 getCurFunction()->setHasBranchIntoScope();
462 SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
463 getCurFunction()->SwitchStack.push_back(SS);
467 static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
468 if (Val.getBitWidth() < BitWidth)
469 Val = Val.extend(BitWidth);
470 else if (Val.getBitWidth() > BitWidth)
471 Val = Val.trunc(BitWidth);
472 Val.setIsSigned(IsSigned);
476 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
478 SwitchStmt *SS = cast<SwitchStmt>(Switch);
479 assert(SS == getCurFunction()->SwitchStack.back() &&
480 "switch stack missing push/pop!");
482 SS->setBody(BodyStmt, SwitchLoc);
483 getCurFunction()->SwitchStack.pop_back();
485 if (SS->getCond() == 0)
488 Expr *CondExpr = SS->getCond();
489 Expr *CondExprBeforePromotion = CondExpr;
490 QualType CondTypeBeforePromotion =
491 GetTypeBeforeIntegralPromotion(CondExpr);
493 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
494 ExprResult CondResult = UsualUnaryConversions(CondExpr);
495 if (CondResult.isInvalid())
497 CondExpr = CondResult.take();
498 QualType CondType = CondExpr->getType();
499 SS->setCond(CondExpr);
502 // Integral promotions are performed (on the switch condition).
504 // A case value unrepresentable by the original switch condition
505 // type (before the promotion) doesn't make sense, even when it can
506 // be represented by the promoted type. Therefore we need to find
507 // the pre-promotion type of the switch condition.
508 if (!CondExpr->isTypeDependent()) {
509 // We have already converted the expression to an integral or enumeration
510 // type, when we started the switch statement. If we don't have an
511 // appropriate type now, just return an error.
512 if (!CondType->isIntegralOrEnumerationType())
515 if (CondExpr->isKnownToHaveBooleanValue()) {
516 // switch(bool_expr) {...} is often a programmer error, e.g.
517 // switch(n && mask) { ... } // Doh - should be "n & mask".
518 // One can always use an if statement instead of switch(bool_expr).
519 Diag(SwitchLoc, diag::warn_bool_switch_condition)
520 << CondExpr->getSourceRange();
524 // Get the bitwidth of the switched-on value before promotions. We must
525 // convert the integer case values to this width before comparison.
526 bool HasDependentValue
527 = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
529 = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
531 = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
533 // Accumulate all of the case values in a vector so that we can sort them
534 // and detect duplicates. This vector contains the APInt for the case after
535 // it has been converted to the condition type.
536 typedef llvm::SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
539 // Keep track of any GNU case ranges we see. The APSInt is the low value.
540 typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
541 CaseRangesTy CaseRanges;
543 DefaultStmt *TheDefaultStmt = 0;
545 bool CaseListIsErroneous = false;
547 for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
548 SC = SC->getNextSwitchCase()) {
550 if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
551 if (TheDefaultStmt) {
552 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
553 Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
555 // FIXME: Remove the default statement from the switch block so that
556 // we'll return a valid AST. This requires recursing down the AST and
557 // finding it, not something we are set up to do right now. For now,
558 // just lop the entire switch stmt out of the AST.
559 CaseListIsErroneous = true;
564 CaseStmt *CS = cast<CaseStmt>(SC);
566 // We already verified that the expression has a i-c-e value (C99
567 // 6.8.4.2p3) - get that value now.
568 Expr *Lo = CS->getLHS();
570 if (Lo->isTypeDependent() || Lo->isValueDependent()) {
571 HasDependentValue = true;
575 llvm::APSInt LoVal = Lo->EvaluateAsInt(Context);
577 // Convert the value to the same width/sign as the condition.
578 ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
580 diag::warn_case_value_overflow);
582 // If the LHS is not the same type as the condition, insert an implicit
584 Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
587 // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
589 if (CS->getRHS()->isTypeDependent() ||
590 CS->getRHS()->isValueDependent()) {
591 HasDependentValue = true;
594 CaseRanges.push_back(std::make_pair(LoVal, CS));
596 CaseVals.push_back(std::make_pair(LoVal, CS));
600 if (!HasDependentValue) {
601 // If we don't have a default statement, check whether the
602 // condition is constant.
603 llvm::APSInt ConstantCondValue;
604 bool HasConstantCond = false;
605 bool ShouldCheckConstantCond = false;
606 if (!HasDependentValue && !TheDefaultStmt) {
607 Expr::EvalResult Result;
608 HasConstantCond = CondExprBeforePromotion->Evaluate(Result, Context);
609 if (HasConstantCond) {
610 assert(Result.Val.isInt() && "switch condition evaluated to non-int");
611 ConstantCondValue = Result.Val.getInt();
612 ShouldCheckConstantCond = true;
614 assert(ConstantCondValue.getBitWidth() == CondWidth &&
615 ConstantCondValue.isSigned() == CondIsSigned);
619 // Sort all the scalar case values so we can easily detect duplicates.
620 std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
622 if (!CaseVals.empty()) {
623 for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
624 if (ShouldCheckConstantCond &&
625 CaseVals[i].first == ConstantCondValue)
626 ShouldCheckConstantCond = false;
628 if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
629 // If we have a duplicate, report it.
630 Diag(CaseVals[i].second->getLHS()->getLocStart(),
631 diag::err_duplicate_case) << CaseVals[i].first.toString(10);
632 Diag(CaseVals[i-1].second->getLHS()->getLocStart(),
633 diag::note_duplicate_case_prev);
634 // FIXME: We really want to remove the bogus case stmt from the
635 // substmt, but we have no way to do this right now.
636 CaseListIsErroneous = true;
641 // Detect duplicate case ranges, which usually don't exist at all in
643 if (!CaseRanges.empty()) {
644 // Sort all the case ranges by their low value so we can easily detect
645 // overlaps between ranges.
646 std::stable_sort(CaseRanges.begin(), CaseRanges.end());
648 // Scan the ranges, computing the high values and removing empty ranges.
649 std::vector<llvm::APSInt> HiVals;
650 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
651 llvm::APSInt &LoVal = CaseRanges[i].first;
652 CaseStmt *CR = CaseRanges[i].second;
653 Expr *Hi = CR->getRHS();
654 llvm::APSInt HiVal = Hi->EvaluateAsInt(Context);
656 // Convert the value to the same width/sign as the condition.
657 ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
659 diag::warn_case_value_overflow);
661 // If the LHS is not the same type as the condition, insert an implicit
663 Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
666 // If the low value is bigger than the high value, the case is empty.
668 Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
669 << SourceRange(CR->getLHS()->getLocStart(),
671 CaseRanges.erase(CaseRanges.begin()+i);
676 if (ShouldCheckConstantCond &&
677 LoVal <= ConstantCondValue &&
678 ConstantCondValue <= HiVal)
679 ShouldCheckConstantCond = false;
681 HiVals.push_back(HiVal);
684 // Rescan the ranges, looking for overlap with singleton values and other
685 // ranges. Since the range list is sorted, we only need to compare case
686 // ranges with their neighbors.
687 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
688 llvm::APSInt &CRLo = CaseRanges[i].first;
689 llvm::APSInt &CRHi = HiVals[i];
690 CaseStmt *CR = CaseRanges[i].second;
692 // Check to see whether the case range overlaps with any
694 CaseStmt *OverlapStmt = 0;
695 llvm::APSInt OverlapVal(32);
697 // Find the smallest value >= the lower bound. If I is in the
698 // case range, then we have overlap.
699 CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
700 CaseVals.end(), CRLo,
701 CaseCompareFunctor());
702 if (I != CaseVals.end() && I->first < CRHi) {
703 OverlapVal = I->first; // Found overlap with scalar.
704 OverlapStmt = I->second;
707 // Find the smallest value bigger than the upper bound.
708 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
709 if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
710 OverlapVal = (I-1)->first; // Found overlap with scalar.
711 OverlapStmt = (I-1)->second;
714 // Check to see if this case stmt overlaps with the subsequent
716 if (i && CRLo <= HiVals[i-1]) {
717 OverlapVal = HiVals[i-1]; // Found overlap with range.
718 OverlapStmt = CaseRanges[i-1].second;
722 // If we have a duplicate, report it.
723 Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
724 << OverlapVal.toString(10);
725 Diag(OverlapStmt->getLHS()->getLocStart(),
726 diag::note_duplicate_case_prev);
727 // FIXME: We really want to remove the bogus case stmt from the
728 // substmt, but we have no way to do this right now.
729 CaseListIsErroneous = true;
734 // Complain if we have a constant condition and we didn't find a match.
735 if (!CaseListIsErroneous && ShouldCheckConstantCond) {
736 // TODO: it would be nice if we printed enums as enums, chars as
738 Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
739 << ConstantCondValue.toString(10)
740 << CondExpr->getSourceRange();
743 // Check to see if switch is over an Enum and handles all of its
744 // values. We only issue a warning if there is not 'default:', but
745 // we still do the analysis to preserve this information in the AST
746 // (which can be used by flow-based analyes).
748 const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
750 // If switch has default case, then ignore it.
751 if (!CaseListIsErroneous && !HasConstantCond && ET) {
752 const EnumDecl *ED = ET->getDecl();
753 typedef llvm::SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
757 // Gather all enum values, set their type and sort them,
758 // allowing easier comparison with CaseVals.
759 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
760 EDI != ED->enumerator_end(); ++EDI) {
761 llvm::APSInt Val = EDI->getInitVal();
762 AdjustAPSInt(Val, CondWidth, CondIsSigned);
763 EnumVals.push_back(std::make_pair(Val, *EDI));
765 std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
766 EnumValsTy::iterator EIend =
767 std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
769 // See which case values aren't in enum.
770 // TODO: we might want to check whether case values are out of the
771 // enum even if we don't want to check whether all cases are handled.
772 if (!TheDefaultStmt) {
773 EnumValsTy::const_iterator EI = EnumVals.begin();
774 for (CaseValsTy::const_iterator CI = CaseVals.begin();
775 CI != CaseVals.end(); CI++) {
776 while (EI != EIend && EI->first < CI->first)
778 if (EI == EIend || EI->first > CI->first)
779 Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
780 << ED->getDeclName();
782 // See which of case ranges aren't in enum
783 EI = EnumVals.begin();
784 for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
785 RI != CaseRanges.end() && EI != EIend; RI++) {
786 while (EI != EIend && EI->first < RI->first)
789 if (EI == EIend || EI->first != RI->first) {
790 Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
791 << ED->getDeclName();
794 llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context);
795 AdjustAPSInt(Hi, CondWidth, CondIsSigned);
796 while (EI != EIend && EI->first < Hi)
798 if (EI == EIend || EI->first != Hi)
799 Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
800 << ED->getDeclName();
804 // Check which enum vals aren't in switch
805 CaseValsTy::const_iterator CI = CaseVals.begin();
806 CaseRangesTy::const_iterator RI = CaseRanges.begin();
807 bool hasCasesNotInSwitch = false;
809 llvm::SmallVector<DeclarationName,8> UnhandledNames;
811 for (EnumValsTy::const_iterator EI = EnumVals.begin(); EI != EIend; EI++){
812 // Drop unneeded case values
814 while (CI != CaseVals.end() && CI->first < EI->first)
817 if (CI != CaseVals.end() && CI->first == EI->first)
820 // Drop unneeded case ranges
821 for (; RI != CaseRanges.end(); RI++) {
822 llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context);
823 AdjustAPSInt(Hi, CondWidth, CondIsSigned);
828 if (RI == CaseRanges.end() || EI->first < RI->first) {
829 hasCasesNotInSwitch = true;
831 UnhandledNames.push_back(EI->second->getDeclName());
835 // Produce a nice diagnostic if multiple values aren't handled.
836 switch (UnhandledNames.size()) {
839 Diag(CondExpr->getExprLoc(), diag::warn_missing_case1)
840 << UnhandledNames[0];
843 Diag(CondExpr->getExprLoc(), diag::warn_missing_case2)
844 << UnhandledNames[0] << UnhandledNames[1];
847 Diag(CondExpr->getExprLoc(), diag::warn_missing_case3)
848 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
851 Diag(CondExpr->getExprLoc(), diag::warn_missing_cases)
852 << (unsigned)UnhandledNames.size()
853 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
857 if (!hasCasesNotInSwitch)
858 SS->setAllEnumCasesCovered();
862 // FIXME: If the case list was broken is some way, we don't have a good system
863 // to patch it up. Instead, just return the whole substmt as broken.
864 if (CaseListIsErroneous)
871 Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
872 Decl *CondVar, Stmt *Body) {
873 ExprResult CondResult(Cond.release());
875 VarDecl *ConditionVar = 0;
877 ConditionVar = cast<VarDecl>(CondVar);
878 CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
879 if (CondResult.isInvalid())
882 Expr *ConditionExpr = CondResult.take();
886 DiagnoseUnusedExprResult(Body);
888 return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
893 Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
894 SourceLocation WhileLoc, SourceLocation CondLParen,
895 Expr *Cond, SourceLocation CondRParen) {
896 assert(Cond && "ActOnDoStmt(): missing expression");
898 ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
899 if (CondResult.isInvalid() || CondResult.isInvalid())
901 Cond = CondResult.take();
903 CheckImplicitConversions(Cond, DoLoc);
904 CondResult = MaybeCreateExprWithCleanups(Cond);
905 if (CondResult.isInvalid())
907 Cond = CondResult.take();
909 DiagnoseUnusedExprResult(Body);
911 return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
915 Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
916 Stmt *First, FullExprArg second, Decl *secondVar,
918 SourceLocation RParenLoc, Stmt *Body) {
919 if (!getLangOptions().CPlusPlus) {
920 if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
921 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
922 // declare identifiers for objects having storage class 'auto' or
924 for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
926 VarDecl *VD = dyn_cast<VarDecl>(*DI);
927 if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
930 Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
931 // FIXME: mark decl erroneous!
936 ExprResult SecondResult(second.release());
937 VarDecl *ConditionVar = 0;
939 ConditionVar = cast<VarDecl>(secondVar);
940 SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
941 if (SecondResult.isInvalid())
945 Expr *Third = third.release().takeAs<Expr>();
947 DiagnoseUnusedExprResult(First);
948 DiagnoseUnusedExprResult(Third);
949 DiagnoseUnusedExprResult(Body);
951 return Owned(new (Context) ForStmt(Context, First,
952 SecondResult.take(), ConditionVar,
953 Third, Body, ForLoc, LParenLoc,
957 /// In an Objective C collection iteration statement:
959 /// x can be an arbitrary l-value expression. Bind it up as a
961 StmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
962 CheckImplicitConversions(E);
963 ExprResult Result = MaybeCreateExprWithCleanups(E);
964 if (Result.isInvalid()) return StmtError();
965 return Owned(static_cast<Stmt*>(Result.get()));
969 Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
970 SourceLocation LParenLoc,
971 Stmt *First, Expr *Second,
972 SourceLocation RParenLoc, Stmt *Body) {
975 if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
976 if (!DS->isSingleDecl())
977 return StmtError(Diag((*DS->decl_begin())->getLocation(),
978 diag::err_toomany_element_decls));
980 VarDecl *D = cast<VarDecl>(DS->getSingleDecl());
981 FirstType = D->getType();
982 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
983 // declare identifiers for objects having storage class 'auto' or
985 if (!D->hasLocalStorage())
986 return StmtError(Diag(D->getLocation(),
987 diag::err_non_variable_decl_in_for));
989 Expr *FirstE = cast<Expr>(First);
990 if (!FirstE->isTypeDependent() && !FirstE->isLValue())
991 return StmtError(Diag(First->getLocStart(),
992 diag::err_selector_element_not_lvalue)
993 << First->getSourceRange());
995 FirstType = static_cast<Expr*>(First)->getType();
997 if (!FirstType->isDependentType() &&
998 !FirstType->isObjCObjectPointerType() &&
999 !FirstType->isBlockPointerType())
1000 Diag(ForLoc, diag::err_selector_element_type)
1001 << FirstType << First->getSourceRange();
1003 if (Second && !Second->isTypeDependent()) {
1004 ExprResult Result = DefaultFunctionArrayLvalueConversion(Second);
1005 if (Result.isInvalid())
1007 Second = Result.take();
1008 QualType SecondType = Second->getType();
1009 if (!SecondType->isObjCObjectPointerType())
1010 Diag(ForLoc, diag::err_collection_expr_type)
1011 << SecondType << Second->getSourceRange();
1012 else if (const ObjCObjectPointerType *OPT =
1013 SecondType->getAsObjCInterfacePointerType()) {
1014 llvm::SmallVector<IdentifierInfo *, 4> KeyIdents;
1015 IdentifierInfo* selIdent =
1016 &Context.Idents.get("countByEnumeratingWithState");
1017 KeyIdents.push_back(selIdent);
1018 selIdent = &Context.Idents.get("objects");
1019 KeyIdents.push_back(selIdent);
1020 selIdent = &Context.Idents.get("count");
1021 KeyIdents.push_back(selIdent);
1022 Selector CSelector = Context.Selectors.getSelector(3, &KeyIdents[0]);
1023 if (ObjCInterfaceDecl *IDecl = OPT->getInterfaceDecl()) {
1024 if (!IDecl->isForwardDecl() &&
1025 !IDecl->lookupInstanceMethod(CSelector) &&
1026 !LookupMethodInQualifiedType(CSelector, OPT, true)) {
1027 // Must further look into private implementation methods.
1028 if (!LookupPrivateInstanceMethod(CSelector, IDecl))
1029 Diag(ForLoc, diag::warn_collection_expr_type)
1030 << SecondType << CSelector << Second->getSourceRange();
1035 return Owned(new (Context) ObjCForCollectionStmt(First, Second, Body,
1036 ForLoc, RParenLoc));
1041 enum BeginEndFunction {
1046 /// Build a variable declaration for a for-range statement.
1047 static VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
1048 QualType Type, const char *Name) {
1049 DeclContext *DC = SemaRef.CurContext;
1050 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1051 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1052 VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
1053 TInfo, SC_Auto, SC_None);
1054 Decl->setImplicit();
1058 /// Finish building a variable declaration for a for-range statement.
1059 /// \return true if an error occurs.
1060 static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
1061 SourceLocation Loc, int diag) {
1062 // Deduce the type for the iterator variable now rather than leaving it to
1063 // AddInitializerToDecl, so we can produce a more suitable diagnostic.
1064 TypeSourceInfo *InitTSI = 0;
1065 if (Init->getType()->isVoidType() ||
1066 !SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTSI))
1067 SemaRef.Diag(Loc, diag) << Init->getType();
1069 Decl->setInvalidDecl();
1072 Decl->setTypeSourceInfo(InitTSI);
1073 Decl->setType(InitTSI->getType());
1075 // In ARC, infer lifetime.
1076 // FIXME: ARC may want to turn this into 'const __unsafe_unretained' if
1077 // we're doing the equivalent of fast iteration.
1078 if (SemaRef.getLangOptions().ObjCAutoRefCount &&
1079 SemaRef.inferObjCARCLifetime(Decl))
1080 Decl->setInvalidDecl();
1082 SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1083 /*TypeMayContainAuto=*/false);
1084 SemaRef.FinalizeDeclaration(Decl);
1085 SemaRef.CurContext->addHiddenDecl(Decl);
1089 /// Produce a note indicating which begin/end function was implicitly called
1090 /// by a C++0x for-range statement. This is often not obvious from the code,
1091 /// nor from the diagnostics produced when analysing the implicit expressions
1092 /// required in a for-range statement.
1093 void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1094 BeginEndFunction BEF) {
1095 CallExpr *CE = dyn_cast<CallExpr>(E);
1098 FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1101 SourceLocation Loc = D->getLocation();
1103 std::string Description;
1104 bool IsTemplate = false;
1105 if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1106 Description = SemaRef.getTemplateArgumentBindingsText(
1107 FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1111 SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1112 << BEF << IsTemplate << Description << E->getType();
1115 /// Build a call to 'begin' or 'end' for a C++0x for-range statement. If the
1116 /// given LookupResult is non-empty, it is assumed to describe a member which
1117 /// will be invoked. Otherwise, the function will be found via argument
1118 /// dependent lookup.
1119 static ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1122 BeginEndFunction BEF,
1123 const DeclarationNameInfo &NameInfo,
1124 LookupResult &MemberLookup,
1126 ExprResult CallExpr;
1127 if (!MemberLookup.empty()) {
1128 ExprResult MemberRef =
1129 SemaRef.BuildMemberReferenceExpr(Range, Range->getType(), Loc,
1130 /*IsPtr=*/false, CXXScopeSpec(),
1131 /*Qualifier=*/0, MemberLookup,
1132 /*TemplateArgs=*/0);
1133 if (MemberRef.isInvalid())
1135 CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1137 if (CallExpr.isInvalid())
1140 UnresolvedSet<0> FoundNames;
1141 // C++0x [stmt.ranged]p1: For the purposes of this name lookup, namespace
1142 // std is an associated namespace.
1143 UnresolvedLookupExpr *Fn =
1144 UnresolvedLookupExpr::Create(SemaRef.Context, /*NamingClass=*/0,
1145 NestedNameSpecifierLoc(), NameInfo,
1146 /*NeedsADL=*/true, /*Overloaded=*/false,
1147 FoundNames.begin(), FoundNames.end(),
1148 /*LookInStdNamespace=*/true);
1149 CallExpr = SemaRef.BuildOverloadedCallExpr(S, Fn, Fn, Loc, &Range, 1, Loc,
1151 if (CallExpr.isInvalid()) {
1152 SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1153 << Range->getType();
1157 if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1158 diag::err_for_range_iter_deduction_failure)) {
1159 NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1167 /// ActOnCXXForRangeStmt - Check and build a C++0x for-range statement.
1169 /// C++0x [stmt.ranged]:
1170 /// A range-based for statement is equivalent to
1173 /// auto && __range = range-init;
1174 /// for ( auto __begin = begin-expr,
1175 /// __end = end-expr;
1176 /// __begin != __end;
1178 /// for-range-declaration = *__begin;
1183 /// The body of the loop is not available yet, since it cannot be analysed until
1184 /// we have determined the type of the for-range-declaration.
1186 Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1187 Stmt *First, SourceLocation ColonLoc, Expr *Range,
1188 SourceLocation RParenLoc) {
1189 if (!First || !Range)
1192 DeclStmt *DS = dyn_cast<DeclStmt>(First);
1193 assert(DS && "first part of for range not a decl stmt");
1195 if (!DS->isSingleDecl()) {
1196 Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1199 if (DS->getSingleDecl()->isInvalidDecl())
1202 if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1205 // Build auto && __range = range-init
1206 SourceLocation RangeLoc = Range->getLocStart();
1207 VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1208 Context.getAutoRRefDeductType(),
1210 if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1211 diag::err_for_range_deduction_failure))
1214 // Claim the type doesn't contain auto: we've already done the checking.
1215 DeclGroupPtrTy RangeGroup =
1216 BuildDeclaratorGroup((Decl**)&RangeVar, 1, /*TypeMayContainAuto=*/false);
1217 StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
1218 if (RangeDecl.isInvalid())
1221 return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1222 /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1226 /// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1228 Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1229 Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1230 Expr *Inc, Stmt *LoopVarDecl,
1231 SourceLocation RParenLoc) {
1232 Scope *S = getCurScope();
1234 DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1235 VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1236 QualType RangeVarType = RangeVar->getType();
1238 DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1239 VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1241 StmtResult BeginEndDecl = BeginEnd;
1242 ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1244 if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1245 SourceLocation RangeLoc = RangeVar->getLocation();
1247 ExprResult RangeRef = BuildDeclRefExpr(RangeVar,
1248 RangeVarType.getNonReferenceType(),
1249 VK_LValue, ColonLoc);
1250 if (RangeRef.isInvalid())
1253 QualType AutoType = Context.getAutoDeductType();
1254 Expr *Range = RangeVar->getInit();
1257 QualType RangeType = Range->getType();
1259 if (RequireCompleteType(RangeLoc, RangeType,
1260 PDiag(diag::err_for_range_incomplete_type)))
1263 // Build auto __begin = begin-expr, __end = end-expr.
1264 VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1266 VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1269 // Build begin-expr and end-expr and attach to __begin and __end variables.
1270 ExprResult BeginExpr, EndExpr;
1271 if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
1272 // - if _RangeT is an array type, begin-expr and end-expr are __range and
1273 // __range + __bound, respectively, where __bound is the array bound. If
1274 // _RangeT is an array of unknown size or an array of incomplete type,
1275 // the program is ill-formed;
1277 // begin-expr is __range.
1278 BeginExpr = RangeRef;
1279 if (FinishForRangeVarDecl(*this, BeginVar, RangeRef.get(), ColonLoc,
1280 diag::err_for_range_iter_deduction_failure)) {
1281 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1285 // Find the array bound.
1286 ExprResult BoundExpr;
1287 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
1288 BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(),
1289 Context.getPointerDiffType(),
1291 else if (const VariableArrayType *VAT =
1292 dyn_cast<VariableArrayType>(UnqAT))
1293 BoundExpr = VAT->getSizeExpr();
1295 // Can't be a DependentSizedArrayType or an IncompleteArrayType since
1296 // UnqAT is not incomplete and Range is not type-dependent.
1297 assert(0 && "Unexpected array type in for-range");
1301 // end-expr is __range + __bound.
1302 EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, RangeRef.get(),
1304 if (EndExpr.isInvalid())
1306 if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1307 diag::err_for_range_iter_deduction_failure)) {
1308 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1312 DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1314 DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1317 LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1318 LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1320 if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
1321 // - if _RangeT is a class type, the unqualified-ids begin and end are
1322 // looked up in the scope of class _RangeT as if by class member access
1323 // lookup (3.4.5), and if either (or both) finds at least one
1324 // declaration, begin-expr and end-expr are __range.begin() and
1325 // __range.end(), respectively;
1326 LookupQualifiedName(BeginMemberLookup, D);
1327 LookupQualifiedName(EndMemberLookup, D);
1329 if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1330 Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1331 << RangeType << BeginMemberLookup.empty();
1335 // - otherwise, begin-expr and end-expr are begin(__range) and
1336 // end(__range), respectively, where begin and end are looked up with
1337 // argument-dependent lookup (3.4.2). For the purposes of this name
1338 // lookup, namespace std is an associated namespace.
1341 BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1342 BEF_begin, BeginNameInfo,
1343 BeginMemberLookup, RangeRef.get());
1344 if (BeginExpr.isInvalid())
1347 EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1348 BEF_end, EndNameInfo,
1349 EndMemberLookup, RangeRef.get());
1350 if (EndExpr.isInvalid())
1354 // C++0x [decl.spec.auto]p6: BeginType and EndType must be the same.
1355 QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
1356 if (!Context.hasSameType(BeginType, EndType)) {
1357 Diag(RangeLoc, diag::err_for_range_begin_end_types_differ)
1358 << BeginType << EndType;
1359 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1360 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1363 Decl *BeginEndDecls[] = { BeginVar, EndVar };
1364 // Claim the type doesn't contain auto: we've already done the checking.
1365 DeclGroupPtrTy BeginEndGroup =
1366 BuildDeclaratorGroup(BeginEndDecls, 2, /*TypeMayContainAuto=*/false);
1367 BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc);
1369 ExprResult BeginRef = BuildDeclRefExpr(BeginVar,
1370 BeginType.getNonReferenceType(),
1371 VK_LValue, ColonLoc);
1372 ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1373 VK_LValue, ColonLoc);
1375 // Build and check __begin != __end expression.
1376 NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
1377 BeginRef.get(), EndRef.get());
1378 NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get());
1379 NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get());
1380 if (NotEqExpr.isInvalid()) {
1381 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1382 if (!Context.hasSameType(BeginType, EndType))
1383 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1387 // Build and check ++__begin expression.
1388 IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
1389 IncrExpr = ActOnFinishFullExpr(IncrExpr.get());
1390 if (IncrExpr.isInvalid()) {
1391 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1395 // Build and check *__begin expression.
1396 ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
1397 if (DerefExpr.isInvalid()) {
1398 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1402 // Attach *__begin as initializer for VD.
1403 if (!LoopVar->isInvalidDecl()) {
1404 AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false,
1405 /*TypeMayContainAuto=*/true);
1406 if (LoopVar->isInvalidDecl())
1407 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1410 // The range is implicitly used as a placeholder when it is dependent.
1411 RangeVar->setUsed();
1414 return Owned(new (Context) CXXForRangeStmt(RangeDS,
1415 cast_or_null<DeclStmt>(BeginEndDecl.get()),
1416 NotEqExpr.take(), IncrExpr.take(),
1417 LoopVarDS, /*Body=*/0, ForLoc,
1418 ColonLoc, RParenLoc));
1421 /// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
1422 /// This is a separate step from ActOnCXXForRangeStmt because analysis of the
1423 /// body cannot be performed until after the type of the range variable is
1425 StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
1429 cast<CXXForRangeStmt>(S)->setBody(B);
1433 StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
1434 SourceLocation LabelLoc,
1435 LabelDecl *TheDecl) {
1436 getCurFunction()->setHasBranchIntoScope();
1438 return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
1442 Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
1444 // Convert operand to void*
1445 if (!E->isTypeDependent()) {
1446 QualType ETy = E->getType();
1447 QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
1448 ExprResult ExprRes = Owned(E);
1449 AssignConvertType ConvTy =
1450 CheckSingleAssignmentConstraints(DestTy, ExprRes);
1451 if (ExprRes.isInvalid())
1454 if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
1458 getCurFunction()->setHasIndirectGoto();
1460 return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
1464 Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
1465 Scope *S = CurScope->getContinueParent();
1467 // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
1468 return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
1471 return Owned(new (Context) ContinueStmt(ContinueLoc));
1475 Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
1476 Scope *S = CurScope->getBreakParent();
1478 // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
1479 return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
1482 return Owned(new (Context) BreakStmt(BreakLoc));
1485 /// \brief Determine whether the given expression is a candidate for
1486 /// copy elision in either a return statement or a throw expression.
1488 /// \param ReturnType If we're determining the copy elision candidate for
1489 /// a return statement, this is the return type of the function. If we're
1490 /// determining the copy elision candidate for a throw expression, this will
1493 /// \param E The expression being returned from the function or block, or
1496 /// \param AllowFunctionParameter Whether we allow function parameters to
1497 /// be considered NRVO candidates. C++ prohibits this for NRVO itself, but
1498 /// we re-use this logic to determine whether we should try to move as part of
1499 /// a return or throw (which does allow function parameters).
1501 /// \returns The NRVO candidate variable, if the return statement may use the
1502 /// NRVO, or NULL if there is no such candidate.
1503 const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
1505 bool AllowFunctionParameter) {
1506 QualType ExprType = E->getType();
1507 // - in a return statement in a function with ...
1508 // ... a class return type ...
1509 if (!ReturnType.isNull()) {
1510 if (!ReturnType->isRecordType())
1512 // ... the same cv-unqualified type as the function return type ...
1513 if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
1517 // ... the expression is the name of a non-volatile automatic object
1518 // (other than a function or catch-clause parameter)) ...
1519 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
1522 const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
1526 if (VD->hasLocalStorage() && !VD->isExceptionVariable() &&
1527 !VD->getType()->isReferenceType() && !VD->hasAttr<BlocksAttr>() &&
1528 !VD->getType().isVolatileQualified() &&
1529 ((VD->getKind() == Decl::Var) ||
1530 (AllowFunctionParameter && VD->getKind() == Decl::ParmVar)))
1536 /// \brief Perform the initialization of a potentially-movable value, which
1537 /// is the result of return value.
1539 /// This routine implements C++0x [class.copy]p33, which attempts to treat
1540 /// returned lvalues as rvalues in certain cases (to prefer move construction),
1541 /// then falls back to treating them as lvalues if that failed.
1543 Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
1544 const VarDecl *NRVOCandidate,
1545 QualType ResultType,
1548 // C++0x [class.copy]p33:
1549 // When the criteria for elision of a copy operation are met or would
1550 // be met save for the fact that the source object is a function
1551 // parameter, and the object to be copied is designated by an lvalue,
1552 // overload resolution to select the constructor for the copy is first
1553 // performed as if the object were designated by an rvalue.
1554 ExprResult Res = ExprError();
1556 (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true))) {
1557 ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
1558 Value->getType(), CK_LValueToRValue,
1561 Expr *InitExpr = &AsRvalue;
1562 InitializationKind Kind
1563 = InitializationKind::CreateCopy(Value->getLocStart(),
1564 Value->getLocStart());
1565 InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
1567 // [...] If overload resolution fails, or if the type of the first
1568 // parameter of the selected constructor is not an rvalue reference
1569 // to the object's type (possibly cv-qualified), overload resolution
1570 // is performed again, considering the object as an lvalue.
1572 for (InitializationSequence::step_iterator Step = Seq.step_begin(),
1573 StepEnd = Seq.step_end();
1574 Step != StepEnd; ++Step) {
1575 if (Step->Kind != InitializationSequence::SK_ConstructorInitialization)
1578 CXXConstructorDecl *Constructor
1579 = cast<CXXConstructorDecl>(Step->Function.Function);
1581 const RValueReferenceType *RRefType
1582 = Constructor->getParamDecl(0)->getType()
1583 ->getAs<RValueReferenceType>();
1585 // If we don't meet the criteria, break out now.
1587 !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
1588 Context.getTypeDeclType(Constructor->getParent())))
1591 // Promote "AsRvalue" to the heap, since we now need this
1592 // expression node to persist.
1593 Value = ImplicitCastExpr::Create(Context, Value->getType(),
1594 CK_LValueToRValue, Value, 0,
1597 // Complete type-checking the initialization of the return type
1598 // using the constructor we found.
1599 Res = Seq.Perform(*this, Entity, Kind, MultiExprArg(&Value, 1));
1604 // Either we didn't meet the criteria for treating an lvalue as an rvalue,
1605 // above, or overload resolution failed. Either way, we need to try
1606 // (again) now with the return value expression as written.
1607 if (Res.isInvalid())
1608 Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
1613 /// ActOnBlockReturnStmt - Utility routine to figure out block's return type.
1616 Sema::ActOnBlockReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1617 // If this is the first return we've seen in the block, infer the type of
1618 // the block from it.
1619 BlockScopeInfo *CurBlock = getCurBlock();
1620 if (CurBlock->ReturnType.isNull()) {
1622 // Don't call UsualUnaryConversions(), since we don't want to do
1623 // integer promotions here.
1624 ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
1625 if (Result.isInvalid())
1627 RetValExp = Result.take();
1629 if (!RetValExp->isTypeDependent()) {
1630 CurBlock->ReturnType = RetValExp->getType();
1631 if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(RetValExp)) {
1632 // We have to remove a 'const' added to copied-in variable which was
1633 // part of the implementation spec. and not the actual qualifier for
1635 if (CDRE->isConstQualAdded())
1636 CurBlock->ReturnType.removeLocalConst(); // FIXME: local???
1639 CurBlock->ReturnType = Context.DependentTy;
1641 CurBlock->ReturnType = Context.VoidTy;
1643 QualType FnRetType = CurBlock->ReturnType;
1645 if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
1646 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr)
1647 << getCurFunctionOrMethodDecl()->getDeclName();
1651 // Otherwise, verify that this result type matches the previous one. We are
1652 // pickier with blocks than for normal functions because we don't have GCC
1653 // compatibility to worry about here.
1654 ReturnStmt *Result = 0;
1655 if (CurBlock->ReturnType->isVoidType()) {
1656 if (RetValExp && !RetValExp->isTypeDependent() &&
1657 (!getLangOptions().CPlusPlus || !RetValExp->getType()->isVoidType())) {
1658 Diag(ReturnLoc, diag::err_return_block_has_expr);
1661 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
1662 } else if (!RetValExp) {
1663 if (!CurBlock->ReturnType->isDependentType())
1664 return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
1666 Result = new (Context) ReturnStmt(ReturnLoc, 0, 0);
1668 const VarDecl *NRVOCandidate = 0;
1670 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1671 // we have a non-void block with an expression, continue checking
1673 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1674 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1677 // In C++ the return statement is handled via a copy initialization.
1678 // the C version of which boils down to CheckSingleAssignmentConstraints.
1679 NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1680 InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1682 NRVOCandidate != 0);
1683 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1684 FnRetType, RetValExp);
1685 if (Res.isInvalid()) {
1686 // FIXME: Cleanup temporaries here, anyway?
1691 CheckImplicitConversions(RetValExp, ReturnLoc);
1692 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1695 RetValExp = Res.takeAs<Expr>();
1697 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1700 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1703 // If we need to check for the named return value optimization, save the
1704 // return statement in our scope for later processing.
1705 if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1706 !CurContext->isDependentContext())
1707 FunctionScopes.back()->Returns.push_back(Result);
1709 return Owned(Result);
1713 Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1714 // Check for unexpanded parameter packs.
1715 if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
1719 return ActOnBlockReturnStmt(ReturnLoc, RetValExp);
1722 QualType DeclaredRetType;
1723 if (const FunctionDecl *FD = getCurFunctionDecl()) {
1724 FnRetType = FD->getResultType();
1725 DeclaredRetType = FnRetType;
1726 if (FD->hasAttr<NoReturnAttr>() ||
1727 FD->getType()->getAs<FunctionType>()->getNoReturnAttr())
1728 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
1729 << getCurFunctionOrMethodDecl()->getDeclName();
1730 } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
1731 DeclaredRetType = MD->getResultType();
1732 if (MD->hasRelatedResultType() && MD->getClassInterface()) {
1733 // In the implementation of a method with a related return type, the
1734 // type used to type-check the validity of return statements within the
1735 // method body is a pointer to the type of the class being implemented.
1736 FnRetType = Context.getObjCInterfaceType(MD->getClassInterface());
1737 FnRetType = Context.getObjCObjectPointerType(FnRetType);
1739 FnRetType = DeclaredRetType;
1741 } else // If we don't have a function/method context, bail.
1744 ReturnStmt *Result = 0;
1745 if (FnRetType->isVoidType()) {
1747 if (!RetValExp->isTypeDependent()) {
1748 // C99 6.8.6.4p1 (ext_ since GCC warns)
1749 unsigned D = diag::ext_return_has_expr;
1750 if (RetValExp->getType()->isVoidType())
1751 D = diag::ext_return_has_void_expr;
1753 ExprResult Result = Owned(RetValExp);
1754 Result = IgnoredValueConversions(Result.take());
1755 if (Result.isInvalid())
1757 RetValExp = Result.take();
1758 RetValExp = ImpCastExprToType(RetValExp,
1759 Context.VoidTy, CK_ToVoid).take();
1762 // return (some void expression); is legal in C++.
1763 if (D != diag::ext_return_has_void_expr ||
1764 !getLangOptions().CPlusPlus) {
1765 NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
1767 int FunctionKind = 0;
1768 if (isa<ObjCMethodDecl>(CurDecl))
1770 else if (isa<CXXConstructorDecl>(CurDecl))
1772 else if (isa<CXXDestructorDecl>(CurDecl))
1776 << CurDecl->getDeclName() << FunctionKind
1777 << RetValExp->getSourceRange();
1781 CheckImplicitConversions(RetValExp, ReturnLoc);
1782 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1785 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
1786 } else if (!RetValExp && !FnRetType->isDependentType()) {
1787 unsigned DiagID = diag::warn_return_missing_expr; // C90 6.6.6.4p4
1788 // C99 6.8.6.4p1 (ext_ since GCC warns)
1789 if (getLangOptions().C99) DiagID = diag::ext_return_missing_expr;
1791 if (FunctionDecl *FD = getCurFunctionDecl())
1792 Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
1794 Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
1795 Result = new (Context) ReturnStmt(ReturnLoc);
1797 const VarDecl *NRVOCandidate = 0;
1798 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1799 // we have a non-void function with an expression, continue checking
1801 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1802 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1805 // In C++ the return statement is handled via a copy initialization,
1806 // the C version of which boils down to CheckSingleAssignmentConstraints.
1807 NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1808 InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1810 NRVOCandidate != 0);
1811 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1812 FnRetType, RetValExp);
1813 if (Res.isInvalid()) {
1814 // FIXME: Cleanup temporaries here, anyway?
1818 RetValExp = Res.takeAs<Expr>();
1820 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1824 // If we type-checked an Objective-C method's return type based
1825 // on a related return type, we may need to adjust the return
1826 // type again. Do so now.
1827 if (DeclaredRetType != FnRetType) {
1828 ExprResult result = PerformImplicitConversion(RetValExp,
1831 if (result.isInvalid()) return StmtError();
1832 RetValExp = result.take();
1835 CheckImplicitConversions(RetValExp, ReturnLoc);
1836 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1838 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1841 // If we need to check for the named return value optimization, save the
1842 // return statement in our scope for later processing.
1843 if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1844 !CurContext->isDependentContext())
1845 FunctionScopes.back()->Returns.push_back(Result);
1847 return Owned(Result);
1850 /// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
1851 /// ignore "noop" casts in places where an lvalue is required by an inline asm.
1852 /// We emulate this behavior when -fheinous-gnu-extensions is specified, but
1853 /// provide a strong guidance to not use it.
1855 /// This method checks to see if the argument is an acceptable l-value and
1856 /// returns false if it is a case we can handle.
1857 static bool CheckAsmLValue(const Expr *E, Sema &S) {
1858 // Type dependent expressions will be checked during instantiation.
1859 if (E->isTypeDependent())
1863 return false; // Cool, this is an lvalue.
1865 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
1866 // are supposed to allow.
1867 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
1868 if (E != E2 && E2->isLValue()) {
1869 if (!S.getLangOptions().HeinousExtensions)
1870 S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
1871 << E->getSourceRange();
1873 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
1874 << E->getSourceRange();
1875 // Accept, even if we emitted an error diagnostic.
1879 // None of the above, just randomly invalid non-lvalue.
1883 /// isOperandMentioned - Return true if the specified operand # is mentioned
1884 /// anywhere in the decomposed asm string.
1885 static bool isOperandMentioned(unsigned OpNo,
1886 llvm::ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) {
1887 for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
1888 const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
1889 if (!Piece.isOperand()) continue;
1891 // If this is a reference to the input and if the input was the smaller
1892 // one, then we have to reject this asm.
1893 if (Piece.getOperandNo() == OpNo)
1900 StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1901 bool IsVolatile, unsigned NumOutputs,
1902 unsigned NumInputs, IdentifierInfo **Names,
1903 MultiExprArg constraints, MultiExprArg exprs,
1904 Expr *asmString, MultiExprArg clobbers,
1905 SourceLocation RParenLoc, bool MSAsm) {
1906 unsigned NumClobbers = clobbers.size();
1907 StringLiteral **Constraints =
1908 reinterpret_cast<StringLiteral**>(constraints.get());
1909 Expr **Exprs = exprs.get();
1910 StringLiteral *AsmString = cast<StringLiteral>(asmString);
1911 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
1913 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1915 // The parser verifies that there is a string literal here.
1916 if (AsmString->isWide())
1917 return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
1918 << AsmString->getSourceRange());
1920 for (unsigned i = 0; i != NumOutputs; i++) {
1921 StringLiteral *Literal = Constraints[i];
1922 if (Literal->isWide())
1923 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1924 << Literal->getSourceRange());
1926 llvm::StringRef OutputName;
1928 OutputName = Names[i]->getName();
1930 TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
1931 if (!Context.Target.validateOutputConstraint(Info))
1932 return StmtError(Diag(Literal->getLocStart(),
1933 diag::err_asm_invalid_output_constraint)
1934 << Info.getConstraintStr());
1936 // Check that the output exprs are valid lvalues.
1937 Expr *OutputExpr = Exprs[i];
1938 if (CheckAsmLValue(OutputExpr, *this)) {
1939 return StmtError(Diag(OutputExpr->getLocStart(),
1940 diag::err_asm_invalid_lvalue_in_output)
1941 << OutputExpr->getSourceRange());
1944 OutputConstraintInfos.push_back(Info);
1947 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
1949 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
1950 StringLiteral *Literal = Constraints[i];
1951 if (Literal->isWide())
1952 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1953 << Literal->getSourceRange());
1955 llvm::StringRef InputName;
1957 InputName = Names[i]->getName();
1959 TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
1960 if (!Context.Target.validateInputConstraint(OutputConstraintInfos.data(),
1961 NumOutputs, Info)) {
1962 return StmtError(Diag(Literal->getLocStart(),
1963 diag::err_asm_invalid_input_constraint)
1964 << Info.getConstraintStr());
1967 Expr *InputExpr = Exprs[i];
1969 // Only allow void types for memory constraints.
1970 if (Info.allowsMemory() && !Info.allowsRegister()) {
1971 if (CheckAsmLValue(InputExpr, *this))
1972 return StmtError(Diag(InputExpr->getLocStart(),
1973 diag::err_asm_invalid_lvalue_in_input)
1974 << Info.getConstraintStr()
1975 << InputExpr->getSourceRange());
1978 if (Info.allowsRegister()) {
1979 if (InputExpr->getType()->isVoidType()) {
1980 return StmtError(Diag(InputExpr->getLocStart(),
1981 diag::err_asm_invalid_type_in_input)
1982 << InputExpr->getType() << Info.getConstraintStr()
1983 << InputExpr->getSourceRange());
1987 ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
1988 if (Result.isInvalid())
1991 Exprs[i] = Result.take();
1992 InputConstraintInfos.push_back(Info);
1995 // Check that the clobbers are valid.
1996 for (unsigned i = 0; i != NumClobbers; i++) {
1997 StringLiteral *Literal = Clobbers[i];
1998 if (Literal->isWide())
1999 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
2000 << Literal->getSourceRange());
2002 llvm::StringRef Clobber = Literal->getString();
2004 if (!Context.Target.isValidClobber(Clobber))
2005 return StmtError(Diag(Literal->getLocStart(),
2006 diag::err_asm_unknown_register_name) << Clobber);
2010 new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm,
2011 NumOutputs, NumInputs, Names, Constraints, Exprs,
2012 AsmString, NumClobbers, Clobbers, RParenLoc);
2013 // Validate the asm string, ensuring it makes sense given the operands we
2015 llvm::SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
2017 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
2018 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
2019 << AsmString->getSourceRange();
2023 // Validate tied input operands for type mismatches.
2024 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
2025 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
2027 // If this is a tied constraint, verify that the output and input have
2028 // either exactly the same type, or that they are int/ptr operands with the
2029 // same size (int/long, int*/long, are ok etc).
2030 if (!Info.hasTiedOperand()) continue;
2032 unsigned TiedTo = Info.getTiedOperand();
2033 unsigned InputOpNo = i+NumOutputs;
2034 Expr *OutputExpr = Exprs[TiedTo];
2035 Expr *InputExpr = Exprs[InputOpNo];
2036 QualType InTy = InputExpr->getType();
2037 QualType OutTy = OutputExpr->getType();
2038 if (Context.hasSameType(InTy, OutTy))
2039 continue; // All types can be tied to themselves.
2041 // Decide if the input and output are in the same domain (integer/ptr or
2044 AD_Int, AD_FP, AD_Other
2045 } InputDomain, OutputDomain;
2047 if (InTy->isIntegerType() || InTy->isPointerType())
2048 InputDomain = AD_Int;
2049 else if (InTy->isRealFloatingType())
2050 InputDomain = AD_FP;
2052 InputDomain = AD_Other;
2054 if (OutTy->isIntegerType() || OutTy->isPointerType())
2055 OutputDomain = AD_Int;
2056 else if (OutTy->isRealFloatingType())
2057 OutputDomain = AD_FP;
2059 OutputDomain = AD_Other;
2061 // They are ok if they are the same size and in the same domain. This
2062 // allows tying things like:
2064 // void* to int if they are the same size.
2065 // double to long double if they are the same size.
2067 uint64_t OutSize = Context.getTypeSize(OutTy);
2068 uint64_t InSize = Context.getTypeSize(InTy);
2069 if (OutSize == InSize && InputDomain == OutputDomain &&
2070 InputDomain != AD_Other)
2073 // If the smaller input/output operand is not mentioned in the asm string,
2074 // then we can promote the smaller one to a larger input and the asm string
2076 bool SmallerValueMentioned = false;
2078 // If this is a reference to the input and if the input was the smaller
2079 // one, then we have to reject this asm.
2080 if (isOperandMentioned(InputOpNo, Pieces)) {
2081 // This is a use in the asm string of the smaller operand. Since we
2082 // codegen this by promoting to a wider value, the asm will get printed
2084 SmallerValueMentioned |= InSize < OutSize;
2086 if (isOperandMentioned(TiedTo, Pieces)) {
2087 // If this is a reference to the output, and if the output is the larger
2088 // value, then it's ok because we'll promote the input to the larger type.
2089 SmallerValueMentioned |= OutSize < InSize;
2092 // If the smaller value wasn't mentioned in the asm string, and if the
2093 // output was a register, just extend the shorter one to the size of the
2095 if (!SmallerValueMentioned && InputDomain != AD_Other &&
2096 OutputConstraintInfos[TiedTo].allowsRegister())
2099 // Either both of the operands were mentioned or the smaller one was
2100 // mentioned. One more special case that we'll allow: if the tied input is
2101 // integer, unmentioned, and is a constant, then we'll allow truncating it
2102 // down to the size of the destination.
2103 if (InputDomain == AD_Int && OutputDomain == AD_Int &&
2104 !isOperandMentioned(InputOpNo, Pieces) &&
2105 InputExpr->isEvaluatable(Context)) {
2107 (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
2108 InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2109 Exprs[InputOpNo] = InputExpr;
2110 NS->setInputExpr(i, InputExpr);
2114 Diag(InputExpr->getLocStart(),
2115 diag::err_asm_tying_incompatible_types)
2116 << InTy << OutTy << OutputExpr->getSourceRange()
2117 << InputExpr->getSourceRange();
2125 Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
2126 SourceLocation RParen, Decl *Parm,
2128 VarDecl *Var = cast_or_null<VarDecl>(Parm);
2129 if (Var && Var->isInvalidDecl())
2132 return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
2136 Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
2137 return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
2141 Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
2142 MultiStmtArg CatchStmts, Stmt *Finally) {
2143 if (!getLangOptions().ObjCExceptions)
2144 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
2146 getCurFunction()->setHasBranchProtectedScope();
2147 unsigned NumCatchStmts = CatchStmts.size();
2148 return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
2149 CatchStmts.release(),
2154 StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc,
2157 ExprResult Result = DefaultLvalueConversion(Throw);
2158 if (Result.isInvalid())
2161 Throw = Result.take();
2162 QualType ThrowType = Throw->getType();
2163 // Make sure the expression type is an ObjC pointer or "void *".
2164 if (!ThrowType->isDependentType() &&
2165 !ThrowType->isObjCObjectPointerType()) {
2166 const PointerType *PT = ThrowType->getAs<PointerType>();
2167 if (!PT || !PT->getPointeeType()->isVoidType())
2168 return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
2169 << Throw->getType() << Throw->getSourceRange());
2173 return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
2177 Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
2179 if (!getLangOptions().ObjCExceptions)
2180 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
2183 // @throw without an expression designates a rethrow (which much occur
2184 // in the context of an @catch clause).
2185 Scope *AtCatchParent = CurScope;
2186 while (AtCatchParent && !AtCatchParent->isAtCatchScope())
2187 AtCatchParent = AtCatchParent->getParent();
2189 return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
2192 return BuildObjCAtThrowStmt(AtLoc, Throw);
2196 Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
2198 getCurFunction()->setHasBranchProtectedScope();
2200 ExprResult Result = DefaultLvalueConversion(SyncExpr);
2201 if (Result.isInvalid())
2204 SyncExpr = Result.take();
2205 // Make sure the expression type is an ObjC pointer or "void *".
2206 if (!SyncExpr->getType()->isDependentType() &&
2207 !SyncExpr->getType()->isObjCObjectPointerType()) {
2208 const PointerType *PT = SyncExpr->getType()->getAs<PointerType>();
2209 if (!PT || !PT->getPointeeType()->isVoidType())
2210 return StmtError(Diag(AtLoc, diag::error_objc_synchronized_expects_object)
2211 << SyncExpr->getType() << SyncExpr->getSourceRange());
2214 return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
2217 /// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
2218 /// and creates a proper catch handler from them.
2220 Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl,
2221 Stmt *HandlerBlock) {
2222 // There's nothing to test that ActOnExceptionDecl didn't already test.
2223 return Owned(new (Context) CXXCatchStmt(CatchLoc,
2224 cast_or_null<VarDecl>(ExDecl),
2229 Sema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) {
2230 getCurFunction()->setHasBranchProtectedScope();
2231 return Owned(new (Context) ObjCAutoreleasePoolStmt(AtLoc, Body));
2236 class TypeWithHandler {
2240 TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
2241 : t(type), stmt(statement) {}
2243 // An arbitrary order is fine as long as it places identical
2244 // types next to each other.
2245 bool operator<(const TypeWithHandler &y) const {
2246 if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr())
2248 if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
2251 return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
2254 bool operator==(const TypeWithHandler& other) const {
2255 return t == other.t;
2258 CXXCatchStmt *getCatchStmt() const { return stmt; }
2259 SourceLocation getTypeSpecStartLoc() const {
2260 return stmt->getExceptionDecl()->getTypeSpecStartLoc();
2266 /// ActOnCXXTryBlock - Takes a try compound-statement and a number of
2267 /// handlers and creates a try statement from them.
2269 Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
2270 MultiStmtArg RawHandlers) {
2271 // Don't report an error if 'try' is used in system headers.
2272 if (!getLangOptions().CXXExceptions &&
2273 !getSourceManager().isInSystemHeader(TryLoc))
2274 Diag(TryLoc, diag::err_exceptions_disabled) << "try";
2276 unsigned NumHandlers = RawHandlers.size();
2277 assert(NumHandlers > 0 &&
2278 "The parser shouldn't call this if there are no handlers.");
2279 Stmt **Handlers = RawHandlers.get();
2281 llvm::SmallVector<TypeWithHandler, 8> TypesWithHandlers;
2283 for (unsigned i = 0; i < NumHandlers; ++i) {
2284 CXXCatchStmt *Handler = llvm::cast<CXXCatchStmt>(Handlers[i]);
2285 if (!Handler->getExceptionDecl()) {
2286 if (i < NumHandlers - 1)
2287 return StmtError(Diag(Handler->getLocStart(),
2288 diag::err_early_catch_all));
2293 const QualType CaughtType = Handler->getCaughtType();
2294 const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
2295 TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
2298 // Detect handlers for the same type as an earlier one.
2299 if (NumHandlers > 1) {
2300 llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
2302 TypeWithHandler prev = TypesWithHandlers[0];
2303 for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
2304 TypeWithHandler curr = TypesWithHandlers[i];
2307 Diag(curr.getTypeSpecStartLoc(),
2308 diag::warn_exception_caught_by_earlier_handler)
2309 << curr.getCatchStmt()->getCaughtType().getAsString();
2310 Diag(prev.getTypeSpecStartLoc(),
2311 diag::note_previous_exception_handler)
2312 << prev.getCatchStmt()->getCaughtType().getAsString();
2319 getCurFunction()->setHasBranchProtectedScope();
2321 // FIXME: We should detect handlers that cannot catch anything because an
2322 // earlier handler catches a superclass. Need to find a method that is not
2323 // quadratic for this.
2324 // Neither of these are explicitly forbidden, but every compiler detects them
2327 return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
2328 Handlers, NumHandlers));
2332 Sema::ActOnSEHTryBlock(bool IsCXXTry,
2333 SourceLocation TryLoc,
2336 assert(TryBlock && Handler);
2338 getCurFunction()->setHasBranchProtectedScope();
2340 return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
2344 Sema::ActOnSEHExceptBlock(SourceLocation Loc,
2347 assert(FilterExpr && Block);
2349 if(!FilterExpr->getType()->isIntegerType()) {
2350 return StmtError(Diag(FilterExpr->getExprLoc(),
2351 diag::err_filter_expression_integral)
2352 << FilterExpr->getType());
2355 return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
2359 Sema::ActOnSEHFinallyBlock(SourceLocation Loc,
2362 return Owned(SEHFinallyStmt::Create(Context,Loc,Block));