1//===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for statements.
11//
12//===----------------------------------------------------------------------===//
13
14#include "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"
32using namespace clang;
33using namespace sema;
34
35StmtResult Sema::ActOnExprStmt(FullExprArg expr) {
36 Expr *E = expr.get();
37 if (!E) // FIXME: FullExprArg has no error state?
38 return StmtError();
39
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.
43
44 // Same thing in for stmt first clause (when expr) and third clause.
45 return Owned(static_cast<Stmt*>(E));
46}
47
48
49StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
50 SourceLocation LeadingEmptyMacroLoc) {
51 return Owned(new (Context) NullStmt(SemiLoc, LeadingEmptyMacroLoc));
52}
53
54StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
55 SourceLocation EndLoc) {
56 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
57
58 // If we have an invalid decl, just return an error.
59 if (DG.isNull()) return StmtError();
60
61 return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
62}
63
64void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
65 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
66
67 // If we have an invalid decl, just return.
68 if (DG.isNull() || !DG.isSingleDecl()) return;
| 1//===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements semantic analysis for statements.
11//
12//===----------------------------------------------------------------------===//
13
14#include "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"
32using namespace clang;
33using namespace sema;
34
35StmtResult Sema::ActOnExprStmt(FullExprArg expr) {
36 Expr *E = expr.get();
37 if (!E) // FIXME: FullExprArg has no error state?
38 return StmtError();
39
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.
43
44 // Same thing in for stmt first clause (when expr) and third clause.
45 return Owned(static_cast<Stmt*>(E));
46}
47
48
49StmtResult Sema::ActOnNullStmt(SourceLocation SemiLoc,
50 SourceLocation LeadingEmptyMacroLoc) {
51 return Owned(new (Context) NullStmt(SemiLoc, LeadingEmptyMacroLoc));
52}
53
54StmtResult Sema::ActOnDeclStmt(DeclGroupPtrTy dg, SourceLocation StartLoc,
55 SourceLocation EndLoc) {
56 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
57
58 // If we have an invalid decl, just return an error.
59 if (DG.isNull()) return StmtError();
60
61 return Owned(new (Context) DeclStmt(DG, StartLoc, EndLoc));
62}
63
64void Sema::ActOnForEachDeclStmt(DeclGroupPtrTy dg) {
65 DeclGroupRef DG = dg.getAsVal<DeclGroupRef>();
66
67 // If we have an invalid decl, just return.
68 if (DG.isNull() || !DG.isSingleDecl()) return;
|
| 69 VarDecl *var = cast<VarDecl>(DG.getSingleDecl());
70
|
69 // suppress any potential 'unused variable' warning.
| 71 // suppress any potential 'unused variable' warning.
|
70 DG.getSingleDecl()->setUsed();
| 72 var->setUsed();
73
74 // foreach variables are never actually initialized in the way that
75 // the parser came up with.
76 var->setInit(0);
77
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();
83
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);
91 }
92 }
|
71}
72
73void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
74 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
75 return DiagnoseUnusedExprResult(Label->getSubStmt());
76
77 const Expr *E = dyn_cast_or_null<Expr>(S);
78 if (!E)
79 return;
80
81 SourceLocation Loc;
82 SourceRange R1, R2;
83 if (!E->isUnusedResultAWarning(Loc, R1, R2, Context))
84 return;
85
86 // Okay, we have an unused result. Depending on what the base expression is,
87 // we might want to make a more specific diagnostic. Check for one of these
88 // cases now.
89 unsigned DiagID = diag::warn_unused_expr;
90 if (const ExprWithCleanups *Temps = dyn_cast<ExprWithCleanups>(E))
91 E = Temps->getSubExpr();
92 if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
93 E = TempExpr->getSubExpr();
94
95 E = E->IgnoreParenImpCasts();
96 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
97 if (E->getType()->isVoidType())
98 return;
99
100 // If the callee has attribute pure, const, or warn_unused_result, warn with
101 // a more specific message to make it clear what is happening.
102 if (const Decl *FD = CE->getCalleeDecl()) {
103 if (FD->getAttr<WarnUnusedResultAttr>()) {
104 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result";
105 return;
106 }
107 if (FD->getAttr<PureAttr>()) {
108 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
109 return;
110 }
111 if (FD->getAttr<ConstAttr>()) {
112 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
113 return;
114 }
115 }
116 } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
| 93}
94
95void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
96 if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
97 return DiagnoseUnusedExprResult(Label->getSubStmt());
98
99 const Expr *E = dyn_cast_or_null<Expr>(S);
100 if (!E)
101 return;
102
103 SourceLocation Loc;
104 SourceRange R1, R2;
105 if (!E->isUnusedResultAWarning(Loc, R1, R2, Context))
106 return;
107
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
110 // cases now.
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();
116
117 E = E->IgnoreParenImpCasts();
118 if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
119 if (E->getType()->isVoidType())
120 return;
121
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";
127 return;
128 }
129 if (FD->getAttr<PureAttr>()) {
130 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
131 return;
132 }
133 if (FD->getAttr<ConstAttr>()) {
134 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
135 return;
136 }
137 }
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;
141 return;
142 }
|
117 const ObjCMethodDecl *MD = ME->getMethodDecl();
118 if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
119 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result";
120 return;
121 }
122 } else if (isa<ObjCPropertyRefExpr>(E)) {
123 DiagID = diag::warn_unused_property_expr;
124 } else if (const CXXFunctionalCastExpr *FC
125 = dyn_cast<CXXFunctionalCastExpr>(E)) {
126 if (isa<CXXConstructExpr>(FC->getSubExpr()) ||
127 isa<CXXTemporaryObjectExpr>(FC->getSubExpr()))
128 return;
129 }
130 // Diagnose "(void*) blah" as a typo for "(void) blah".
131 else if (const CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(E)) {
132 TypeSourceInfo *TI = CE->getTypeInfoAsWritten();
133 QualType T = TI->getType();
134
135 // We really do want to use the non-canonical type here.
136 if (T == Context.VoidPtrTy) {
137 PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
138
139 Diag(Loc, diag::warn_unused_voidptr)
140 << FixItHint::CreateRemoval(TL.getStarLoc());
141 return;
142 }
143 }
144
145 DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
146}
147
148StmtResult
149Sema::ActOnCompoundStmt(SourceLocation L, SourceLocation R,
150 MultiStmtArg elts, bool isStmtExpr) {
151 unsigned NumElts = elts.size();
152 Stmt **Elts = reinterpret_cast<Stmt**>(elts.release());
153 // If we're in C89 mode, check that we don't have any decls after stmts. If
154 // so, emit an extension diagnostic.
155 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus) {
156 // Note that __extension__ can be around a decl.
157 unsigned i = 0;
158 // Skip over all declarations.
159 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
160 /*empty*/;
161
162 // We found the end of the list or a statement. Scan for another declstmt.
163 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
164 /*empty*/;
165
166 if (i != NumElts) {
167 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
168 Diag(D->getLocation(), diag::ext_mixed_decls_code);
169 }
170 }
171 // Warn about unused expressions in statements.
172 for (unsigned i = 0; i != NumElts; ++i) {
173 // Ignore statements that are last in a statement expression.
174 if (isStmtExpr && i == NumElts - 1)
175 continue;
176
177 DiagnoseUnusedExprResult(Elts[i]);
178 }
179
180 return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
181}
182
183StmtResult
184Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
185 SourceLocation DotDotDotLoc, Expr *RHSVal,
186 SourceLocation ColonLoc) {
187 assert((LHSVal != 0) && "missing expression in case statement");
188
189 // C99 6.8.4.2p3: The expression shall be an integer constant.
190 // However, GCC allows any evaluatable integer expression.
191 if (!LHSVal->isTypeDependent() && !LHSVal->isValueDependent() &&
192 VerifyIntegerConstantExpression(LHSVal))
193 return StmtError();
194
195 // GCC extension: The expression shall be an integer constant.
196
197 if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent() &&
198 VerifyIntegerConstantExpression(RHSVal)) {
199 RHSVal = 0; // Recover by just forgetting about it.
200 }
201
202 if (getCurFunction()->SwitchStack.empty()) {
203 Diag(CaseLoc, diag::err_case_not_in_switch);
204 return StmtError();
205 }
206
207 CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
208 ColonLoc);
209 getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
210 return Owned(CS);
211}
212
213/// ActOnCaseStmtBody - This installs a statement as the body of a case.
214void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
215 CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
216 CS->setSubStmt(SubStmt);
217}
218
219StmtResult
220Sema::ActOnDefaultStmt(SourceLocation DefaultLoc, SourceLocation ColonLoc,
221 Stmt *SubStmt, Scope *CurScope) {
222 if (getCurFunction()->SwitchStack.empty()) {
223 Diag(DefaultLoc, diag::err_default_not_in_switch);
224 return Owned(SubStmt);
225 }
226
227 DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
228 getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
229 return Owned(DS);
230}
231
232StmtResult
233Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
234 SourceLocation ColonLoc, Stmt *SubStmt) {
235
236 // If the label was multiply defined, reject it now.
237 if (TheDecl->getStmt()) {
238 Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();
239 Diag(TheDecl->getLocation(), diag::note_previous_definition);
240 return Owned(SubStmt);
241 }
242
243 // Otherwise, things are good. Fill in the declaration and return it.
244 LabelStmt *LS = new (Context) LabelStmt(IdentLoc, TheDecl, SubStmt);
245 TheDecl->setStmt(LS);
246 if (!TheDecl->isGnuLocal())
247 TheDecl->setLocation(IdentLoc);
248 return Owned(LS);
249}
250
251StmtResult
252Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
253 Stmt *thenStmt, SourceLocation ElseLoc,
254 Stmt *elseStmt) {
255 ExprResult CondResult(CondVal.release());
256
257 VarDecl *ConditionVar = 0;
258 if (CondVar) {
259 ConditionVar = cast<VarDecl>(CondVar);
260 CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
261 if (CondResult.isInvalid())
262 return StmtError();
263 }
264 Expr *ConditionExpr = CondResult.takeAs<Expr>();
265 if (!ConditionExpr)
266 return StmtError();
267
268 DiagnoseUnusedExprResult(thenStmt);
269
270 // Warn if the if block has a null body without an else value.
271 // this helps prevent bugs due to typos, such as
272 // if (condition);
273 // do_stuff();
274 //
275 if (!elseStmt) {
276 if (NullStmt* stmt = dyn_cast<NullStmt>(thenStmt))
277 // But do not warn if the body is a macro that expands to nothing, e.g:
278 //
279 // #define CALL(x)
280 // if (condition)
281 // CALL(0);
282 //
283 if (!stmt->hasLeadingEmptyMacro())
284 Diag(stmt->getSemiLoc(), diag::warn_empty_if_body);
285 }
286
287 DiagnoseUnusedExprResult(elseStmt);
288
289 return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
290 thenStmt, ElseLoc, elseStmt));
291}
292
293/// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
294/// the specified width and sign. If an overflow occurs, detect it and emit
295/// the specified diagnostic.
296void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
297 unsigned NewWidth, bool NewSign,
298 SourceLocation Loc,
299 unsigned DiagID) {
300 // Perform a conversion to the promoted condition type if needed.
301 if (NewWidth > Val.getBitWidth()) {
302 // If this is an extension, just do it.
303 Val = Val.extend(NewWidth);
304 Val.setIsSigned(NewSign);
305
306 // If the input was signed and negative and the output is
307 // unsigned, don't bother to warn: this is implementation-defined
308 // behavior.
309 // FIXME: Introduce a second, default-ignored warning for this case?
310 } else if (NewWidth < Val.getBitWidth()) {
311 // If this is a truncation, check for overflow.
312 llvm::APSInt ConvVal(Val);
313 ConvVal = ConvVal.trunc(NewWidth);
314 ConvVal.setIsSigned(NewSign);
315 ConvVal = ConvVal.extend(Val.getBitWidth());
316 ConvVal.setIsSigned(Val.isSigned());
317 if (ConvVal != Val)
318 Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
319
320 // Regardless of whether a diagnostic was emitted, really do the
321 // truncation.
322 Val = Val.trunc(NewWidth);
323 Val.setIsSigned(NewSign);
324 } else if (NewSign != Val.isSigned()) {
325 // Convert the sign to match the sign of the condition. This can cause
326 // overflow as well: unsigned(INTMIN)
327 // We don't diagnose this overflow, because it is implementation-defined
328 // behavior.
329 // FIXME: Introduce a second, default-ignored warning for this case?
330 llvm::APSInt OldVal(Val);
331 Val.setIsSigned(NewSign);
332 }
333}
334
335namespace {
336 struct CaseCompareFunctor {
337 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
338 const llvm::APSInt &RHS) {
339 return LHS.first < RHS;
340 }
341 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
342 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
343 return LHS.first < RHS.first;
344 }
345 bool operator()(const llvm::APSInt &LHS,
346 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
347 return LHS < RHS.first;
348 }
349 };
350}
351
352/// CmpCaseVals - Comparison predicate for sorting case values.
353///
354static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
355 const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
356 if (lhs.first < rhs.first)
357 return true;
358
359 if (lhs.first == rhs.first &&
360 lhs.second->getCaseLoc().getRawEncoding()
361 < rhs.second->getCaseLoc().getRawEncoding())
362 return true;
363 return false;
364}
365
366/// CmpEnumVals - Comparison predicate for sorting enumeration values.
367///
368static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
369 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
370{
371 return lhs.first < rhs.first;
372}
373
374/// EqEnumVals - Comparison preficate for uniqing enumeration values.
375///
376static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
377 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
378{
379 return lhs.first == rhs.first;
380}
381
382/// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
383/// potentially integral-promoted expression @p expr.
384static QualType GetTypeBeforeIntegralPromotion(const Expr* expr) {
385 if (const CastExpr *ImplicitCast = dyn_cast<ImplicitCastExpr>(expr)) {
386 const Expr *ExprBeforePromotion = ImplicitCast->getSubExpr();
387 QualType TypeBeforePromotion = ExprBeforePromotion->getType();
388 if (TypeBeforePromotion->isIntegralOrEnumerationType()) {
389 return TypeBeforePromotion;
390 }
391 }
392 return expr->getType();
393}
394
395StmtResult
396Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
397 Decl *CondVar) {
398 ExprResult CondResult;
399
400 VarDecl *ConditionVar = 0;
401 if (CondVar) {
402 ConditionVar = cast<VarDecl>(CondVar);
403 CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
404 if (CondResult.isInvalid())
405 return StmtError();
406
407 Cond = CondResult.release();
408 }
409
410 if (!Cond)
411 return StmtError();
412
413 CondResult
414 = ConvertToIntegralOrEnumerationType(SwitchLoc, Cond,
415 PDiag(diag::err_typecheck_statement_requires_integer),
416 PDiag(diag::err_switch_incomplete_class_type)
417 << Cond->getSourceRange(),
418 PDiag(diag::err_switch_explicit_conversion),
419 PDiag(diag::note_switch_conversion),
420 PDiag(diag::err_switch_multiple_conversions),
421 PDiag(diag::note_switch_conversion),
422 PDiag(0));
423 if (CondResult.isInvalid()) return StmtError();
424 Cond = CondResult.take();
425
426 if (!CondVar) {
427 CheckImplicitConversions(Cond, SwitchLoc);
428 CondResult = MaybeCreateExprWithCleanups(Cond);
429 if (CondResult.isInvalid())
430 return StmtError();
431 Cond = CondResult.take();
432 }
433
434 getCurFunction()->setHasBranchIntoScope();
435
436 SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
437 getCurFunction()->SwitchStack.push_back(SS);
438 return Owned(SS);
439}
440
441static void AdjustAPSInt(llvm::APSInt &Val, unsigned BitWidth, bool IsSigned) {
442 if (Val.getBitWidth() < BitWidth)
443 Val = Val.extend(BitWidth);
444 else if (Val.getBitWidth() > BitWidth)
445 Val = Val.trunc(BitWidth);
446 Val.setIsSigned(IsSigned);
447}
448
449StmtResult
450Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
451 Stmt *BodyStmt) {
452 SwitchStmt *SS = cast<SwitchStmt>(Switch);
453 assert(SS == getCurFunction()->SwitchStack.back() &&
454 "switch stack missing push/pop!");
455
456 SS->setBody(BodyStmt, SwitchLoc);
457 getCurFunction()->SwitchStack.pop_back();
458
459 if (SS->getCond() == 0)
460 return StmtError();
461
462 Expr *CondExpr = SS->getCond();
463 Expr *CondExprBeforePromotion = CondExpr;
464 QualType CondTypeBeforePromotion =
465 GetTypeBeforeIntegralPromotion(CondExpr);
466
467 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
468 ExprResult CondResult = UsualUnaryConversions(CondExpr);
469 if (CondResult.isInvalid())
470 return StmtError();
471 CondExpr = CondResult.take();
472 QualType CondType = CondExpr->getType();
473 SS->setCond(CondExpr);
474
475 // C++ 6.4.2.p2:
476 // Integral promotions are performed (on the switch condition).
477 //
478 // A case value unrepresentable by the original switch condition
479 // type (before the promotion) doesn't make sense, even when it can
480 // be represented by the promoted type. Therefore we need to find
481 // the pre-promotion type of the switch condition.
482 if (!CondExpr->isTypeDependent()) {
483 // We have already converted the expression to an integral or enumeration
484 // type, when we started the switch statement. If we don't have an
485 // appropriate type now, just return an error.
486 if (!CondType->isIntegralOrEnumerationType())
487 return StmtError();
488
489 if (CondExpr->isKnownToHaveBooleanValue()) {
490 // switch(bool_expr) {...} is often a programmer error, e.g.
491 // switch(n && mask) { ... } // Doh - should be "n & mask".
492 // One can always use an if statement instead of switch(bool_expr).
493 Diag(SwitchLoc, diag::warn_bool_switch_condition)
494 << CondExpr->getSourceRange();
495 }
496 }
497
498 // Get the bitwidth of the switched-on value before promotions. We must
499 // convert the integer case values to this width before comparison.
500 bool HasDependentValue
501 = CondExpr->isTypeDependent() || CondExpr->isValueDependent();
502 unsigned CondWidth
503 = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
504 bool CondIsSigned
505 = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
506
507 // Accumulate all of the case values in a vector so that we can sort them
508 // and detect duplicates. This vector contains the APInt for the case after
509 // it has been converted to the condition type.
510 typedef llvm::SmallVector<std::pair<llvm::APSInt, CaseStmt*>, 64> CaseValsTy;
511 CaseValsTy CaseVals;
512
513 // Keep track of any GNU case ranges we see. The APSInt is the low value.
514 typedef std::vector<std::pair<llvm::APSInt, CaseStmt*> > CaseRangesTy;
515 CaseRangesTy CaseRanges;
516
517 DefaultStmt *TheDefaultStmt = 0;
518
519 bool CaseListIsErroneous = false;
520
521 for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
522 SC = SC->getNextSwitchCase()) {
523
524 if (DefaultStmt *DS = dyn_cast<DefaultStmt>(SC)) {
525 if (TheDefaultStmt) {
526 Diag(DS->getDefaultLoc(), diag::err_multiple_default_labels_defined);
527 Diag(TheDefaultStmt->getDefaultLoc(), diag::note_duplicate_case_prev);
528
529 // FIXME: Remove the default statement from the switch block so that
530 // we'll return a valid AST. This requires recursing down the AST and
531 // finding it, not something we are set up to do right now. For now,
532 // just lop the entire switch stmt out of the AST.
533 CaseListIsErroneous = true;
534 }
535 TheDefaultStmt = DS;
536
537 } else {
538 CaseStmt *CS = cast<CaseStmt>(SC);
539
540 // We already verified that the expression has a i-c-e value (C99
541 // 6.8.4.2p3) - get that value now.
542 Expr *Lo = CS->getLHS();
543
544 if (Lo->isTypeDependent() || Lo->isValueDependent()) {
545 HasDependentValue = true;
546 break;
547 }
548
549 llvm::APSInt LoVal = Lo->EvaluateAsInt(Context);
550
551 // Convert the value to the same width/sign as the condition.
552 ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
553 Lo->getLocStart(),
554 diag::warn_case_value_overflow);
555
556 // If the LHS is not the same type as the condition, insert an implicit
557 // cast.
558 Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
559 CS->setLHS(Lo);
560
561 // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
562 if (CS->getRHS()) {
563 if (CS->getRHS()->isTypeDependent() ||
564 CS->getRHS()->isValueDependent()) {
565 HasDependentValue = true;
566 break;
567 }
568 CaseRanges.push_back(std::make_pair(LoVal, CS));
569 } else
570 CaseVals.push_back(std::make_pair(LoVal, CS));
571 }
572 }
573
574 if (!HasDependentValue) {
575 // If we don't have a default statement, check whether the
576 // condition is constant.
577 llvm::APSInt ConstantCondValue;
578 bool HasConstantCond = false;
579 bool ShouldCheckConstantCond = false;
580 if (!HasDependentValue && !TheDefaultStmt) {
581 Expr::EvalResult Result;
582 HasConstantCond = CondExprBeforePromotion->Evaluate(Result, Context);
583 if (HasConstantCond) {
584 assert(Result.Val.isInt() && "switch condition evaluated to non-int");
585 ConstantCondValue = Result.Val.getInt();
586 ShouldCheckConstantCond = true;
587
588 assert(ConstantCondValue.getBitWidth() == CondWidth &&
589 ConstantCondValue.isSigned() == CondIsSigned);
590 }
591 }
592
593 // Sort all the scalar case values so we can easily detect duplicates.
594 std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
595
596 if (!CaseVals.empty()) {
597 for (unsigned i = 0, e = CaseVals.size(); i != e; ++i) {
598 if (ShouldCheckConstantCond &&
599 CaseVals[i].first == ConstantCondValue)
600 ShouldCheckConstantCond = false;
601
602 if (i != 0 && CaseVals[i].first == CaseVals[i-1].first) {
603 // If we have a duplicate, report it.
604 Diag(CaseVals[i].second->getLHS()->getLocStart(),
605 diag::err_duplicate_case) << CaseVals[i].first.toString(10);
606 Diag(CaseVals[i-1].second->getLHS()->getLocStart(),
607 diag::note_duplicate_case_prev);
608 // FIXME: We really want to remove the bogus case stmt from the
609 // substmt, but we have no way to do this right now.
610 CaseListIsErroneous = true;
611 }
612 }
613 }
614
615 // Detect duplicate case ranges, which usually don't exist at all in
616 // the first place.
617 if (!CaseRanges.empty()) {
618 // Sort all the case ranges by their low value so we can easily detect
619 // overlaps between ranges.
620 std::stable_sort(CaseRanges.begin(), CaseRanges.end());
621
622 // Scan the ranges, computing the high values and removing empty ranges.
623 std::vector<llvm::APSInt> HiVals;
624 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
625 llvm::APSInt &LoVal = CaseRanges[i].first;
626 CaseStmt *CR = CaseRanges[i].second;
627 Expr *Hi = CR->getRHS();
628 llvm::APSInt HiVal = Hi->EvaluateAsInt(Context);
629
630 // Convert the value to the same width/sign as the condition.
631 ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
632 Hi->getLocStart(),
633 diag::warn_case_value_overflow);
634
635 // If the LHS is not the same type as the condition, insert an implicit
636 // cast.
637 Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
638 CR->setRHS(Hi);
639
640 // If the low value is bigger than the high value, the case is empty.
641 if (LoVal > HiVal) {
642 Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
643 << SourceRange(CR->getLHS()->getLocStart(),
644 Hi->getLocEnd());
645 CaseRanges.erase(CaseRanges.begin()+i);
646 --i, --e;
647 continue;
648 }
649
650 if (ShouldCheckConstantCond &&
651 LoVal <= ConstantCondValue &&
652 ConstantCondValue <= HiVal)
653 ShouldCheckConstantCond = false;
654
655 HiVals.push_back(HiVal);
656 }
657
658 // Rescan the ranges, looking for overlap with singleton values and other
659 // ranges. Since the range list is sorted, we only need to compare case
660 // ranges with their neighbors.
661 for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {
662 llvm::APSInt &CRLo = CaseRanges[i].first;
663 llvm::APSInt &CRHi = HiVals[i];
664 CaseStmt *CR = CaseRanges[i].second;
665
666 // Check to see whether the case range overlaps with any
667 // singleton cases.
668 CaseStmt *OverlapStmt = 0;
669 llvm::APSInt OverlapVal(32);
670
671 // Find the smallest value >= the lower bound. If I is in the
672 // case range, then we have overlap.
673 CaseValsTy::iterator I = std::lower_bound(CaseVals.begin(),
674 CaseVals.end(), CRLo,
675 CaseCompareFunctor());
676 if (I != CaseVals.end() && I->first < CRHi) {
677 OverlapVal = I->first; // Found overlap with scalar.
678 OverlapStmt = I->second;
679 }
680
681 // Find the smallest value bigger than the upper bound.
682 I = std::upper_bound(I, CaseVals.end(), CRHi, CaseCompareFunctor());
683 if (I != CaseVals.begin() && (I-1)->first >= CRLo) {
684 OverlapVal = (I-1)->first; // Found overlap with scalar.
685 OverlapStmt = (I-1)->second;
686 }
687
688 // Check to see if this case stmt overlaps with the subsequent
689 // case range.
690 if (i && CRLo <= HiVals[i-1]) {
691 OverlapVal = HiVals[i-1]; // Found overlap with range.
692 OverlapStmt = CaseRanges[i-1].second;
693 }
694
695 if (OverlapStmt) {
696 // If we have a duplicate, report it.
697 Diag(CR->getLHS()->getLocStart(), diag::err_duplicate_case)
698 << OverlapVal.toString(10);
699 Diag(OverlapStmt->getLHS()->getLocStart(),
700 diag::note_duplicate_case_prev);
701 // FIXME: We really want to remove the bogus case stmt from the
702 // substmt, but we have no way to do this right now.
703 CaseListIsErroneous = true;
704 }
705 }
706 }
707
708 // Complain if we have a constant condition and we didn't find a match.
709 if (!CaseListIsErroneous && ShouldCheckConstantCond) {
710 // TODO: it would be nice if we printed enums as enums, chars as
711 // chars, etc.
712 Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
713 << ConstantCondValue.toString(10)
714 << CondExpr->getSourceRange();
715 }
716
717 // Check to see if switch is over an Enum and handles all of its
718 // values. We only issue a warning if there is not 'default:', but
719 // we still do the analysis to preserve this information in the AST
720 // (which can be used by flow-based analyes).
721 //
722 const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
723
724 // If switch has default case, then ignore it.
725 if (!CaseListIsErroneous && !HasConstantCond && ET) {
726 const EnumDecl *ED = ET->getDecl();
727 typedef llvm::SmallVector<std::pair<llvm::APSInt, EnumConstantDecl*>, 64>
728 EnumValsTy;
729 EnumValsTy EnumVals;
730
731 // Gather all enum values, set their type and sort them,
732 // allowing easier comparison with CaseVals.
733 for (EnumDecl::enumerator_iterator EDI = ED->enumerator_begin();
734 EDI != ED->enumerator_end(); ++EDI) {
735 llvm::APSInt Val = EDI->getInitVal();
736 AdjustAPSInt(Val, CondWidth, CondIsSigned);
737 EnumVals.push_back(std::make_pair(Val, *EDI));
738 }
739 std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
740 EnumValsTy::iterator EIend =
741 std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
742
743 // See which case values aren't in enum.
744 // TODO: we might want to check whether case values are out of the
745 // enum even if we don't want to check whether all cases are handled.
746 if (!TheDefaultStmt) {
747 EnumValsTy::const_iterator EI = EnumVals.begin();
748 for (CaseValsTy::const_iterator CI = CaseVals.begin();
749 CI != CaseVals.end(); CI++) {
750 while (EI != EIend && EI->first < CI->first)
751 EI++;
752 if (EI == EIend || EI->first > CI->first)
753 Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
754 << ED->getDeclName();
755 }
756 // See which of case ranges aren't in enum
757 EI = EnumVals.begin();
758 for (CaseRangesTy::const_iterator RI = CaseRanges.begin();
759 RI != CaseRanges.end() && EI != EIend; RI++) {
760 while (EI != EIend && EI->first < RI->first)
761 EI++;
762
763 if (EI == EIend || EI->first != RI->first) {
764 Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
765 << ED->getDeclName();
766 }
767
768 llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context);
769 AdjustAPSInt(Hi, CondWidth, CondIsSigned);
770 while (EI != EIend && EI->first < Hi)
771 EI++;
772 if (EI == EIend || EI->first != Hi)
773 Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
774 << ED->getDeclName();
775 }
776 }
777
778 // Check which enum vals aren't in switch
779 CaseValsTy::const_iterator CI = CaseVals.begin();
780 CaseRangesTy::const_iterator RI = CaseRanges.begin();
781 bool hasCasesNotInSwitch = false;
782
783 llvm::SmallVector<DeclarationName,8> UnhandledNames;
784
785 for (EnumValsTy::const_iterator EI = EnumVals.begin(); EI != EIend; EI++){
786 // Drop unneeded case values
787 llvm::APSInt CIVal;
788 while (CI != CaseVals.end() && CI->first < EI->first)
789 CI++;
790
791 if (CI != CaseVals.end() && CI->first == EI->first)
792 continue;
793
794 // Drop unneeded case ranges
795 for (; RI != CaseRanges.end(); RI++) {
796 llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context);
797 AdjustAPSInt(Hi, CondWidth, CondIsSigned);
798 if (EI->first <= Hi)
799 break;
800 }
801
802 if (RI == CaseRanges.end() || EI->first < RI->first) {
803 hasCasesNotInSwitch = true;
804 if (!TheDefaultStmt)
805 UnhandledNames.push_back(EI->second->getDeclName());
806 }
807 }
808
809 // Produce a nice diagnostic if multiple values aren't handled.
810 switch (UnhandledNames.size()) {
811 case 0: break;
812 case 1:
813 Diag(CondExpr->getExprLoc(), diag::warn_missing_case1)
814 << UnhandledNames[0];
815 break;
816 case 2:
817 Diag(CondExpr->getExprLoc(), diag::warn_missing_case2)
818 << UnhandledNames[0] << UnhandledNames[1];
819 break;
820 case 3:
821 Diag(CondExpr->getExprLoc(), diag::warn_missing_case3)
822 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
823 break;
824 default:
825 Diag(CondExpr->getExprLoc(), diag::warn_missing_cases)
826 << (unsigned)UnhandledNames.size()
827 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
828 break;
829 }
830
831 if (!hasCasesNotInSwitch)
832 SS->setAllEnumCasesCovered();
833 }
834 }
835
836 // FIXME: If the case list was broken is some way, we don't have a good system
837 // to patch it up. Instead, just return the whole substmt as broken.
838 if (CaseListIsErroneous)
839 return StmtError();
840
841 return Owned(SS);
842}
843
844StmtResult
845Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
846 Decl *CondVar, Stmt *Body) {
847 ExprResult CondResult(Cond.release());
848
849 VarDecl *ConditionVar = 0;
850 if (CondVar) {
851 ConditionVar = cast<VarDecl>(CondVar);
852 CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
853 if (CondResult.isInvalid())
854 return StmtError();
855 }
856 Expr *ConditionExpr = CondResult.take();
857 if (!ConditionExpr)
858 return StmtError();
859
860 DiagnoseUnusedExprResult(Body);
861
862 return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
863 Body, WhileLoc));
864}
865
866StmtResult
867Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
868 SourceLocation WhileLoc, SourceLocation CondLParen,
869 Expr *Cond, SourceLocation CondRParen) {
870 assert(Cond && "ActOnDoStmt(): missing expression");
871
872 ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
873 if (CondResult.isInvalid() || CondResult.isInvalid())
874 return StmtError();
875 Cond = CondResult.take();
876
877 CheckImplicitConversions(Cond, DoLoc);
878 CondResult = MaybeCreateExprWithCleanups(Cond);
879 if (CondResult.isInvalid())
880 return StmtError();
881 Cond = CondResult.take();
882
883 DiagnoseUnusedExprResult(Body);
884
885 return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
886}
887
888StmtResult
889Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
890 Stmt *First, FullExprArg second, Decl *secondVar,
891 FullExprArg third,
892 SourceLocation RParenLoc, Stmt *Body) {
893 if (!getLangOptions().CPlusPlus) {
894 if (DeclStmt *DS = dyn_cast_or_null<DeclStmt>(First)) {
895 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
896 // declare identifiers for objects having storage class 'auto' or
897 // 'register'.
898 for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
899 DI!=DE; ++DI) {
900 VarDecl *VD = dyn_cast<VarDecl>(*DI);
901 if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
902 VD = 0;
903 if (VD == 0)
904 Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
905 // FIXME: mark decl erroneous!
906 }
907 }
908 }
909
910 ExprResult SecondResult(second.release());
911 VarDecl *ConditionVar = 0;
912 if (secondVar) {
913 ConditionVar = cast<VarDecl>(secondVar);
914 SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
915 if (SecondResult.isInvalid())
916 return StmtError();
917 }
918
919 Expr *Third = third.release().takeAs<Expr>();
920
921 DiagnoseUnusedExprResult(First);
922 DiagnoseUnusedExprResult(Third);
923 DiagnoseUnusedExprResult(Body);
924
925 return Owned(new (Context) ForStmt(Context, First,
926 SecondResult.take(), ConditionVar,
927 Third, Body, ForLoc, LParenLoc,
928 RParenLoc));
929}
930
931/// In an Objective C collection iteration statement:
932/// for (x in y)
933/// x can be an arbitrary l-value expression. Bind it up as a
934/// full-expression.
935StmtResult Sema::ActOnForEachLValueExpr(Expr *E) {
936 CheckImplicitConversions(E);
937 ExprResult Result = MaybeCreateExprWithCleanups(E);
938 if (Result.isInvalid()) return StmtError();
939 return Owned(static_cast<Stmt*>(Result.get()));
940}
941
942StmtResult
943Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
944 SourceLocation LParenLoc,
945 Stmt *First, Expr *Second,
946 SourceLocation RParenLoc, Stmt *Body) {
947 if (First) {
948 QualType FirstType;
949 if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {
950 if (!DS->isSingleDecl())
951 return StmtError(Diag((*DS->decl_begin())->getLocation(),
952 diag::err_toomany_element_decls));
953
| 143 const ObjCMethodDecl *MD = ME->getMethodDecl();
144 if (MD && MD->getAttr<WarnUnusedResultAttr>()) {
145 Diag(Loc, diag::warn_unused_call) << R1 << R2 << "warn_unused_result";
146 return;
147 }
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()))
154 return;
155 }
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();
160
161 // We really do want to use the non-canonical type here.
162 if (T == Context.VoidPtrTy) {
163 PointerTypeLoc TL = cast<PointerTypeLoc>(TI->getTypeLoc());
164
165 Diag(Loc, diag::warn_unused_voidptr)
166 << FixItHint::CreateRemoval(TL.getStarLoc());
167 return;
168 }
169 }
170
171 DiagRuntimeBehavior(Loc, 0, PDiag(DiagID) << R1 << R2);
172}
173
174StmtResult
175Sema::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.
183 unsigned i = 0;
184 // Skip over all declarations.
185 for (; i != NumElts && isa<DeclStmt>(Elts[i]); ++i)
186 /*empty*/;
187
188 // We found the end of the list or a statement. Scan for another declstmt.
189 for (; i != NumElts && !isa<DeclStmt>(Elts[i]); ++i)
190 /*empty*/;
191
192 if (i != NumElts) {
193 Decl *D = *cast<DeclStmt>(Elts[i])->decl_begin();
194 Diag(D->getLocation(), diag::ext_mixed_decls_code);
195 }
196 }
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)
201 continue;
202
203 DiagnoseUnusedExprResult(Elts[i]);
204 }
205
206 return Owned(new (Context) CompoundStmt(Context, Elts, NumElts, L, R));
207}
208
209StmtResult
210Sema::ActOnCaseStmt(SourceLocation CaseLoc, Expr *LHSVal,
211 SourceLocation DotDotDotLoc, Expr *RHSVal,
212 SourceLocation ColonLoc) {
213 assert((LHSVal != 0) && "missing expression in case statement");
214
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))
219 return StmtError();
220
221 // GCC extension: The expression shall be an integer constant.
222
223 if (RHSVal && !RHSVal->isTypeDependent() && !RHSVal->isValueDependent() &&
224 VerifyIntegerConstantExpression(RHSVal)) {
225 RHSVal = 0; // Recover by just forgetting about it.
226 }
227
228 if (getCurFunction()->SwitchStack.empty()) {
229 Diag(CaseLoc, diag::err_case_not_in_switch);
230 return StmtError();
231 }
232
233 CaseStmt *CS = new (Context) CaseStmt(LHSVal, RHSVal, CaseLoc, DotDotDotLoc,
234 ColonLoc);
235 getCurFunction()->SwitchStack.back()->addSwitchCase(CS);
236 return Owned(CS);
237}
238
239/// ActOnCaseStmtBody - This installs a statement as the body of a case.
240void Sema::ActOnCaseStmtBody(Stmt *caseStmt, Stmt *SubStmt) {
241 CaseStmt *CS = static_cast<CaseStmt*>(caseStmt);
242 CS->setSubStmt(SubStmt);
243}
244
245StmtResult
246Sema::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);
251 }
252
253 DefaultStmt *DS = new (Context) DefaultStmt(DefaultLoc, ColonLoc, SubStmt);
254 getCurFunction()->SwitchStack.back()->addSwitchCase(DS);
255 return Owned(DS);
256}
257
258StmtResult
259Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
260 SourceLocation ColonLoc, Stmt *SubStmt) {
261
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);
267 }
268
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);
274 return Owned(LS);
275}
276
277StmtResult
278Sema::ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, Decl *CondVar,
279 Stmt *thenStmt, SourceLocation ElseLoc,
280 Stmt *elseStmt) {
281 ExprResult CondResult(CondVal.release());
282
283 VarDecl *ConditionVar = 0;
284 if (CondVar) {
285 ConditionVar = cast<VarDecl>(CondVar);
286 CondResult = CheckConditionVariable(ConditionVar, IfLoc, true);
287 if (CondResult.isInvalid())
288 return StmtError();
289 }
290 Expr *ConditionExpr = CondResult.takeAs<Expr>();
291 if (!ConditionExpr)
292 return StmtError();
293
294 DiagnoseUnusedExprResult(thenStmt);
295
296 // Warn if the if block has a null body without an else value.
297 // this helps prevent bugs due to typos, such as
298 // if (condition);
299 // do_stuff();
300 //
301 if (!elseStmt) {
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:
304 //
305 // #define CALL(x)
306 // if (condition)
307 // CALL(0);
308 //
309 if (!stmt->hasLeadingEmptyMacro())
310 Diag(stmt->getSemiLoc(), diag::warn_empty_if_body);
311 }
312
313 DiagnoseUnusedExprResult(elseStmt);
314
315 return Owned(new (Context) IfStmt(Context, IfLoc, ConditionVar, ConditionExpr,
316 thenStmt, ElseLoc, elseStmt));
317}
318
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.
322void Sema::ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &Val,
323 unsigned NewWidth, bool NewSign,
324 SourceLocation Loc,
325 unsigned DiagID) {
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);
331
332 // If the input was signed and negative and the output is
333 // unsigned, don't bother to warn: this is implementation-defined
334 // behavior.
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());
343 if (ConvVal != Val)
344 Diag(Loc, DiagID) << Val.toString(10) << ConvVal.toString(10);
345
346 // Regardless of whether a diagnostic was emitted, really do the
347 // truncation.
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
354 // behavior.
355 // FIXME: Introduce a second, default-ignored warning for this case?
356 llvm::APSInt OldVal(Val);
357 Val.setIsSigned(NewSign);
358 }
359}
360
361namespace {
362 struct CaseCompareFunctor {
363 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
364 const llvm::APSInt &RHS) {
365 return LHS.first < RHS;
366 }
367 bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
368 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
369 return LHS.first < RHS.first;
370 }
371 bool operator()(const llvm::APSInt &LHS,
372 const std::pair<llvm::APSInt, CaseStmt*> &RHS) {
373 return LHS < RHS.first;
374 }
375 };
376}
377
378/// CmpCaseVals - Comparison predicate for sorting case values.
379///
380static bool CmpCaseVals(const std::pair<llvm::APSInt, CaseStmt*>& lhs,
381 const std::pair<llvm::APSInt, CaseStmt*>& rhs) {
382 if (lhs.first < rhs.first)
383 return true;
384
385 if (lhs.first == rhs.first &&
386 lhs.second->getCaseLoc().getRawEncoding()
387 < rhs.second->getCaseLoc().getRawEncoding())
388 return true;
389 return false;
390}
391
392/// CmpEnumVals - Comparison predicate for sorting enumeration values.
393///
394static bool CmpEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
395 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
396{
397 return lhs.first < rhs.first;
398}
399
400/// EqEnumVals - Comparison preficate for uniqing enumeration values.
401///
402static bool EqEnumVals(const std::pair<llvm::APSInt, EnumConstantDecl*>& lhs,
403 const std::pair<llvm::APSInt, EnumConstantDecl*>& rhs)
404{
405 return lhs.first == rhs.first;
406}
407
408/// GetTypeBeforeIntegralPromotion - Returns the pre-promotion type of
409/// potentially integral-promoted expression @p expr.
410static 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;
416 }
417 }
418 return expr->getType();
419}
420
421StmtResult
422Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, Expr *Cond,
423 Decl *CondVar) {
424 ExprResult CondResult;
425
426 VarDecl *ConditionVar = 0;
427 if (CondVar) {
428 ConditionVar = cast<VarDecl>(CondVar);
429 CondResult = CheckConditionVariable(ConditionVar, SourceLocation(), false);
430 if (CondResult.isInvalid())
431 return StmtError();
432
433 Cond = CondResult.release();
434 }
435
436 if (!Cond)
437 return StmtError();
438
439 CondResult
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),
448 PDiag(0));
449 if (CondResult.isInvalid()) return StmtError();
450 Cond = CondResult.take();
451
452 if (!CondVar) {
453 CheckImplicitConversions(Cond, SwitchLoc);
454 CondResult = MaybeCreateExprWithCleanups(Cond);
455 if (CondResult.isInvalid())
456 return StmtError();
457 Cond = CondResult.take();
458 }
459
460 getCurFunction()->setHasBranchIntoScope();
461
462 SwitchStmt *SS = new (Context) SwitchStmt(Context, ConditionVar, Cond);
463 getCurFunction()->SwitchStack.push_back(SS);
464 return Owned(SS);
465}
466
467static 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);
473}
474
475StmtResult
476Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
477 Stmt *BodyStmt) {
478 SwitchStmt *SS = cast<SwitchStmt>(Switch);
479 assert(SS == getCurFunction()->SwitchStack.back() &&
480 "switch stack missing push/pop!");
481
482 SS->setBody(BodyStmt, SwitchLoc);
483 getCurFunction()->SwitchStack.pop_back();
484
485 if (SS->getCond() == 0)
486 return StmtError();
487
488 Expr *CondExpr = SS->getCond();
489 Expr *CondExprBeforePromotion = CondExpr;
490 QualType CondTypeBeforePromotion =
491 GetTypeBeforeIntegralPromotion(CondExpr);
492
493 // C99 6.8.4.2p5 - Integer promotions are performed on the controlling expr.
494 ExprResult CondResult = UsualUnaryConversions(CondExpr);
495 if (CondResult.isInvalid())
496 return StmtError();
497 CondExpr = CondResult.take();
498 QualType CondType = CondExpr->getType();
499 SS->setCond(CondExpr);
500
501 // C++ 6.4.2.p2:
502 // Integral promotions are performed (on the switch condition).
503 //
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())
513 return StmtError();
514
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();
521 }
522 }
523
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();
528 unsigned CondWidth
529 = HasDependentValue ? 0 : Context.getIntWidth(CondTypeBeforePromotion);
530 bool CondIsSigned
531 = CondTypeBeforePromotion->isSignedIntegerOrEnumerationType();
532
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;
537 CaseValsTy CaseVals;
538
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;
542
543 DefaultStmt *TheDefaultStmt = 0;
544
545 bool CaseListIsErroneous = false;
546
547 for (SwitchCase *SC = SS->getSwitchCaseList(); SC && !HasDependentValue;
548 SC = SC->getNextSwitchCase()) {
549
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);
554
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;
560 }
561 TheDefaultStmt = DS;
562
563 } else {
564 CaseStmt *CS = cast<CaseStmt>(SC);
565
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();
569
570 if (Lo->isTypeDependent() || Lo->isValueDependent()) {
571 HasDependentValue = true;
572 break;
573 }
574
575 llvm::APSInt LoVal = Lo->EvaluateAsInt(Context);
576
577 // Convert the value to the same width/sign as the condition.
578 ConvertIntegerToTypeWarnOnOverflow(LoVal, CondWidth, CondIsSigned,
579 Lo->getLocStart(),
580 diag::warn_case_value_overflow);
581
582 // If the LHS is not the same type as the condition, insert an implicit
583 // cast.
584 Lo = ImpCastExprToType(Lo, CondType, CK_IntegralCast).take();
585 CS->setLHS(Lo);
586
587 // If this is a case range, remember it in CaseRanges, otherwise CaseVals.
588 if (CS->getRHS()) {
589 if (CS->getRHS()->isTypeDependent() ||
590 CS->getRHS()->isValueDependent()) {
591 HasDependentValue = true;
592 break;
593 }
594 CaseRanges.push_back(std::make_pair(LoVal, CS));
595 } else
596 CaseVals.push_back(std::make_pair(LoVal, CS));
597 }
598 }
599
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;
613
614 assert(ConstantCondValue.getBitWidth() == CondWidth &&
615 ConstantCondValue.isSigned() == CondIsSigned);
616 }
617 }
618
619 // Sort all the scalar case values so we can easily detect duplicates.
620 std::stable_sort(CaseVals.begin(), CaseVals.end(), CmpCaseVals);
621
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;
627
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;
637 }
638 }
639 }
640
641 // Detect duplicate case ranges, which usually don't exist at all in
642 // the first place.
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());
647
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);
655
656 // Convert the value to the same width/sign as the condition.
657 ConvertIntegerToTypeWarnOnOverflow(HiVal, CondWidth, CondIsSigned,
658 Hi->getLocStart(),
659 diag::warn_case_value_overflow);
660
661 // If the LHS is not the same type as the condition, insert an implicit
662 // cast.
663 Hi = ImpCastExprToType(Hi, CondType, CK_IntegralCast).take();
664 CR->setRHS(Hi);
665
666 // If the low value is bigger than the high value, the case is empty.
667 if (LoVal > HiVal) {
668 Diag(CR->getLHS()->getLocStart(), diag::warn_case_empty_range)
669 << SourceRange(CR->getLHS()->getLocStart(),
670 Hi->getLocEnd());
671 CaseRanges.erase(CaseRanges.begin()+i);
672 --i, --e;
673 continue;
674 }
675
676 if (ShouldCheckConstantCond &&
677 LoVal <= ConstantCondValue &&
678 ConstantCondValue <= HiVal)
679 ShouldCheckConstantCond = false;
680
681 HiVals.push_back(HiVal);
682 }
683
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;
691
692 // Check to see whether the case range overlaps with any
693 // singleton cases.
694 CaseStmt *OverlapStmt = 0;
695 llvm::APSInt OverlapVal(32);
696
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;
705 }
706
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;
712 }
713
714 // Check to see if this case stmt overlaps with the subsequent
715 // case range.
716 if (i && CRLo <= HiVals[i-1]) {
717 OverlapVal = HiVals[i-1]; // Found overlap with range.
718 OverlapStmt = CaseRanges[i-1].second;
719 }
720
721 if (OverlapStmt) {
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;
730 }
731 }
732 }
733
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
737 // chars, etc.
738 Diag(CondExpr->getExprLoc(), diag::warn_missing_case_for_condition)
739 << ConstantCondValue.toString(10)
740 << CondExpr->getSourceRange();
741 }
742
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).
747 //
748 const EnumType *ET = CondTypeBeforePromotion->getAs<EnumType>();
749
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>
754 EnumValsTy;
755 EnumValsTy EnumVals;
756
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));
764 }
765 std::stable_sort(EnumVals.begin(), EnumVals.end(), CmpEnumVals);
766 EnumValsTy::iterator EIend =
767 std::unique(EnumVals.begin(), EnumVals.end(), EqEnumVals);
768
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)
777 EI++;
778 if (EI == EIend || EI->first > CI->first)
779 Diag(CI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
780 << ED->getDeclName();
781 }
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)
787 EI++;
788
789 if (EI == EIend || EI->first != RI->first) {
790 Diag(RI->second->getLHS()->getExprLoc(), diag::warn_not_in_enum)
791 << ED->getDeclName();
792 }
793
794 llvm::APSInt Hi = RI->second->getRHS()->EvaluateAsInt(Context);
795 AdjustAPSInt(Hi, CondWidth, CondIsSigned);
796 while (EI != EIend && EI->first < Hi)
797 EI++;
798 if (EI == EIend || EI->first != Hi)
799 Diag(RI->second->getRHS()->getExprLoc(), diag::warn_not_in_enum)
800 << ED->getDeclName();
801 }
802 }
803
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;
808
809 llvm::SmallVector<DeclarationName,8> UnhandledNames;
810
811 for (EnumValsTy::const_iterator EI = EnumVals.begin(); EI != EIend; EI++){
812 // Drop unneeded case values
813 llvm::APSInt CIVal;
814 while (CI != CaseVals.end() && CI->first < EI->first)
815 CI++;
816
817 if (CI != CaseVals.end() && CI->first == EI->first)
818 continue;
819
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);
824 if (EI->first <= Hi)
825 break;
826 }
827
828 if (RI == CaseRanges.end() || EI->first < RI->first) {
829 hasCasesNotInSwitch = true;
830 if (!TheDefaultStmt)
831 UnhandledNames.push_back(EI->second->getDeclName());
832 }
833 }
834
835 // Produce a nice diagnostic if multiple values aren't handled.
836 switch (UnhandledNames.size()) {
837 case 0: break;
838 case 1:
839 Diag(CondExpr->getExprLoc(), diag::warn_missing_case1)
840 << UnhandledNames[0];
841 break;
842 case 2:
843 Diag(CondExpr->getExprLoc(), diag::warn_missing_case2)
844 << UnhandledNames[0] << UnhandledNames[1];
845 break;
846 case 3:
847 Diag(CondExpr->getExprLoc(), diag::warn_missing_case3)
848 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
849 break;
850 default:
851 Diag(CondExpr->getExprLoc(), diag::warn_missing_cases)
852 << (unsigned)UnhandledNames.size()
853 << UnhandledNames[0] << UnhandledNames[1] << UnhandledNames[2];
854 break;
855 }
856
857 if (!hasCasesNotInSwitch)
858 SS->setAllEnumCasesCovered();
859 }
860 }
861
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)
865 return StmtError();
866
867 return Owned(SS);
868}
869
870StmtResult
871Sema::ActOnWhileStmt(SourceLocation WhileLoc, FullExprArg Cond,
872 Decl *CondVar, Stmt *Body) {
873 ExprResult CondResult(Cond.release());
874
875 VarDecl *ConditionVar = 0;
876 if (CondVar) {
877 ConditionVar = cast<VarDecl>(CondVar);
878 CondResult = CheckConditionVariable(ConditionVar, WhileLoc, true);
879 if (CondResult.isInvalid())
880 return StmtError();
881 }
882 Expr *ConditionExpr = CondResult.take();
883 if (!ConditionExpr)
884 return StmtError();
885
886 DiagnoseUnusedExprResult(Body);
887
888 return Owned(new (Context) WhileStmt(Context, ConditionVar, ConditionExpr,
889 Body, WhileLoc));
890}
891
892StmtResult
893Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
894 SourceLocation WhileLoc, SourceLocation CondLParen,
895 Expr *Cond, SourceLocation CondRParen) {
896 assert(Cond && "ActOnDoStmt(): missing expression");
897
898 ExprResult CondResult = CheckBooleanCondition(Cond, DoLoc);
899 if (CondResult.isInvalid() || CondResult.isInvalid())
900 return StmtError();
901 Cond = CondResult.take();
902
903 CheckImplicitConversions(Cond, DoLoc);
904 CondResult = MaybeCreateExprWithCleanups(Cond);
905 if (CondResult.isInvalid())
906 return StmtError();
907 Cond = CondResult.take();
908
909 DiagnoseUnusedExprResult(Body);
910
911 return Owned(new (Context) DoStmt(Body, Cond, DoLoc, WhileLoc, CondRParen));
912}
913
914StmtResult
915Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
916 Stmt *First, FullExprArg second, Decl *secondVar,
917 FullExprArg third,
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
923 // 'register'.
924 for (DeclStmt::decl_iterator DI=DS->decl_begin(), DE=DS->decl_end();
925 DI!=DE; ++DI) {
926 VarDecl *VD = dyn_cast<VarDecl>(*DI);
927 if (VD && VD->isLocalVarDecl() && !VD->hasLocalStorage())
928 VD = 0;
929 if (VD == 0)
930 Diag((*DI)->getLocation(), diag::err_non_variable_decl_in_for);
931 // FIXME: mark decl erroneous!
932 }
933 }
934 }
935
936 ExprResult SecondResult(second.release());
937 VarDecl *ConditionVar = 0;
938 if (secondVar) {
939 ConditionVar = cast<VarDecl>(secondVar);
940 SecondResult = CheckConditionVariable(ConditionVar, ForLoc, true);
941 if (SecondResult.isInvalid())
942 return StmtError();
943 }
944
945 Expr *Third = third.release().takeAs<Expr>();
946
947 DiagnoseUnusedExprResult(First);
948 DiagnoseUnusedExprResult(Third);
949 DiagnoseUnusedExprResult(Body);
950
951 return Owned(new (Context) ForStmt(Context, First,
952 SecondResult.take(), ConditionVar,
953 Third, Body, ForLoc, LParenLoc,
954 RParenLoc));
955}
956
957/// In an Objective C collection iteration statement:
958/// for (x in y)
959/// x can be an arbitrary l-value expression. Bind it up as a
960/// full-expression.
961StmtResult 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()));
966}
967
968StmtResult
969Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc,
970 SourceLocation LParenLoc,
971 Stmt *First, Expr *Second,
972 SourceLocation RParenLoc, Stmt *Body) {
973 if (First) {
974 QualType FirstType;
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));
979
|
954 Decl *D = DS->getSingleDecl();
955 FirstType = cast<ValueDecl>(D)->getType();
| 980 VarDecl *D = cast<VarDecl>(DS->getSingleDecl());
981 FirstType = D->getType();
|
956 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
957 // declare identifiers for objects having storage class 'auto' or
958 // 'register'.
| 982 // C99 6.8.5p3: The declaration part of a 'for' statement shall only
983 // declare identifiers for objects having storage class 'auto' or
984 // 'register'.
|
959 VarDecl *VD = cast<VarDecl>(D);
960 if (VD->isLocalVarDecl() && !VD->hasLocalStorage())
961 return StmtError(Diag(VD->getLocation(),
| 985 if (!D->hasLocalStorage())
986 return StmtError(Diag(D->getLocation(),
|
962 diag::err_non_variable_decl_in_for));
963 } else {
964 Expr *FirstE = cast<Expr>(First);
965 if (!FirstE->isTypeDependent() && !FirstE->isLValue())
966 return StmtError(Diag(First->getLocStart(),
967 diag::err_selector_element_not_lvalue)
968 << First->getSourceRange());
969
970 FirstType = static_cast<Expr*>(First)->getType();
971 }
972 if (!FirstType->isDependentType() &&
973 !FirstType->isObjCObjectPointerType() &&
974 !FirstType->isBlockPointerType())
975 Diag(ForLoc, diag::err_selector_element_type)
976 << FirstType << First->getSourceRange();
977 }
978 if (Second && !Second->isTypeDependent()) {
979 ExprResult Result = DefaultFunctionArrayLvalueConversion(Second);
980 if (Result.isInvalid())
981 return StmtError();
982 Second = Result.take();
983 QualType SecondType = Second->getType();
984 if (!SecondType->isObjCObjectPointerType())
985 Diag(ForLoc, diag::err_collection_expr_type)
986 << SecondType << Second->getSourceRange();
987 else if (const ObjCObjectPointerType *OPT =
988 SecondType->getAsObjCInterfacePointerType()) {
989 llvm::SmallVector<IdentifierInfo *, 4> KeyIdents;
990 IdentifierInfo* selIdent =
991 &Context.Idents.get("countByEnumeratingWithState");
992 KeyIdents.push_back(selIdent);
993 selIdent = &Context.Idents.get("objects");
994 KeyIdents.push_back(selIdent);
995 selIdent = &Context.Idents.get("count");
996 KeyIdents.push_back(selIdent);
997 Selector CSelector = Context.Selectors.getSelector(3, &KeyIdents[0]);
998 if (ObjCInterfaceDecl *IDecl = OPT->getInterfaceDecl()) {
999 if (!IDecl->isForwardDecl() &&
1000 !IDecl->lookupInstanceMethod(CSelector) &&
1001 !LookupMethodInQualifiedType(CSelector, OPT, true)) {
1002 // Must further look into private implementation methods.
1003 if (!LookupPrivateInstanceMethod(CSelector, IDecl))
1004 Diag(ForLoc, diag::warn_collection_expr_type)
1005 << SecondType << CSelector << Second->getSourceRange();
1006 }
1007 }
1008 }
1009 }
1010 return Owned(new (Context) ObjCForCollectionStmt(First, Second, Body,
1011 ForLoc, RParenLoc));
1012}
1013
1014namespace {
1015
1016enum BeginEndFunction {
1017 BEF_begin,
1018 BEF_end
1019};
1020
1021/// Build a variable declaration for a for-range statement.
1022static VarDecl *BuildForRangeVarDecl(Sema &SemaRef, SourceLocation Loc,
1023 QualType Type, const char *Name) {
1024 DeclContext *DC = SemaRef.CurContext;
1025 IdentifierInfo *II = &SemaRef.PP.getIdentifierTable().get(Name);
1026 TypeSourceInfo *TInfo = SemaRef.Context.getTrivialTypeSourceInfo(Type, Loc);
1027 VarDecl *Decl = VarDecl::Create(SemaRef.Context, DC, Loc, Loc, II, Type,
1028 TInfo, SC_Auto, SC_None);
1029 Decl->setImplicit();
1030 return Decl;
1031}
1032
1033/// Finish building a variable declaration for a for-range statement.
1034/// \return true if an error occurs.
1035static bool FinishForRangeVarDecl(Sema &SemaRef, VarDecl *Decl, Expr *Init,
1036 SourceLocation Loc, int diag) {
1037 // Deduce the type for the iterator variable now rather than leaving it to
1038 // AddInitializerToDecl, so we can produce a more suitable diagnostic.
1039 TypeSourceInfo *InitTSI = 0;
1040 if (Init->getType()->isVoidType() ||
1041 !SemaRef.DeduceAutoType(Decl->getTypeSourceInfo(), Init, InitTSI))
1042 SemaRef.Diag(Loc, diag) << Init->getType();
1043 if (!InitTSI) {
1044 Decl->setInvalidDecl();
1045 return true;
1046 }
1047 Decl->setTypeSourceInfo(InitTSI);
1048 Decl->setType(InitTSI->getType());
1049
| 987 diag::err_non_variable_decl_in_for));
988 } else {
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());
994
995 FirstType = static_cast<Expr*>(First)->getType();
996 }
997 if (!FirstType->isDependentType() &&
998 !FirstType->isObjCObjectPointerType() &&
999 !FirstType->isBlockPointerType())
1000 Diag(ForLoc, diag::err_selector_element_type)
1001 << FirstType << First->getSourceRange();
1002 }
1003 if (Second && !Second->isTypeDependent()) {
1004 ExprResult Result = DefaultFunctionArrayLvalueConversion(Second);
1005 if (Result.isInvalid())
1006 return StmtError();
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();
1031 }
1032 }
1033 }
1034 }
1035 return Owned(new (Context) ObjCForCollectionStmt(First, Second, Body,
1036 ForLoc, RParenLoc));
1037}
1038
1039namespace {
1040
1041enum BeginEndFunction {
1042 BEF_begin,
1043 BEF_end
1044};
1045
1046/// Build a variable declaration for a for-range statement.
1047static 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();
1055 return Decl;
1056}
1057
1058/// Finish building a variable declaration for a for-range statement.
1059/// \return true if an error occurs.
1060static 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();
1068 if (!InitTSI) {
1069 Decl->setInvalidDecl();
1070 return true;
1071 }
1072 Decl->setTypeSourceInfo(InitTSI);
1073 Decl->setType(InitTSI->getType());
1074
|
| 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();
1081
|
1050 SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1051 /*TypeMayContainAuto=*/false);
1052 SemaRef.FinalizeDeclaration(Decl);
1053 SemaRef.CurContext->addHiddenDecl(Decl);
1054 return false;
1055}
1056
1057/// Produce a note indicating which begin/end function was implicitly called
1058/// by a C++0x for-range statement. This is often not obvious from the code,
1059/// nor from the diagnostics produced when analysing the implicit expressions
1060/// required in a for-range statement.
1061void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1062 BeginEndFunction BEF) {
1063 CallExpr *CE = dyn_cast<CallExpr>(E);
1064 if (!CE)
1065 return;
1066 FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1067 if (!D)
1068 return;
1069 SourceLocation Loc = D->getLocation();
1070
1071 std::string Description;
1072 bool IsTemplate = false;
1073 if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1074 Description = SemaRef.getTemplateArgumentBindingsText(
1075 FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1076 IsTemplate = true;
1077 }
1078
1079 SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1080 << BEF << IsTemplate << Description << E->getType();
1081}
1082
1083/// Build a call to 'begin' or 'end' for a C++0x for-range statement. If the
1084/// given LookupResult is non-empty, it is assumed to describe a member which
1085/// will be invoked. Otherwise, the function will be found via argument
1086/// dependent lookup.
1087static ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1088 SourceLocation Loc,
1089 VarDecl *Decl,
1090 BeginEndFunction BEF,
1091 const DeclarationNameInfo &NameInfo,
1092 LookupResult &MemberLookup,
1093 Expr *Range) {
1094 ExprResult CallExpr;
1095 if (!MemberLookup.empty()) {
1096 ExprResult MemberRef =
1097 SemaRef.BuildMemberReferenceExpr(Range, Range->getType(), Loc,
1098 /*IsPtr=*/false, CXXScopeSpec(),
1099 /*Qualifier=*/0, MemberLookup,
1100 /*TemplateArgs=*/0);
1101 if (MemberRef.isInvalid())
1102 return ExprError();
1103 CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1104 Loc, 0);
1105 if (CallExpr.isInvalid())
1106 return ExprError();
1107 } else {
1108 UnresolvedSet<0> FoundNames;
1109 // C++0x [stmt.ranged]p1: For the purposes of this name lookup, namespace
1110 // std is an associated namespace.
1111 UnresolvedLookupExpr *Fn =
1112 UnresolvedLookupExpr::Create(SemaRef.Context, /*NamingClass=*/0,
1113 NestedNameSpecifierLoc(), NameInfo,
1114 /*NeedsADL=*/true, /*Overloaded=*/false,
1115 FoundNames.begin(), FoundNames.end(),
1116 /*LookInStdNamespace=*/true);
1117 CallExpr = SemaRef.BuildOverloadedCallExpr(S, Fn, Fn, Loc, &Range, 1, Loc,
1118 0);
1119 if (CallExpr.isInvalid()) {
1120 SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1121 << Range->getType();
1122 return ExprError();
1123 }
1124 }
1125 if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1126 diag::err_for_range_iter_deduction_failure)) {
1127 NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1128 return ExprError();
1129 }
1130 return CallExpr;
1131}
1132
1133}
1134
1135/// ActOnCXXForRangeStmt - Check and build a C++0x for-range statement.
1136///
1137/// C++0x [stmt.ranged]:
1138/// A range-based for statement is equivalent to
1139///
1140/// {
1141/// auto && __range = range-init;
1142/// for ( auto __begin = begin-expr,
1143/// __end = end-expr;
1144/// __begin != __end;
1145/// ++__begin ) {
1146/// for-range-declaration = *__begin;
1147/// statement
1148/// }
1149/// }
1150///
1151/// The body of the loop is not available yet, since it cannot be analysed until
1152/// we have determined the type of the for-range-declaration.
1153StmtResult
1154Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1155 Stmt *First, SourceLocation ColonLoc, Expr *Range,
1156 SourceLocation RParenLoc) {
1157 if (!First || !Range)
1158 return StmtError();
1159
1160 DeclStmt *DS = dyn_cast<DeclStmt>(First);
1161 assert(DS && "first part of for range not a decl stmt");
1162
1163 if (!DS->isSingleDecl()) {
1164 Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1165 return StmtError();
1166 }
1167 if (DS->getSingleDecl()->isInvalidDecl())
1168 return StmtError();
1169
1170 if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1171 return StmtError();
1172
1173 // Build auto && __range = range-init
1174 SourceLocation RangeLoc = Range->getLocStart();
1175 VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1176 Context.getAutoRRefDeductType(),
1177 "__range");
1178 if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1179 diag::err_for_range_deduction_failure))
1180 return StmtError();
1181
1182 // Claim the type doesn't contain auto: we've already done the checking.
1183 DeclGroupPtrTy RangeGroup =
1184 BuildDeclaratorGroup((Decl**)&RangeVar, 1, /*TypeMayContainAuto=*/false);
1185 StmtResult RangeDecl = ActOnDeclStmt(RangeGroup, RangeLoc, RangeLoc);
1186 if (RangeDecl.isInvalid())
1187 return StmtError();
1188
1189 return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1190 /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1191 RParenLoc);
1192}
1193
1194/// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1195StmtResult
1196Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1197 Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1198 Expr *Inc, Stmt *LoopVarDecl,
1199 SourceLocation RParenLoc) {
1200 Scope *S = getCurScope();
1201
1202 DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1203 VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1204 QualType RangeVarType = RangeVar->getType();
1205
1206 DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1207 VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1208
1209 StmtResult BeginEndDecl = BeginEnd;
1210 ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1211
1212 if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1213 SourceLocation RangeLoc = RangeVar->getLocation();
1214
1215 ExprResult RangeRef = BuildDeclRefExpr(RangeVar,
1216 RangeVarType.getNonReferenceType(),
1217 VK_LValue, ColonLoc);
1218 if (RangeRef.isInvalid())
1219 return StmtError();
1220
1221 QualType AutoType = Context.getAutoDeductType();
1222 Expr *Range = RangeVar->getInit();
1223 if (!Range)
1224 return StmtError();
1225 QualType RangeType = Range->getType();
1226
1227 if (RequireCompleteType(RangeLoc, RangeType,
1228 PDiag(diag::err_for_range_incomplete_type)))
1229 return StmtError();
1230
1231 // Build auto __begin = begin-expr, __end = end-expr.
1232 VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1233 "__begin");
1234 VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1235 "__end");
1236
1237 // Build begin-expr and end-expr and attach to __begin and __end variables.
1238 ExprResult BeginExpr, EndExpr;
1239 if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {
1240 // - if _RangeT is an array type, begin-expr and end-expr are __range and
1241 // __range + __bound, respectively, where __bound is the array bound. If
1242 // _RangeT is an array of unknown size or an array of incomplete type,
1243 // the program is ill-formed;
1244
1245 // begin-expr is __range.
1246 BeginExpr = RangeRef;
1247 if (FinishForRangeVarDecl(*this, BeginVar, RangeRef.get(), ColonLoc,
1248 diag::err_for_range_iter_deduction_failure)) {
1249 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1250 return StmtError();
1251 }
1252
1253 // Find the array bound.
1254 ExprResult BoundExpr;
1255 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(UnqAT))
1256 BoundExpr = Owned(IntegerLiteral::Create(Context, CAT->getSize(),
1257 Context.getPointerDiffType(),
1258 RangeLoc));
1259 else if (const VariableArrayType *VAT =
1260 dyn_cast<VariableArrayType>(UnqAT))
1261 BoundExpr = VAT->getSizeExpr();
1262 else {
1263 // Can't be a DependentSizedArrayType or an IncompleteArrayType since
1264 // UnqAT is not incomplete and Range is not type-dependent.
1265 assert(0 && "Unexpected array type in for-range");
1266 return StmtError();
1267 }
1268
1269 // end-expr is __range + __bound.
1270 EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, RangeRef.get(),
1271 BoundExpr.get());
1272 if (EndExpr.isInvalid())
1273 return StmtError();
1274 if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1275 diag::err_for_range_iter_deduction_failure)) {
1276 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1277 return StmtError();
1278 }
1279 } else {
1280 DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1281 ColonLoc);
1282 DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1283 ColonLoc);
1284
1285 LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1286 LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1287
1288 if (CXXRecordDecl *D = RangeType->getAsCXXRecordDecl()) {
1289 // - if _RangeT is a class type, the unqualified-ids begin and end are
1290 // looked up in the scope of class _RangeT as if by class member access
1291 // lookup (3.4.5), and if either (or both) finds at least one
1292 // declaration, begin-expr and end-expr are __range.begin() and
1293 // __range.end(), respectively;
1294 LookupQualifiedName(BeginMemberLookup, D);
1295 LookupQualifiedName(EndMemberLookup, D);
1296
1297 if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1298 Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1299 << RangeType << BeginMemberLookup.empty();
1300 return StmtError();
1301 }
1302 } else {
1303 // - otherwise, begin-expr and end-expr are begin(__range) and
1304 // end(__range), respectively, where begin and end are looked up with
1305 // argument-dependent lookup (3.4.2). For the purposes of this name
1306 // lookup, namespace std is an associated namespace.
1307 }
1308
1309 BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1310 BEF_begin, BeginNameInfo,
1311 BeginMemberLookup, RangeRef.get());
1312 if (BeginExpr.isInvalid())
1313 return StmtError();
1314
1315 EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1316 BEF_end, EndNameInfo,
1317 EndMemberLookup, RangeRef.get());
1318 if (EndExpr.isInvalid())
1319 return StmtError();
1320 }
1321
1322 // C++0x [decl.spec.auto]p6: BeginType and EndType must be the same.
1323 QualType BeginType = BeginVar->getType(), EndType = EndVar->getType();
1324 if (!Context.hasSameType(BeginType, EndType)) {
1325 Diag(RangeLoc, diag::err_for_range_begin_end_types_differ)
1326 << BeginType << EndType;
1327 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1328 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1329 }
1330
1331 Decl *BeginEndDecls[] = { BeginVar, EndVar };
1332 // Claim the type doesn't contain auto: we've already done the checking.
1333 DeclGroupPtrTy BeginEndGroup =
1334 BuildDeclaratorGroup(BeginEndDecls, 2, /*TypeMayContainAuto=*/false);
1335 BeginEndDecl = ActOnDeclStmt(BeginEndGroup, ColonLoc, ColonLoc);
1336
1337 ExprResult BeginRef = BuildDeclRefExpr(BeginVar,
1338 BeginType.getNonReferenceType(),
1339 VK_LValue, ColonLoc);
1340 ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1341 VK_LValue, ColonLoc);
1342
1343 // Build and check __begin != __end expression.
1344 NotEqExpr = ActOnBinOp(S, ColonLoc, tok::exclaimequal,
1345 BeginRef.get(), EndRef.get());
1346 NotEqExpr = ActOnBooleanCondition(S, ColonLoc, NotEqExpr.get());
1347 NotEqExpr = ActOnFinishFullExpr(NotEqExpr.get());
1348 if (NotEqExpr.isInvalid()) {
1349 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1350 if (!Context.hasSameType(BeginType, EndType))
1351 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1352 return StmtError();
1353 }
1354
1355 // Build and check ++__begin expression.
1356 IncrExpr = ActOnUnaryOp(S, ColonLoc, tok::plusplus, BeginRef.get());
1357 IncrExpr = ActOnFinishFullExpr(IncrExpr.get());
1358 if (IncrExpr.isInvalid()) {
1359 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1360 return StmtError();
1361 }
1362
1363 // Build and check *__begin expression.
1364 ExprResult DerefExpr = ActOnUnaryOp(S, ColonLoc, tok::star, BeginRef.get());
1365 if (DerefExpr.isInvalid()) {
1366 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1367 return StmtError();
1368 }
1369
1370 // Attach *__begin as initializer for VD.
1371 if (!LoopVar->isInvalidDecl()) {
1372 AddInitializerToDecl(LoopVar, DerefExpr.get(), /*DirectInit=*/false,
1373 /*TypeMayContainAuto=*/true);
1374 if (LoopVar->isInvalidDecl())
1375 NoteForRangeBeginEndFunction(*this, BeginExpr.get(), BEF_begin);
1376 }
| 1082 SemaRef.AddInitializerToDecl(Decl, Init, /*DirectInit=*/false,
1083 /*TypeMayContainAuto=*/false);
1084 SemaRef.FinalizeDeclaration(Decl);
1085 SemaRef.CurContext->addHiddenDecl(Decl);
1086 return false;
1087}
1088
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.
1093void NoteForRangeBeginEndFunction(Sema &SemaRef, Expr *E,
1094 BeginEndFunction BEF) {
1095 CallExpr *CE = dyn_cast<CallExpr>(E);
1096 if (!CE)
1097 return;
1098 FunctionDecl *D = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
1099 if (!D)
1100 return;
1101 SourceLocation Loc = D->getLocation();
1102
1103 std::string Description;
1104 bool IsTemplate = false;
1105 if (FunctionTemplateDecl *FunTmpl = D->getPrimaryTemplate()) {
1106 Description = SemaRef.getTemplateArgumentBindingsText(
1107 FunTmpl->getTemplateParameters(), *D->getTemplateSpecializationArgs());
1108 IsTemplate = true;
1109 }
1110
1111 SemaRef.Diag(Loc, diag::note_for_range_begin_end)
1112 << BEF << IsTemplate << Description << E->getType();
1113}
1114
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.
1119static ExprResult BuildForRangeBeginEndCall(Sema &SemaRef, Scope *S,
1120 SourceLocation Loc,
1121 VarDecl *Decl,
1122 BeginEndFunction BEF,
1123 const DeclarationNameInfo &NameInfo,
1124 LookupResult &MemberLookup,
1125 Expr *Range) {
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())
1134 return ExprError();
1135 CallExpr = SemaRef.ActOnCallExpr(S, MemberRef.get(), Loc, MultiExprArg(),
1136 Loc, 0);
1137 if (CallExpr.isInvalid())
1138 return ExprError();
1139 } else {
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,
1150 0);
1151 if (CallExpr.isInvalid()) {
1152 SemaRef.Diag(Range->getLocStart(), diag::note_for_range_type)
1153 << Range->getType();
1154 return ExprError();
1155 }
1156 }
1157 if (FinishForRangeVarDecl(SemaRef, Decl, CallExpr.get(), Loc,
1158 diag::err_for_range_iter_deduction_failure)) {
1159 NoteForRangeBeginEndFunction(SemaRef, CallExpr.get(), BEF);
1160 return ExprError();
1161 }
1162 return CallExpr;
1163}
1164
1165}
1166
1167/// ActOnCXXForRangeStmt - Check and build a C++0x for-range statement.
1168///
1169/// C++0x [stmt.ranged]:
1170/// A range-based for statement is equivalent to
1171///
1172/// {
1173/// auto && __range = range-init;
1174/// for ( auto __begin = begin-expr,
1175/// __end = end-expr;
1176/// __begin != __end;
1177/// ++__begin ) {
1178/// for-range-declaration = *__begin;
1179/// statement
1180/// }
1181/// }
1182///
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.
1185StmtResult
1186Sema::ActOnCXXForRangeStmt(SourceLocation ForLoc, SourceLocation LParenLoc,
1187 Stmt *First, SourceLocation ColonLoc, Expr *Range,
1188 SourceLocation RParenLoc) {
1189 if (!First || !Range)
1190 return StmtError();
1191
1192 DeclStmt *DS = dyn_cast<DeclStmt>(First);
1193 assert(DS && "first part of for range not a decl stmt");
1194
1195 if (!DS->isSingleDecl()) {
1196 Diag(DS->getStartLoc(), diag::err_type_defined_in_for_range);
1197 return StmtError();
1198 }
1199 if (DS->getSingleDecl()->isInvalidDecl())
1200 return StmtError();
1201
1202 if (DiagnoseUnexpandedParameterPack(Range, UPPC_Expression))
1203 return StmtError();
1204
1205 // Build auto && __range = range-init
1206 SourceLocation RangeLoc = Range->getLocStart();
1207 VarDecl *RangeVar = BuildForRangeVarDecl(*this, RangeLoc,
1208 Context.getAutoRRefDeductType(),
1209 "__range");
1210 if (FinishForRangeVarDecl(*this, RangeVar, Range, RangeLoc,
1211 diag::err_for_range_deduction_failure))
1212 return StmtError();
1213
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())
1219 return StmtError();
1220
1221 return BuildCXXForRangeStmt(ForLoc, ColonLoc, RangeDecl.get(),
1222 /*BeginEndDecl=*/0, /*Cond=*/0, /*Inc=*/0, DS,
1223 RParenLoc);
1224}
1225
1226/// BuildCXXForRangeStmt - Build or instantiate a C++0x for-range statement.
1227StmtResult
1228Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation ColonLoc,
1229 Stmt *RangeDecl, Stmt *BeginEnd, Expr *Cond,
1230 Expr *Inc, Stmt *LoopVarDecl,
1231 SourceLocation RParenLoc) {
1232 Scope *S = getCurScope();
1233
1234 DeclStmt *RangeDS = cast<DeclStmt>(RangeDecl);
1235 VarDecl *RangeVar = cast<VarDecl>(RangeDS->getSingleDecl());
1236 QualType RangeVarType = RangeVar->getType();
1237
1238 DeclStmt *LoopVarDS = cast<DeclStmt>(LoopVarDecl);
1239 VarDecl *LoopVar = cast<VarDecl>(LoopVarDS->getSingleDecl());
1240
1241 StmtResult BeginEndDecl = BeginEnd;
1242 ExprResult NotEqExpr = Cond, IncrExpr = Inc;
1243
1244 if (!BeginEndDecl.get() && !RangeVarType->isDependentType()) {
1245 SourceLocation RangeLoc = RangeVar->getLocation();
1246
1247 ExprResult RangeRef = BuildDeclRefExpr(RangeVar,
1248 RangeVarType.getNonReferenceType(),
1249 VK_LValue, ColonLoc);
1250 if (RangeRef.isInvalid())
1251 return StmtError();
1252
1253 QualType AutoType = Context.getAutoDeductType();
1254 Expr *Range = RangeVar->getInit();
1255 if (!Range)
1256 return StmtError();
1257 QualType RangeType = Range->getType();
1258
1259 if (RequireCompleteType(RangeLoc, RangeType,
1260 PDiag(diag::err_for_range_incomplete_type)))
1261 return StmtError();
1262
1263 // Build auto __begin = begin-expr, __end = end-expr.
1264 VarDecl *BeginVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1265 "__begin");
1266 VarDecl *EndVar = BuildForRangeVarDecl(*this, ColonLoc, AutoType,
1267 "__end");
1268
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;
1276
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);
1282 return StmtError();
1283 }
1284
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(),
1290 RangeLoc));
1291 else if (const VariableArrayType *VAT =
1292 dyn_cast<VariableArrayType>(UnqAT))
1293 BoundExpr = VAT->getSizeExpr();
1294 else {
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");
1298 return StmtError();
1299 }
1300
1301 // end-expr is __range + __bound.
1302 EndExpr = ActOnBinOp(S, ColonLoc, tok::plus, RangeRef.get(),
1303 BoundExpr.get());
1304 if (EndExpr.isInvalid())
1305 return StmtError();
1306 if (FinishForRangeVarDecl(*this, EndVar, EndExpr.get(), ColonLoc,
1307 diag::err_for_range_iter_deduction_failure)) {
1308 NoteForRangeBeginEndFunction(*this, EndExpr.get(), BEF_end);
1309 return StmtError();
1310 }
1311 } else {
1312 DeclarationNameInfo BeginNameInfo(&PP.getIdentifierTable().get("begin"),
1313 ColonLoc);
1314 DeclarationNameInfo EndNameInfo(&PP.getIdentifierTable().get("end"),
1315 ColonLoc);
1316
1317 LookupResult BeginMemberLookup(*this, BeginNameInfo, LookupMemberName);
1318 LookupResult EndMemberLookup(*this, EndNameInfo, LookupMemberName);
1319
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);
1328
1329 if (BeginMemberLookup.empty() != EndMemberLookup.empty()) {
1330 Diag(ColonLoc, diag::err_for_range_member_begin_end_mismatch)
1331 << RangeType << BeginMemberLookup.empty();
1332 return StmtError();
1333 }
1334 } else {
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.
1339 }
1340
1341 BeginExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, BeginVar,
1342 BEF_begin, BeginNameInfo,
1343 BeginMemberLookup, RangeRef.get());
1344 if (BeginExpr.isInvalid())
1345 return StmtError();
1346
1347 EndExpr = BuildForRangeBeginEndCall(*this, S, ColonLoc, EndVar,
1348 BEF_end, EndNameInfo,
1349 EndMemberLookup, RangeRef.get());
1350 if (EndExpr.isInvalid())
1351 return StmtError();
1352 }
1353
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);
1361 }
1362
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);
1368
1369 ExprResult BeginRef = BuildDeclRefExpr(BeginVar,
1370 BeginType.getNonReferenceType(),
1371 VK_LValue, ColonLoc);
1372 ExprResult EndRef = BuildDeclRefExpr(EndVar, EndType.getNonReferenceType(),
1373 VK_LValue, ColonLoc);
1374
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);
1384 return StmtError();
1385 }
1386
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);
1392 return StmtError();
1393 }
1394
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);
1399 return StmtError();
1400 }
1401
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);
1408 }
|
| 1409 } else {
1410 // The range is implicitly used as a placeholder when it is dependent.
1411 RangeVar->setUsed();
|
1377 }
1378
1379 return Owned(new (Context) CXXForRangeStmt(RangeDS,
1380 cast_or_null<DeclStmt>(BeginEndDecl.get()),
1381 NotEqExpr.take(), IncrExpr.take(),
1382 LoopVarDS, /*Body=*/0, ForLoc,
1383 ColonLoc, RParenLoc));
1384}
1385
1386/// FinishCXXForRangeStmt - Attach the body to a C++0x for-range statement.
1387/// This is a separate step from ActOnCXXForRangeStmt because analysis of the
1388/// body cannot be performed until after the type of the range variable is
1389/// determined.
1390StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
1391 if (!S || !B)
1392 return StmtError();
1393
1394 cast<CXXForRangeStmt>(S)->setBody(B);
1395 return S;
1396}
1397
1398StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
1399 SourceLocation LabelLoc,
1400 LabelDecl *TheDecl) {
1401 getCurFunction()->setHasBranchIntoScope();
1402 TheDecl->setUsed();
1403 return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
1404}
1405
1406StmtResult
1407Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
1408 Expr *E) {
1409 // Convert operand to void*
1410 if (!E->isTypeDependent()) {
1411 QualType ETy = E->getType();
1412 QualType DestTy = Context.getPointerType(Context.VoidTy.withConst());
1413 ExprResult ExprRes = Owned(E);
1414 AssignConvertType ConvTy =
1415 CheckSingleAssignmentConstraints(DestTy, ExprRes);
1416 if (ExprRes.isInvalid())
1417 return StmtError();
1418 E = ExprRes.take();
1419 if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
1420 return StmtError();
1421 }
1422
1423 getCurFunction()->setHasIndirectGoto();
1424
1425 return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
1426}
1427
1428StmtResult
1429Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
1430 Scope *S = CurScope->getContinueParent();
1431 if (!S) {
1432 // C99 6.8.6.2p1: A break shall appear only in or as a loop body.
1433 return StmtError(Diag(ContinueLoc, diag::err_continue_not_in_loop));
1434 }
1435
1436 return Owned(new (Context) ContinueStmt(ContinueLoc));
1437}
1438
1439StmtResult
1440Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
1441 Scope *S = CurScope->getBreakParent();
1442 if (!S) {
1443 // C99 6.8.6.3p1: A break shall appear only in or as a switch/loop body.
1444 return StmtError(Diag(BreakLoc, diag::err_break_not_in_loop_or_switch));
1445 }
1446
1447 return Owned(new (Context) BreakStmt(BreakLoc));
1448}
1449
1450/// \brief Determine whether the given expression is a candidate for
1451/// copy elision in either a return statement or a throw expression.
1452///
1453/// \param ReturnType If we're determining the copy elision candidate for
1454/// a return statement, this is the return type of the function. If we're
1455/// determining the copy elision candidate for a throw expression, this will
1456/// be a NULL type.
1457///
1458/// \param E The expression being returned from the function or block, or
1459/// being thrown.
1460///
1461/// \param AllowFunctionParameter Whether we allow function parameters to
1462/// be considered NRVO candidates. C++ prohibits this for NRVO itself, but
1463/// we re-use this logic to determine whether we should try to move as part of
1464/// a return or throw (which does allow function parameters).
1465///
1466/// \returns The NRVO candidate variable, if the return statement may use the
1467/// NRVO, or NULL if there is no such candidate.
1468const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
1469 Expr *E,
1470 bool AllowFunctionParameter) {
1471 QualType ExprType = E->getType();
1472 // - in a return statement in a function with ...
1473 // ... a class return type ...
1474 if (!ReturnType.isNull()) {
1475 if (!ReturnType->isRecordType())
1476 return 0;
1477 // ... the same cv-unqualified type as the function return type ...
1478 if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
1479 return 0;
1480 }
1481
1482 // ... the expression is the name of a non-volatile automatic object
1483 // (other than a function or catch-clause parameter)) ...
1484 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
1485 if (!DR)
1486 return 0;
1487 const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
1488 if (!VD)
1489 return 0;
1490
1491 if (VD->hasLocalStorage() && !VD->isExceptionVariable() &&
1492 !VD->getType()->isReferenceType() && !VD->hasAttr<BlocksAttr>() &&
1493 !VD->getType().isVolatileQualified() &&
1494 ((VD->getKind() == Decl::Var) ||
1495 (AllowFunctionParameter && VD->getKind() == Decl::ParmVar)))
1496 return VD;
1497
1498 return 0;
1499}
1500
1501/// \brief Perform the initialization of a potentially-movable value, which
1502/// is the result of return value.
1503///
1504/// This routine implements C++0x [class.copy]p33, which attempts to treat
1505/// returned lvalues as rvalues in certain cases (to prefer move construction),
1506/// then falls back to treating them as lvalues if that failed.
1507ExprResult
1508Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
1509 const VarDecl *NRVOCandidate,
1510 QualType ResultType,
| 1412 }
1413
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));
1419}
1420
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
1424/// determined.
1425StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
1426 if (!S || !B)
1427 return StmtError();
1428
1429 cast<CXXForRangeStmt>(S)->setBody(B);
1430 return S;
1431}
1432
1433StmtResult Sema::ActOnGotoStmt(SourceLocation GotoLoc,
1434 SourceLocation LabelLoc,
1435 LabelDecl *TheDecl) {
1436 getCurFunction()->setHasBranchIntoScope();
1437 TheDecl->setUsed();
1438 return Owned(new (Context) GotoStmt(TheDecl, GotoLoc, LabelLoc));
1439}
1440
1441StmtResult
1442Sema::ActOnIndirectGotoStmt(SourceLocation GotoLoc, SourceLocation StarLoc,
1443 Expr *E) {
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())
1452 return StmtError();
1453 E = ExprRes.take();
1454 if (DiagnoseAssignmentResult(ConvTy, StarLoc, DestTy, ETy, E, AA_Passing))
1455 return StmtError();
1456 }
1457
1458 getCurFunction()->setHasIndirectGoto();
1459
1460 return Owned(new (Context) IndirectGotoStmt(GotoLoc, StarLoc, E));
1461}
1462
1463StmtResult
1464Sema::ActOnContinueStmt(SourceLocation ContinueLoc, Scope *CurScope) {
1465 Scope *S = CurScope->getContinueParent();
1466 if (!S) {
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));
1469 }
1470
1471 return Owned(new (Context) ContinueStmt(ContinueLoc));
1472}
1473
1474StmtResult
1475Sema::ActOnBreakStmt(SourceLocation BreakLoc, Scope *CurScope) {
1476 Scope *S = CurScope->getBreakParent();
1477 if (!S) {
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));
1480 }
1481
1482 return Owned(new (Context) BreakStmt(BreakLoc));
1483}
1484
1485/// \brief Determine whether the given expression is a candidate for
1486/// copy elision in either a return statement or a throw expression.
1487///
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
1491/// be a NULL type.
1492///
1493/// \param E The expression being returned from the function or block, or
1494/// being thrown.
1495///
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).
1500///
1501/// \returns The NRVO candidate variable, if the return statement may use the
1502/// NRVO, or NULL if there is no such candidate.
1503const VarDecl *Sema::getCopyElisionCandidate(QualType ReturnType,
1504 Expr *E,
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())
1511 return 0;
1512 // ... the same cv-unqualified type as the function return type ...
1513 if (!Context.hasSameUnqualifiedType(ReturnType, ExprType))
1514 return 0;
1515 }
1516
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());
1520 if (!DR)
1521 return 0;
1522 const VarDecl *VD = dyn_cast<VarDecl>(DR->getDecl());
1523 if (!VD)
1524 return 0;
1525
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)))
1531 return VD;
1532
1533 return 0;
1534}
1535
1536/// \brief Perform the initialization of a potentially-movable value, which
1537/// is the result of return value.
1538///
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.
1542ExprResult
1543Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
1544 const VarDecl *NRVOCandidate,
1545 QualType ResultType,
|
1511 Expr *Value) {
| 1546 Expr *Value,
1547 bool AllowNRVO) {
|
1512 // C++0x [class.copy]p33:
1513 // When the criteria for elision of a copy operation are met or would
1514 // be met save for the fact that the source object is a function
1515 // parameter, and the object to be copied is designated by an lvalue,
1516 // overload resolution to select the constructor for the copy is first
1517 // performed as if the object were designated by an rvalue.
1518 ExprResult Res = ExprError();
| 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();
|
1519 if (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true)) {
| 1555 if (AllowNRVO &&
1556 (NRVOCandidate || getCopyElisionCandidate(ResultType, Value, true))) {
|
1520 ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
1521 Value->getType(), CK_LValueToRValue,
1522 Value, VK_XValue);
1523
1524 Expr *InitExpr = &AsRvalue;
1525 InitializationKind Kind
1526 = InitializationKind::CreateCopy(Value->getLocStart(),
1527 Value->getLocStart());
1528 InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
1529
1530 // [...] If overload resolution fails, or if the type of the first
1531 // parameter of the selected constructor is not an rvalue reference
1532 // to the object's type (possibly cv-qualified), overload resolution
1533 // is performed again, considering the object as an lvalue.
1534 if (Seq) {
1535 for (InitializationSequence::step_iterator Step = Seq.step_begin(),
1536 StepEnd = Seq.step_end();
1537 Step != StepEnd; ++Step) {
1538 if (Step->Kind != InitializationSequence::SK_ConstructorInitialization)
1539 continue;
1540
1541 CXXConstructorDecl *Constructor
1542 = cast<CXXConstructorDecl>(Step->Function.Function);
1543
1544 const RValueReferenceType *RRefType
1545 = Constructor->getParamDecl(0)->getType()
1546 ->getAs<RValueReferenceType>();
1547
1548 // If we don't meet the criteria, break out now.
1549 if (!RRefType ||
1550 !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
1551 Context.getTypeDeclType(Constructor->getParent())))
1552 break;
1553
1554 // Promote "AsRvalue" to the heap, since we now need this
1555 // expression node to persist.
1556 Value = ImplicitCastExpr::Create(Context, Value->getType(),
1557 CK_LValueToRValue, Value, 0,
1558 VK_XValue);
1559
1560 // Complete type-checking the initialization of the return type
1561 // using the constructor we found.
1562 Res = Seq.Perform(*this, Entity, Kind, MultiExprArg(&Value, 1));
1563 }
1564 }
1565 }
1566
1567 // Either we didn't meet the criteria for treating an lvalue as an rvalue,
1568 // above, or overload resolution failed. Either way, we need to try
1569 // (again) now with the return value expression as written.
1570 if (Res.isInvalid())
1571 Res = PerformCopyInitialization(Entity, SourceLocation(), Value);
1572
1573 return Res;
1574}
1575
1576/// ActOnBlockReturnStmt - Utility routine to figure out block's return type.
1577///
1578StmtResult
1579Sema::ActOnBlockReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1580 // If this is the first return we've seen in the block, infer the type of
1581 // the block from it.
1582 BlockScopeInfo *CurBlock = getCurBlock();
1583 if (CurBlock->ReturnType.isNull()) {
1584 if (RetValExp) {
1585 // Don't call UsualUnaryConversions(), since we don't want to do
1586 // integer promotions here.
1587 ExprResult Result = DefaultFunctionArrayLvalueConversion(RetValExp);
1588 if (Result.isInvalid())
1589 return StmtError();
1590 RetValExp = Result.take();
1591
1592 if (!RetValExp->isTypeDependent()) {
1593 CurBlock->ReturnType = RetValExp->getType();
1594 if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(RetValExp)) {
1595 // We have to remove a 'const' added to copied-in variable which was
1596 // part of the implementation spec. and not the actual qualifier for
1597 // the variable.
1598 if (CDRE->isConstQualAdded())
1599 CurBlock->ReturnType.removeLocalConst(); // FIXME: local???
1600 }
1601 } else
1602 CurBlock->ReturnType = Context.DependentTy;
1603 } else
1604 CurBlock->ReturnType = Context.VoidTy;
1605 }
1606 QualType FnRetType = CurBlock->ReturnType;
1607
1608 if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
1609 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr)
1610 << getCurFunctionOrMethodDecl()->getDeclName();
1611 return StmtError();
1612 }
1613
1614 // Otherwise, verify that this result type matches the previous one. We are
1615 // pickier with blocks than for normal functions because we don't have GCC
1616 // compatibility to worry about here.
1617 ReturnStmt *Result = 0;
1618 if (CurBlock->ReturnType->isVoidType()) {
1619 if (RetValExp && !RetValExp->isTypeDependent() &&
1620 (!getLangOptions().CPlusPlus || !RetValExp->getType()->isVoidType())) {
1621 Diag(ReturnLoc, diag::err_return_block_has_expr);
1622 RetValExp = 0;
1623 }
1624 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
1625 } else if (!RetValExp) {
1626 if (!CurBlock->ReturnType->isDependentType())
1627 return StmtError(Diag(ReturnLoc, diag::err_block_return_missing_expr));
1628
1629 Result = new (Context) ReturnStmt(ReturnLoc, 0, 0);
1630 } else {
1631 const VarDecl *NRVOCandidate = 0;
1632
1633 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1634 // we have a non-void block with an expression, continue checking
1635
1636 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1637 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1638 // function return.
1639
1640 // In C++ the return statement is handled via a copy initialization.
1641 // the C version of which boils down to CheckSingleAssignmentConstraints.
1642 NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1643 InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1644 FnRetType,
1645 NRVOCandidate != 0);
1646 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1647 FnRetType, RetValExp);
1648 if (Res.isInvalid()) {
1649 // FIXME: Cleanup temporaries here, anyway?
1650 return StmtError();
1651 }
1652
1653 if (RetValExp) {
1654 CheckImplicitConversions(RetValExp, ReturnLoc);
1655 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1656 }
1657
1658 RetValExp = Res.takeAs<Expr>();
1659 if (RetValExp)
1660 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1661 }
1662
1663 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1664 }
1665
1666 // If we need to check for the named return value optimization, save the
1667 // return statement in our scope for later processing.
1668 if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1669 !CurContext->isDependentContext())
1670 FunctionScopes.back()->Returns.push_back(Result);
1671
1672 return Owned(Result);
1673}
1674
1675StmtResult
1676Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1677 // Check for unexpanded parameter packs.
1678 if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
1679 return StmtError();
1680
1681 if (getCurBlock())
1682 return ActOnBlockReturnStmt(ReturnLoc, RetValExp);
1683
1684 QualType FnRetType;
1685 QualType DeclaredRetType;
1686 if (const FunctionDecl *FD = getCurFunctionDecl()) {
1687 FnRetType = FD->getResultType();
1688 DeclaredRetType = FnRetType;
1689 if (FD->hasAttr<NoReturnAttr>() ||
1690 FD->getType()->getAs<FunctionType>()->getNoReturnAttr())
1691 Diag(ReturnLoc, diag::warn_noreturn_function_has_return_expr)
1692 << getCurFunctionOrMethodDecl()->getDeclName();
1693 } else if (ObjCMethodDecl *MD = getCurMethodDecl()) {
1694 DeclaredRetType = MD->getResultType();
1695 if (MD->hasRelatedResultType() && MD->getClassInterface()) {
1696 // In the implementation of a method with a related return type, the
1697 // type used to type-check the validity of return statements within the
1698 // method body is a pointer to the type of the class being implemented.
1699 FnRetType = Context.getObjCInterfaceType(MD->getClassInterface());
1700 FnRetType = Context.getObjCObjectPointerType(FnRetType);
1701 } else {
1702 FnRetType = DeclaredRetType;
1703 }
1704 } else // If we don't have a function/method context, bail.
1705 return StmtError();
1706
1707 ReturnStmt *Result = 0;
1708 if (FnRetType->isVoidType()) {
1709 if (RetValExp) {
1710 if (!RetValExp->isTypeDependent()) {
1711 // C99 6.8.6.4p1 (ext_ since GCC warns)
1712 unsigned D = diag::ext_return_has_expr;
1713 if (RetValExp->getType()->isVoidType())
1714 D = diag::ext_return_has_void_expr;
1715 else {
1716 ExprResult Result = Owned(RetValExp);
1717 Result = IgnoredValueConversions(Result.take());
1718 if (Result.isInvalid())
1719 return StmtError();
1720 RetValExp = Result.take();
1721 RetValExp = ImpCastExprToType(RetValExp,
1722 Context.VoidTy, CK_ToVoid).take();
1723 }
1724
1725 // return (some void expression); is legal in C++.
1726 if (D != diag::ext_return_has_void_expr ||
1727 !getLangOptions().CPlusPlus) {
1728 NamedDecl *CurDecl = getCurFunctionOrMethodDecl();
| 1557 ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack,
1558 Value->getType(), CK_LValueToRValue,
1559 Value, VK_XValue);
1560
1561 Expr *InitExpr = &AsRvalue;
1562 InitializationKind Kind
1563 = InitializationKind::CreateCopy(Value->getLocStart(),
1564 Value->getLocStart());
1565 InitializationSequence Seq(*this, Entity, Kind, &InitExpr, 1);
1566
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.
1571 if (Seq) {
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)
1576 continue;
1577
1578 CXXConstructorDecl *Constructor
1579 = cast<CXXConstructorDecl>(Step->Function.Function);
1580
1581 const RValueReferenceType *RRefType
1582 = Constructor->getParamDecl(0)->getType()
1583 ->getAs<RValueReferenceType>();
1584
1585 // If we don't meet the criteria, break out now.
1586 if (!RRefType ||
1587 !Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
1588 Context.getTypeDeclType(Constructor->getParent())))
1589 break;
1590
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,
1595 VK_XValue);
1596
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));
1600 }
1601 }
1602 }
1603
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);
1609
1610 return Res;
1611}
1612
1613/// ActOnBlockReturnStmt - Utility routine to figure out block's return type.
1614///
1615StmtResult
1616Sema::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()) {
1621 if (RetValExp) {
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())
1626 return StmtError();
1627 RetValExp = Result.take();
1628
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
1634 // the variable.
1635 if (CDRE->isConstQualAdded())
1636 CurBlock->ReturnType.removeLocalConst(); // FIXME: local???
1637 }
1638 } else
1639 CurBlock->ReturnType = Context.DependentTy;
1640 } else
1641 CurBlock->ReturnType = Context.VoidTy;
1642 }
1643 QualType FnRetType = CurBlock->ReturnType;
1644
1645 if (CurBlock->FunctionType->getAs<FunctionType>()->getNoReturnAttr()) {
1646 Diag(ReturnLoc, diag::err_noreturn_block_has_return_expr)
1647 << getCurFunctionOrMethodDecl()->getDeclName();
1648 return StmtError();
1649 }
1650
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);
1659 RetValExp = 0;
1660 }
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));
1665
1666 Result = new (Context) ReturnStmt(ReturnLoc, 0, 0);
1667 } else {
1668 const VarDecl *NRVOCandidate = 0;
1669
1670 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1671 // we have a non-void block with an expression, continue checking
1672
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
1675 // function return.
1676
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,
1681 FnRetType,
1682 NRVOCandidate != 0);
1683 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1684 FnRetType, RetValExp);
1685 if (Res.isInvalid()) {
1686 // FIXME: Cleanup temporaries here, anyway?
1687 return StmtError();
1688 }
1689
1690 if (RetValExp) {
1691 CheckImplicitConversions(RetValExp, ReturnLoc);
1692 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1693 }
1694
1695 RetValExp = Res.takeAs<Expr>();
1696 if (RetValExp)
1697 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1698 }
1699
1700 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1701 }
1702
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);
1708
1709 return Owned(Result);
1710}
1711
1712StmtResult
1713Sema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
1714 // Check for unexpanded parameter packs.
1715 if (RetValExp && DiagnoseUnexpandedParameterPack(RetValExp))
1716 return StmtError();
1717
1718 if (getCurBlock())
1719 return ActOnBlockReturnStmt(ReturnLoc, RetValExp);
1720
1721 QualType FnRetType;
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);
1738 } else {
1739 FnRetType = DeclaredRetType;
1740 }
1741 } else // If we don't have a function/method context, bail.
1742 return StmtError();
1743
1744 ReturnStmt *Result = 0;
1745 if (FnRetType->isVoidType()) {
1746 if (RetValExp) {
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;
1752 else {
1753 ExprResult Result = Owned(RetValExp);
1754 Result = IgnoredValueConversions(Result.take());
1755 if (Result.isInvalid())
1756 return StmtError();
1757 RetValExp = Result.take();
1758 RetValExp = ImpCastExprToType(RetValExp,
1759 Context.VoidTy, CK_ToVoid).take();
1760 }
1761
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();
|
| 1766
1767 int FunctionKind = 0;
1768 if (isa<ObjCMethodDecl>(CurDecl))
1769 FunctionKind = 1;
1770 else if (isa<CXXConstructorDecl>(CurDecl))
1771 FunctionKind = 2;
1772 else if (isa<CXXDestructorDecl>(CurDecl))
1773 FunctionKind = 3;
1774
|
1729 Diag(ReturnLoc, D)
| 1775 Diag(ReturnLoc, D)
|
1730 << CurDecl->getDeclName() << isa<ObjCMethodDecl>(CurDecl)
| 1776 << CurDecl->getDeclName() << FunctionKind
|
1731 << RetValExp->getSourceRange();
1732 }
1733 }
1734
1735 CheckImplicitConversions(RetValExp, ReturnLoc);
1736 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1737 }
1738
1739 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, 0);
1740 } else if (!RetValExp && !FnRetType->isDependentType()) {
1741 unsigned DiagID = diag::warn_return_missing_expr; // C90 6.6.6.4p4
1742 // C99 6.8.6.4p1 (ext_ since GCC warns)
1743 if (getLangOptions().C99) DiagID = diag::ext_return_missing_expr;
1744
1745 if (FunctionDecl *FD = getCurFunctionDecl())
1746 Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
1747 else
1748 Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
1749 Result = new (Context) ReturnStmt(ReturnLoc);
1750 } else {
1751 const VarDecl *NRVOCandidate = 0;
1752 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1753 // we have a non-void function with an expression, continue checking
1754
1755 // C99 6.8.6.4p3(136): The return statement is not an assignment. The
1756 // overlap restriction of subclause 6.5.16.1 does not apply to the case of
1757 // function return.
1758
| 1777 << RetValExp->getSourceRange();
1778 }
1779 }
1780
1781 CheckImplicitConversions(RetValExp, ReturnLoc);
1782 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1783 }
1784
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;
1790
1791 if (FunctionDecl *FD = getCurFunctionDecl())
1792 Diag(ReturnLoc, DiagID) << FD->getIdentifier() << 0/*fn*/;
1793 else
1794 Diag(ReturnLoc, DiagID) << getCurMethodDecl()->getDeclName() << 1/*meth*/;
1795 Result = new (Context) ReturnStmt(ReturnLoc);
1796 } else {
1797 const VarDecl *NRVOCandidate = 0;
1798 if (!FnRetType->isDependentType() && !RetValExp->isTypeDependent()) {
1799 // we have a non-void function with an expression, continue checking
1800
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
1803 // function return.
1804
|
1759 // In C++ the return statement is handled via a copy initialization.
| 1805 // In C++ the return statement is handled via a copy initialization,
|
1760 // the C version of which boils down to CheckSingleAssignmentConstraints.
1761 NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1762 InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1763 FnRetType,
1764 NRVOCandidate != 0);
1765 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1766 FnRetType, RetValExp);
1767 if (Res.isInvalid()) {
1768 // FIXME: Cleanup temporaries here, anyway?
1769 return StmtError();
1770 }
1771
1772 RetValExp = Res.takeAs<Expr>();
1773 if (RetValExp)
1774 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1775 }
1776
1777 if (RetValExp) {
1778 // If we type-checked an Objective-C method's return type based
1779 // on a related return type, we may need to adjust the return
1780 // type again. Do so now.
1781 if (DeclaredRetType != FnRetType) {
1782 ExprResult result = PerformImplicitConversion(RetValExp,
1783 DeclaredRetType,
1784 AA_Returning);
1785 if (result.isInvalid()) return StmtError();
1786 RetValExp = result.take();
1787 }
1788
1789 CheckImplicitConversions(RetValExp, ReturnLoc);
1790 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1791 }
1792 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1793 }
1794
1795 // If we need to check for the named return value optimization, save the
1796 // return statement in our scope for later processing.
1797 if (getLangOptions().CPlusPlus && FnRetType->isRecordType() &&
1798 !CurContext->isDependentContext())
1799 FunctionScopes.back()->Returns.push_back(Result);
| 1806 // the C version of which boils down to CheckSingleAssignmentConstraints.
1807 NRVOCandidate = getCopyElisionCandidate(FnRetType, RetValExp, false);
1808 InitializedEntity Entity = InitializedEntity::InitializeResult(ReturnLoc,
1809 FnRetType,
1810 NRVOCandidate != 0);
1811 ExprResult Res = PerformMoveOrCopyInitialization(Entity, NRVOCandidate,
1812 FnRetType, RetValExp);
1813 if (Res.isInvalid()) {
1814 // FIXME: Cleanup temporaries here, anyway?
1815 return StmtError();
1816 }
1817
1818 RetValExp = Res.takeAs<Expr>();
1819 if (RetValExp)
1820 CheckReturnStackAddr(RetValExp, FnRetType, ReturnLoc);
1821 }
1822
1823 if (RetValExp) {
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,
1829 DeclaredRetType,
1830 AA_Returning);
1831 if (result.isInvalid()) return StmtError();
1832 RetValExp = result.take();
1833 }
1834
1835 CheckImplicitConversions(RetValExp, ReturnLoc);
1836 RetValExp = MaybeCreateExprWithCleanups(RetValExp);
1837 }
1838 Result = new (Context) ReturnStmt(ReturnLoc, RetValExp, NRVOCandidate);
1839 }
1840
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);
|
1800
| 1846
|
1801 return Owned(Result);
1802}
1803
1804/// CheckAsmLValue - GNU C has an extremely ugly extension whereby they silently
1805/// ignore "noop" casts in places where an lvalue is required by an inline asm.
1806/// We emulate this behavior when -fheinous-gnu-extensions is specified, but
1807/// provide a strong guidance to not use it.
1808///
1809/// This method checks to see if the argument is an acceptable l-value and
1810/// returns false if it is a case we can handle.
1811static bool CheckAsmLValue(const Expr *E, Sema &S) {
1812 // Type dependent expressions will be checked during instantiation.
1813 if (E->isTypeDependent())
1814 return false;
1815
1816 if (E->isLValue())
1817 return false; // Cool, this is an lvalue.
1818
1819 // Okay, this is not an lvalue, but perhaps it is the result of a cast that we
1820 // are supposed to allow.
1821 const Expr *E2 = E->IgnoreParenNoopCasts(S.Context);
1822 if (E != E2 && E2->isLValue()) {
1823 if (!S.getLangOptions().HeinousExtensions)
1824 S.Diag(E2->getLocStart(), diag::err_invalid_asm_cast_lvalue)
1825 << E->getSourceRange();
1826 else
1827 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
1828 << E->getSourceRange();
1829 // Accept, even if we emitted an error diagnostic.
1830 return false;
1831 }
1832
1833 // None of the above, just randomly invalid non-lvalue.
1834 return true;
1835}
1836
1837/// isOperandMentioned - Return true if the specified operand # is mentioned
1838/// anywhere in the decomposed asm string.
1839static bool isOperandMentioned(unsigned OpNo,
1840 llvm::ArrayRef<AsmStmt::AsmStringPiece> AsmStrPieces) {
1841 for (unsigned p = 0, e = AsmStrPieces.size(); p != e; ++p) {
1842 const AsmStmt::AsmStringPiece &Piece = AsmStrPieces[p];
1843 if (!Piece.isOperand()) continue;
1844
1845 // If this is a reference to the input and if the input was the smaller
1846 // one, then we have to reject this asm.
1847 if (Piece.getOperandNo() == OpNo)
1848 return true;
1849 }
1850
1851 return false;
1852}
1853
1854StmtResult Sema::ActOnAsmStmt(SourceLocation AsmLoc, bool IsSimple,
1855 bool IsVolatile, unsigned NumOutputs,
1856 unsigned NumInputs, IdentifierInfo **Names,
1857 MultiExprArg constraints, MultiExprArg exprs,
1858 Expr *asmString, MultiExprArg clobbers,
1859 SourceLocation RParenLoc, bool MSAsm) {
1860 unsigned NumClobbers = clobbers.size();
1861 StringLiteral **Constraints =
1862 reinterpret_cast<StringLiteral**>(constraints.get());
1863 Expr **Exprs = exprs.get();
1864 StringLiteral *AsmString = cast<StringLiteral>(asmString);
1865 StringLiteral **Clobbers = reinterpret_cast<StringLiteral**>(clobbers.get());
1866
1867 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1868
1869 // The parser verifies that there is a string literal here.
1870 if (AsmString->isWide())
1871 return StmtError(Diag(AsmString->getLocStart(),diag::err_asm_wide_character)
1872 << AsmString->getSourceRange());
1873
1874 for (unsigned i = 0; i != NumOutputs; i++) {
1875 StringLiteral *Literal = Constraints[i];
1876 if (Literal->isWide())
1877 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1878 << Literal->getSourceRange());
1879
1880 llvm::StringRef OutputName;
1881 if (Names[i])
1882 OutputName = Names[i]->getName();
1883
1884 TargetInfo::ConstraintInfo Info(Literal->getString(), OutputName);
1885 if (!Context.Target.validateOutputConstraint(Info))
1886 return StmtError(Diag(Literal->getLocStart(),
1887 diag::err_asm_invalid_output_constraint)
1888 << Info.getConstraintStr());
1889
1890 // Check that the output exprs are valid lvalues.
1891 Expr *OutputExpr = Exprs[i];
1892 if (CheckAsmLValue(OutputExpr, *this)) {
1893 return StmtError(Diag(OutputExpr->getLocStart(),
1894 diag::err_asm_invalid_lvalue_in_output)
1895 << OutputExpr->getSourceRange());
1896 }
1897
1898 OutputConstraintInfos.push_back(Info);
1899 }
1900
1901 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
1902
1903 for (unsigned i = NumOutputs, e = NumOutputs + NumInputs; i != e; i++) {
1904 StringLiteral *Literal = Constraints[i];
1905 if (Literal->isWide())
1906 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1907 << Literal->getSourceRange());
1908
1909 llvm::StringRef InputName;
1910 if (Names[i])
1911 InputName = Names[i]->getName();
1912
1913 TargetInfo::ConstraintInfo Info(Literal->getString(), InputName);
1914 if (!Context.Target.validateInputConstraint(OutputConstraintInfos.data(),
1915 NumOutputs, Info)) {
1916 return StmtError(Diag(Literal->getLocStart(),
1917 diag::err_asm_invalid_input_constraint)
1918 << Info.getConstraintStr());
1919 }
1920
1921 Expr *InputExpr = Exprs[i];
1922
1923 // Only allow void types for memory constraints.
1924 if (Info.allowsMemory() && !Info.allowsRegister()) {
1925 if (CheckAsmLValue(InputExpr, *this))
1926 return StmtError(Diag(InputExpr->getLocStart(),
1927 diag::err_asm_invalid_lvalue_in_input)
1928 << Info.getConstraintStr()
1929 << InputExpr->getSourceRange());
1930 }
1931
1932 if (Info.allowsRegister()) {
1933 if (InputExpr->getType()->isVoidType()) {
1934 return StmtError(Diag(InputExpr->getLocStart(),
1935 diag::err_asm_invalid_type_in_input)
1936 << InputExpr->getType() << Info.getConstraintStr()
1937 << InputExpr->getSourceRange());
1938 }
1939 }
1940
1941 ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
1942 if (Result.isInvalid())
1943 return StmtError();
1944
1945 Exprs[i] = Result.take();
1946 InputConstraintInfos.push_back(Info);
1947 }
1948
1949 // Check that the clobbers are valid.
1950 for (unsigned i = 0; i != NumClobbers; i++) {
1951 StringLiteral *Literal = Clobbers[i];
1952 if (Literal->isWide())
1953 return StmtError(Diag(Literal->getLocStart(),diag::err_asm_wide_character)
1954 << Literal->getSourceRange());
1955
1956 llvm::StringRef Clobber = Literal->getString();
1957
| 1847 return Owned(Result);
1848}
1849
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.
1854///
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.
1857static bool CheckAsmLValue(const Expr *E, Sema &S) {
1858 // Type dependent expressions will be checked during instantiation.
1859 if (E->isTypeDependent())
1860 return false;
1861
1862 if (E->isLValue())
1863 return false; // Cool, this is an lvalue.
1864
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();
1872 else
1873 S.Diag(E2->getLocStart(), diag::warn_invalid_asm_cast_lvalue)
1874 << E->getSourceRange();
1875 // Accept, even if we emitted an error diagnostic.
1876 return false;
1877 }
1878
1879 // None of the above, just randomly invalid non-lvalue.
1880 return true;
1881}
1882
1883/// isOperandMentioned - Return true if the specified operand # is mentioned
1884/// anywhere in the decomposed asm string.
1885static 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;
1890
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)
1894 return true;
1895 }
1896
1897 return false;
1898}
1899
1900StmtResult 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());
1912
1913 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> OutputConstraintInfos;
1914
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());
1919
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());
1925
1926 llvm::StringRef OutputName;
1927 if (Names[i])
1928 OutputName = Names[i]->getName();
1929
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());
1935
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());
1942 }
1943
1944 OutputConstraintInfos.push_back(Info);
1945 }
1946
1947 llvm::SmallVector<TargetInfo::ConstraintInfo, 4> InputConstraintInfos;
1948
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());
1954
1955 llvm::StringRef InputName;
1956 if (Names[i])
1957 InputName = Names[i]->getName();
1958
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());
1965 }
1966
1967 Expr *InputExpr = Exprs[i];
1968
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());
1976 }
1977
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());
1984 }
1985 }
1986
1987 ExprResult Result = DefaultFunctionArrayLvalueConversion(Exprs[i]);
1988 if (Result.isInvalid())
1989 return StmtError();
1990
1991 Exprs[i] = Result.take();
1992 InputConstraintInfos.push_back(Info);
1993 }
1994
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());
2001
2002 llvm::StringRef Clobber = Literal->getString();
2003
|
1958 if (!Context.Target.isValidGCCRegisterName(Clobber))
| 2004 if (!Context.Target.isValidClobber(Clobber))
|
1959 return StmtError(Diag(Literal->getLocStart(),
1960 diag::err_asm_unknown_register_name) << Clobber);
1961 }
1962
1963 AsmStmt *NS =
1964 new (Context) AsmStmt(Context, AsmLoc, IsSimple, IsVolatile, MSAsm,
1965 NumOutputs, NumInputs, Names, Constraints, Exprs,
1966 AsmString, NumClobbers, Clobbers, RParenLoc);
1967 // Validate the asm string, ensuring it makes sense given the operands we
1968 // have.
1969 llvm::SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
1970 unsigned DiagOffs;
1971 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
1972 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
1973 << AsmString->getSourceRange();
1974 return StmtError();
1975 }
1976
1977 // Validate tied input operands for type mismatches.
1978 for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {
1979 TargetInfo::ConstraintInfo &Info = InputConstraintInfos[i];
1980
1981 // If this is a tied constraint, verify that the output and input have
1982 // either exactly the same type, or that they are int/ptr operands with the
1983 // same size (int/long, int*/long, are ok etc).
1984 if (!Info.hasTiedOperand()) continue;
1985
1986 unsigned TiedTo = Info.getTiedOperand();
1987 unsigned InputOpNo = i+NumOutputs;
1988 Expr *OutputExpr = Exprs[TiedTo];
1989 Expr *InputExpr = Exprs[InputOpNo];
1990 QualType InTy = InputExpr->getType();
1991 QualType OutTy = OutputExpr->getType();
1992 if (Context.hasSameType(InTy, OutTy))
1993 continue; // All types can be tied to themselves.
1994
1995 // Decide if the input and output are in the same domain (integer/ptr or
1996 // floating point.
1997 enum AsmDomain {
1998 AD_Int, AD_FP, AD_Other
1999 } InputDomain, OutputDomain;
2000
2001 if (InTy->isIntegerType() || InTy->isPointerType())
2002 InputDomain = AD_Int;
2003 else if (InTy->isRealFloatingType())
2004 InputDomain = AD_FP;
2005 else
2006 InputDomain = AD_Other;
2007
2008 if (OutTy->isIntegerType() || OutTy->isPointerType())
2009 OutputDomain = AD_Int;
2010 else if (OutTy->isRealFloatingType())
2011 OutputDomain = AD_FP;
2012 else
2013 OutputDomain = AD_Other;
2014
2015 // They are ok if they are the same size and in the same domain. This
2016 // allows tying things like:
2017 // void* to int*
2018 // void* to int if they are the same size.
2019 // double to long double if they are the same size.
2020 //
2021 uint64_t OutSize = Context.getTypeSize(OutTy);
2022 uint64_t InSize = Context.getTypeSize(InTy);
2023 if (OutSize == InSize && InputDomain == OutputDomain &&
2024 InputDomain != AD_Other)
2025 continue;
2026
2027 // If the smaller input/output operand is not mentioned in the asm string,
2028 // then we can promote the smaller one to a larger input and the asm string
2029 // won't notice.
2030 bool SmallerValueMentioned = false;
2031
2032 // If this is a reference to the input and if the input was the smaller
2033 // one, then we have to reject this asm.
2034 if (isOperandMentioned(InputOpNo, Pieces)) {
2035 // This is a use in the asm string of the smaller operand. Since we
2036 // codegen this by promoting to a wider value, the asm will get printed
2037 // "wrong".
2038 SmallerValueMentioned |= InSize < OutSize;
2039 }
2040 if (isOperandMentioned(TiedTo, Pieces)) {
2041 // If this is a reference to the output, and if the output is the larger
2042 // value, then it's ok because we'll promote the input to the larger type.
2043 SmallerValueMentioned |= OutSize < InSize;
2044 }
2045
2046 // If the smaller value wasn't mentioned in the asm string, and if the
2047 // output was a register, just extend the shorter one to the size of the
2048 // larger one.
2049 if (!SmallerValueMentioned && InputDomain != AD_Other &&
2050 OutputConstraintInfos[TiedTo].allowsRegister())
2051 continue;
2052
2053 // Either both of the operands were mentioned or the smaller one was
2054 // mentioned. One more special case that we'll allow: if the tied input is
2055 // integer, unmentioned, and is a constant, then we'll allow truncating it
2056 // down to the size of the destination.
2057 if (InputDomain == AD_Int && OutputDomain == AD_Int &&
2058 !isOperandMentioned(InputOpNo, Pieces) &&
2059 InputExpr->isEvaluatable(Context)) {
2060 CastKind castKind =
2061 (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
2062 InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2063 Exprs[InputOpNo] = InputExpr;
2064 NS->setInputExpr(i, InputExpr);
2065 continue;
2066 }
2067
2068 Diag(InputExpr->getLocStart(),
2069 diag::err_asm_tying_incompatible_types)
2070 << InTy << OutTy << OutputExpr->getSourceRange()
2071 << InputExpr->getSourceRange();
2072 return StmtError();
2073 }
2074
2075 return Owned(NS);
2076}
2077
2078StmtResult
2079Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
2080 SourceLocation RParen, Decl *Parm,
2081 Stmt *Body) {
2082 VarDecl *Var = cast_or_null<VarDecl>(Parm);
2083 if (Var && Var->isInvalidDecl())
2084 return StmtError();
2085
2086 return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
2087}
2088
2089StmtResult
2090Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
2091 return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
2092}
2093
2094StmtResult
2095Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
2096 MultiStmtArg CatchStmts, Stmt *Finally) {
2097 if (!getLangOptions().ObjCExceptions)
2098 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
2099
2100 getCurFunction()->setHasBranchProtectedScope();
2101 unsigned NumCatchStmts = CatchStmts.size();
2102 return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
2103 CatchStmts.release(),
2104 NumCatchStmts,
2105 Finally));
2106}
2107
2108StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc,
2109 Expr *Throw) {
2110 if (Throw) {
2111 ExprResult Result = DefaultLvalueConversion(Throw);
2112 if (Result.isInvalid())
2113 return StmtError();
2114
2115 Throw = Result.take();
2116 QualType ThrowType = Throw->getType();
2117 // Make sure the expression type is an ObjC pointer or "void *".
2118 if (!ThrowType->isDependentType() &&
2119 !ThrowType->isObjCObjectPointerType()) {
2120 const PointerType *PT = ThrowType->getAs<PointerType>();
2121 if (!PT || !PT->getPointeeType()->isVoidType())
2122 return StmtError(Diag(AtLoc, diag::error_objc_throw_expects_object)
2123 << Throw->getType() << Throw->getSourceRange());
2124 }
2125 }
2126
2127 return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
2128}
2129
2130StmtResult
2131Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
2132 Scope *CurScope) {
2133 if (!getLangOptions().ObjCExceptions)
2134 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
2135
2136 if (!Throw) {
2137 // @throw without an expression designates a rethrow (which much occur
2138 // in the context of an @catch clause).
2139 Scope *AtCatchParent = CurScope;
2140 while (AtCatchParent && !AtCatchParent->isAtCatchScope())
2141 AtCatchParent = AtCatchParent->getParent();
2142 if (!AtCatchParent)
2143 return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
2144 }
2145
2146 return BuildObjCAtThrowStmt(AtLoc, Throw);
2147}
2148
2149StmtResult
2150Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
2151 Stmt *SyncBody) {
2152 getCurFunction()->setHasBranchProtectedScope();
2153
2154 ExprResult Result = DefaultLvalueConversion(SyncExpr);
2155 if (Result.isInvalid())
2156 return StmtError();
2157
2158 SyncExpr = Result.take();
2159 // Make sure the expression type is an ObjC pointer or "void *".
2160 if (!SyncExpr->getType()->isDependentType() &&
2161 !SyncExpr->getType()->isObjCObjectPointerType()) {
2162 const PointerType *PT = SyncExpr->getType()->getAs<PointerType>();
2163 if (!PT || !PT->getPointeeType()->isVoidType())
2164 return StmtError(Diag(AtLoc, diag::error_objc_synchronized_expects_object)
2165 << SyncExpr->getType() << SyncExpr->getSourceRange());
2166 }
2167
2168 return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
2169}
2170
2171/// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
2172/// and creates a proper catch handler from them.
2173StmtResult
2174Sema::ActOnCXXCatchBlock(SourceLocation CatchLoc, Decl *ExDecl,
2175 Stmt *HandlerBlock) {
2176 // There's nothing to test that ActOnExceptionDecl didn't already test.
2177 return Owned(new (Context) CXXCatchStmt(CatchLoc,
2178 cast_or_null<VarDecl>(ExDecl),
2179 HandlerBlock));
2180}
2181
| 2005 return StmtError(Diag(Literal->getLocStart(),
2006 diag::err_asm_unknown_register_name) << Clobber);
2007 }
2008
2009 AsmStmt *NS =
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
2014 // have.
2015 llvm::SmallVector<AsmStmt::AsmStringPiece, 8> Pieces;
2016 unsigned DiagOffs;
2017 if (unsigned DiagID = NS->AnalyzeAsmString(Pieces, Context, DiagOffs)) {
2018 Diag(getLocationOfStringLiteralByte(AsmString, DiagOffs), DiagID)
2019 << AsmString->getSourceRange();
2020 return StmtError();
2021 }
2022
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];
2026
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;
2031
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.
2040
2041 // Decide if the input and output are in the same domain (integer/ptr or
2042 // floating point.
2043 enum AsmDomain {
2044 AD_Int, AD_FP, AD_Other
2045 } InputDomain, OutputDomain;
2046
2047 if (InTy->isIntegerType() || InTy->isPointerType())
2048 InputDomain = AD_Int;
2049 else if (InTy->isRealFloatingType())
2050 InputDomain = AD_FP;
2051 else
2052 InputDomain = AD_Other;
2053
2054 if (OutTy->isIntegerType() || OutTy->isPointerType())
2055 OutputDomain = AD_Int;
2056 else if (OutTy->isRealFloatingType())
2057 OutputDomain = AD_FP;
2058 else
2059 OutputDomain = AD_Other;
2060
2061 // They are ok if they are the same size and in the same domain. This
2062 // allows tying things like:
2063 // void* to int*
2064 // void* to int if they are the same size.
2065 // double to long double if they are the same size.
2066 //
2067 uint64_t OutSize = Context.getTypeSize(OutTy);
2068 uint64_t InSize = Context.getTypeSize(InTy);
2069 if (OutSize == InSize && InputDomain == OutputDomain &&
2070 InputDomain != AD_Other)
2071 continue;
2072
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
2075 // won't notice.
2076 bool SmallerValueMentioned = false;
2077
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
2083 // "wrong".
2084 SmallerValueMentioned |= InSize < OutSize;
2085 }
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;
2090 }
2091
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
2094 // larger one.
2095 if (!SmallerValueMentioned && InputDomain != AD_Other &&
2096 OutputConstraintInfos[TiedTo].allowsRegister())
2097 continue;
2098
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)) {
2106 CastKind castKind =
2107 (OutTy->isBooleanType() ? CK_IntegralToBoolean : CK_IntegralCast);
2108 InputExpr = ImpCastExprToType(InputExpr, OutTy, castKind).take();
2109 Exprs[InputOpNo] = InputExpr;
2110 NS->setInputExpr(i, InputExpr);
2111 continue;
2112 }
2113
2114 Diag(InputExpr->getLocStart(),
2115 diag::err_asm_tying_incompatible_types)
2116 << InTy << OutTy << OutputExpr->getSourceRange()
2117 << InputExpr->getSourceRange();
2118 return StmtError();
2119 }
2120
2121 return Owned(NS);
2122}
2123
2124StmtResult
2125Sema::ActOnObjCAtCatchStmt(SourceLocation AtLoc,
2126 SourceLocation RParen, Decl *Parm,
2127 Stmt *Body) {
2128 VarDecl *Var = cast_or_null<VarDecl>(Parm);
2129 if (Var && Var->isInvalidDecl())
2130 return StmtError();
2131
2132 return Owned(new (Context) ObjCAtCatchStmt(AtLoc, RParen, Var, Body));
2133}
2134
2135StmtResult
2136Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
2137 return Owned(new (Context) ObjCAtFinallyStmt(AtLoc, Body));
2138}
2139
2140StmtResult
2141Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
2142 MultiStmtArg CatchStmts, Stmt *Finally) {
2143 if (!getLangOptions().ObjCExceptions)
2144 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@try";
2145
2146 getCurFunction()->setHasBranchProtectedScope();
2147 unsigned NumCatchStmts = CatchStmts.size();
2148 return Owned(ObjCAtTryStmt::Create(Context, AtLoc, Try,
2149 CatchStmts.release(),
2150 NumCatchStmts,
2151 Finally));
2152}
2153
2154StmtResult Sema::BuildObjCAtThrowStmt(SourceLocation AtLoc,
2155 Expr *Throw) {
2156 if (Throw) {
2157 ExprResult Result = DefaultLvalueConversion(Throw);
2158 if (Result.isInvalid())
2159 return StmtError();
2160
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());
2170 }
2171 }
2172
2173 return Owned(new (Context) ObjCAtThrowStmt(AtLoc, Throw));
2174}
2175
2176StmtResult
2177Sema::ActOnObjCAtThrowStmt(SourceLocation AtLoc, Expr *Throw,
2178 Scope *CurScope) {
2179 if (!getLangOptions().ObjCExceptions)
2180 Diag(AtLoc, diag::err_objc_exceptions_disabled) << "@throw";
2181
2182 if (!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();
2188 if (!AtCatchParent)
2189 return StmtError(Diag(AtLoc, diag::error_rethrow_used_outside_catch));
2190 }
2191
2192 return BuildObjCAtThrowStmt(AtLoc, Throw);
2193}
2194
2195StmtResult
2196Sema::ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc, Expr *SyncExpr,
2197 Stmt *SyncBody) {
2198 getCurFunction()->setHasBranchProtectedScope();
2199
2200 ExprResult Result = DefaultLvalueConversion(SyncExpr);
2201 if (Result.isInvalid())
2202 return StmtError();
2203
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());
2212 }
2213
2214 return Owned(new (Context) ObjCAtSynchronizedStmt(AtLoc, SyncExpr, SyncBody));
2215}
2216
2217/// ActOnCXXCatchBlock - Takes an exception declaration and a handler block
2218/// and creates a proper catch handler from them.
2219StmtResult
2220Sema::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),
2225 HandlerBlock));
2226}
2227
|
| 2228StmtResult
2229Sema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) {
2230 getCurFunction()->setHasBranchProtectedScope();
2231 return Owned(new (Context) ObjCAutoreleasePoolStmt(AtLoc, Body));
2232}
2233
|
2182namespace {
2183
2184class TypeWithHandler {
2185 QualType t;
2186 CXXCatchStmt *stmt;
2187public:
2188 TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
2189 : t(type), stmt(statement) {}
2190
2191 // An arbitrary order is fine as long as it places identical
2192 // types next to each other.
2193 bool operator<(const TypeWithHandler &y) const {
2194 if (t.getAsOpaquePtr() < y.t.getAsOpaquePtr())
2195 return true;
2196 if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
2197 return false;
2198 else
2199 return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
2200 }
2201
2202 bool operator==(const TypeWithHandler& other) const {
2203 return t == other.t;
2204 }
2205
2206 CXXCatchStmt *getCatchStmt() const { return stmt; }
2207 SourceLocation getTypeSpecStartLoc() const {
2208 return stmt->getExceptionDecl()->getTypeSpecStartLoc();
2209 }
2210};
2211
2212}
2213
2214/// ActOnCXXTryBlock - Takes a try compound-statement and a number of
2215/// handlers and creates a try statement from them.
2216StmtResult
2217Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
2218 MultiStmtArg RawHandlers) {
2219 // Don't report an error if 'try' is used in system headers.
2220 if (!getLangOptions().CXXExceptions &&
2221 !getSourceManager().isInSystemHeader(TryLoc))
2222 Diag(TryLoc, diag::err_exceptions_disabled) << "try";
2223
2224 unsigned NumHandlers = RawHandlers.size();
2225 assert(NumHandlers > 0 &&
2226 "The parser shouldn't call this if there are no handlers.");
2227 Stmt **Handlers = RawHandlers.get();
2228
2229 llvm::SmallVector<TypeWithHandler, 8> TypesWithHandlers;
2230
2231 for (unsigned i = 0; i < NumHandlers; ++i) {
2232 CXXCatchStmt *Handler = llvm::cast<CXXCatchStmt>(Handlers[i]);
2233 if (!Handler->getExceptionDecl()) {
2234 if (i < NumHandlers - 1)
2235 return StmtError(Diag(Handler->getLocStart(),
2236 diag::err_early_catch_all));
2237
2238 continue;
2239 }
2240
2241 const QualType CaughtType = Handler->getCaughtType();
2242 const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
2243 TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
2244 }
2245
2246 // Detect handlers for the same type as an earlier one.
2247 if (NumHandlers > 1) {
2248 llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
2249
2250 TypeWithHandler prev = TypesWithHandlers[0];
2251 for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
2252 TypeWithHandler curr = TypesWithHandlers[i];
2253
2254 if (curr == prev) {
2255 Diag(curr.getTypeSpecStartLoc(),
2256 diag::warn_exception_caught_by_earlier_handler)
2257 << curr.getCatchStmt()->getCaughtType().getAsString();
2258 Diag(prev.getTypeSpecStartLoc(),
2259 diag::note_previous_exception_handler)
2260 << prev.getCatchStmt()->getCaughtType().getAsString();
2261 }
2262
2263 prev = curr;
2264 }
2265 }
2266
2267 getCurFunction()->setHasBranchProtectedScope();
2268
2269 // FIXME: We should detect handlers that cannot catch anything because an
2270 // earlier handler catches a superclass. Need to find a method that is not
2271 // quadratic for this.
2272 // Neither of these are explicitly forbidden, but every compiler detects them
2273 // and warns.
2274
2275 return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
2276 Handlers, NumHandlers));
2277}
2278
2279StmtResult
2280Sema::ActOnSEHTryBlock(bool IsCXXTry,
2281 SourceLocation TryLoc,
2282 Stmt *TryBlock,
2283 Stmt *Handler) {
2284 assert(TryBlock && Handler);
2285
2286 getCurFunction()->setHasBranchProtectedScope();
2287
2288 return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
2289}
2290
2291StmtResult
2292Sema::ActOnSEHExceptBlock(SourceLocation Loc,
2293 Expr *FilterExpr,
2294 Stmt *Block) {
2295 assert(FilterExpr && Block);
2296
2297 if(!FilterExpr->getType()->isIntegerType()) {
2298 return StmtError(Diag(FilterExpr->getExprLoc(),
2299 diag::err_filter_expression_integral)
2300 << FilterExpr->getType());
2301 }
2302
2303 return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
2304}
2305
2306StmtResult
2307Sema::ActOnSEHFinallyBlock(SourceLocation Loc,
2308 Stmt *Block) {
2309 assert(Block);
2310 return Owned(SEHFinallyStmt::Create(Context,Loc,Block));
2311}
| 2234namespace {
2235
2236class TypeWithHandler {
2237 QualType t;
2238 CXXCatchStmt *stmt;
2239public:
2240 TypeWithHandler(const QualType &type, CXXCatchStmt *statement)
2241 : t(type), stmt(statement) {}
2242
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())
2247 return true;
2248 if (t.getAsOpaquePtr() > y.t.getAsOpaquePtr())
2249 return false;
2250 else
2251 return getTypeSpecStartLoc() < y.getTypeSpecStartLoc();
2252 }
2253
2254 bool operator==(const TypeWithHandler& other) const {
2255 return t == other.t;
2256 }
2257
2258 CXXCatchStmt *getCatchStmt() const { return stmt; }
2259 SourceLocation getTypeSpecStartLoc() const {
2260 return stmt->getExceptionDecl()->getTypeSpecStartLoc();
2261 }
2262};
2263
2264}
2265
2266/// ActOnCXXTryBlock - Takes a try compound-statement and a number of
2267/// handlers and creates a try statement from them.
2268StmtResult
2269Sema::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";
2275
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();
2280
2281 llvm::SmallVector<TypeWithHandler, 8> TypesWithHandlers;
2282
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));
2289
2290 continue;
2291 }
2292
2293 const QualType CaughtType = Handler->getCaughtType();
2294 const QualType CanonicalCaughtType = Context.getCanonicalType(CaughtType);
2295 TypesWithHandlers.push_back(TypeWithHandler(CanonicalCaughtType, Handler));
2296 }
2297
2298 // Detect handlers for the same type as an earlier one.
2299 if (NumHandlers > 1) {
2300 llvm::array_pod_sort(TypesWithHandlers.begin(), TypesWithHandlers.end());
2301
2302 TypeWithHandler prev = TypesWithHandlers[0];
2303 for (unsigned i = 1; i < TypesWithHandlers.size(); ++i) {
2304 TypeWithHandler curr = TypesWithHandlers[i];
2305
2306 if (curr == prev) {
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();
2313 }
2314
2315 prev = curr;
2316 }
2317 }
2318
2319 getCurFunction()->setHasBranchProtectedScope();
2320
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
2325 // and warns.
2326
2327 return Owned(CXXTryStmt::Create(Context, TryLoc, TryBlock,
2328 Handlers, NumHandlers));
2329}
2330
2331StmtResult
2332Sema::ActOnSEHTryBlock(bool IsCXXTry,
2333 SourceLocation TryLoc,
2334 Stmt *TryBlock,
2335 Stmt *Handler) {
2336 assert(TryBlock && Handler);
2337
2338 getCurFunction()->setHasBranchProtectedScope();
2339
2340 return Owned(SEHTryStmt::Create(Context,IsCXXTry,TryLoc,TryBlock,Handler));
2341}
2342
2343StmtResult
2344Sema::ActOnSEHExceptBlock(SourceLocation Loc,
2345 Expr *FilterExpr,
2346 Stmt *Block) {
2347 assert(FilterExpr && Block);
2348
2349 if(!FilterExpr->getType()->isIntegerType()) {
2350 return StmtError(Diag(FilterExpr->getExprLoc(),
2351 diag::err_filter_expression_integral)
2352 << FilterExpr->getType());
2353 }
2354
2355 return Owned(SEHExceptStmt::Create(Context,Loc,FilterExpr,Block));
2356}
2357
2358StmtResult
2359Sema::ActOnSEHFinallyBlock(SourceLocation Loc,
2360 Stmt *Block) {
2361 assert(Block);
2362 return Owned(SEHFinallyStmt::Create(Context,Loc,Block));
2363}
|
2312
| |
| |