]>
Commit | Line | Data |
---|---|---|
b4c522fa IB |
1 | |
2 | /* Compiler implementation of the D programming language | |
8e788ac6 | 3 | * Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved |
b4c522fa IB |
4 | * written by Walter Bright |
5 | * http://www.digitalmars.com | |
6 | * Distributed under the Boost Software License, Version 1.0. | |
7 | * http://www.boost.org/LICENSE_1_0.txt | |
8 | */ | |
9 | ||
10 | #include "statement.h" | |
11 | #include "declaration.h" | |
12 | #include "aggregate.h" | |
13 | #include "id.h" | |
14 | ||
15 | /* Only valid after semantic analysis | |
16 | * If 'mustNotThrow' is true, generate an error if it throws | |
17 | */ | |
18 | int blockExit(Statement *s, FuncDeclaration *func, bool mustNotThrow) | |
19 | { | |
20 | class BlockExit : public Visitor | |
21 | { | |
22 | public: | |
23 | FuncDeclaration *func; | |
24 | bool mustNotThrow; | |
25 | int result; | |
26 | ||
27 | BlockExit(FuncDeclaration *func, bool mustNotThrow) | |
28 | : func(func), mustNotThrow(mustNotThrow) | |
29 | { | |
30 | result = BEnone; | |
31 | } | |
32 | ||
33 | void visit(Statement *s) | |
34 | { | |
35 | printf("Statement::blockExit(%p)\n", s); | |
36 | printf("%s\n", s->toChars()); | |
37 | assert(0); | |
38 | result = BEany; | |
39 | } | |
40 | ||
41 | void visit(ErrorStatement *) | |
42 | { | |
43 | result = BEany; | |
44 | } | |
45 | ||
46 | void visit(ExpStatement *s) | |
47 | { | |
48 | result = BEfallthru; | |
49 | if (s->exp) | |
50 | { | |
51 | if (s->exp->op == TOKhalt) | |
52 | { | |
53 | result = BEhalt; | |
54 | return; | |
55 | } | |
56 | if (s->exp->op == TOKassert) | |
57 | { | |
58 | AssertExp *a = (AssertExp *)s->exp; | |
59 | if (a->e1->isBool(false)) // if it's an assert(0) | |
60 | { | |
61 | result = BEhalt; | |
62 | return; | |
63 | } | |
64 | } | |
65 | if (canThrow(s->exp, func, mustNotThrow)) | |
66 | result |= BEthrow; | |
67 | } | |
68 | } | |
69 | ||
70 | void visit(CompileStatement *) | |
71 | { | |
72 | assert(global.errors); | |
73 | result = BEfallthru; | |
74 | } | |
75 | ||
76 | void visit(CompoundStatement *cs) | |
77 | { | |
78 | //printf("CompoundStatement::blockExit(%p) %d result = x%X\n", cs, cs->statements->dim, result); | |
79 | result = BEfallthru; | |
80 | Statement *slast = NULL; | |
81 | for (size_t i = 0; i < cs->statements->dim; i++) | |
82 | { | |
83 | Statement *s = (*cs->statements)[i]; | |
84 | if (s) | |
85 | { | |
86 | //printf("result = x%x\n", result); | |
87 | //printf("s: %s\n", s->toChars()); | |
88 | if (result & BEfallthru && slast) | |
89 | { | |
90 | slast = slast->last(); | |
91 | if (slast && (slast->isCaseStatement() || slast->isDefaultStatement()) && | |
92 | (s->isCaseStatement() || s->isDefaultStatement())) | |
93 | { | |
94 | // Allow if last case/default was empty | |
95 | CaseStatement *sc = slast->isCaseStatement(); | |
96 | DefaultStatement *sd = slast->isDefaultStatement(); | |
97 | if (sc && (!sc->statement->hasCode() || sc->statement->isCaseStatement() || sc->statement->isErrorStatement())) | |
98 | ; | |
99 | else if (sd && (!sd->statement->hasCode() || sd->statement->isCaseStatement() || sd->statement->isErrorStatement())) | |
100 | ; | |
101 | else | |
102 | { | |
103 | const char *gototype = s->isCaseStatement() ? "case" : "default"; | |
104 | s->deprecation("switch case fallthrough - use 'goto %s;' if intended", gototype); | |
105 | } | |
106 | } | |
107 | } | |
108 | ||
109 | if (!(result & BEfallthru) && !s->comeFrom()) | |
110 | { | |
111 | if (blockExit(s, func, mustNotThrow) != BEhalt && s->hasCode()) | |
112 | s->warning("statement is not reachable"); | |
113 | } | |
114 | else | |
115 | { | |
116 | result &= ~BEfallthru; | |
117 | result |= blockExit(s, func, mustNotThrow); | |
118 | } | |
119 | slast = s; | |
120 | } | |
121 | } | |
122 | } | |
123 | ||
124 | void visit(UnrolledLoopStatement *uls) | |
125 | { | |
126 | result = BEfallthru; | |
127 | for (size_t i = 0; i < uls->statements->dim; i++) | |
128 | { | |
129 | Statement *s = (*uls->statements)[i]; | |
130 | if (s) | |
131 | { | |
132 | int r = blockExit(s, func, mustNotThrow); | |
133 | result |= r & ~(BEbreak | BEcontinue | BEfallthru); | |
134 | if ((r & (BEfallthru | BEcontinue | BEbreak)) == 0) | |
135 | result &= ~BEfallthru; | |
136 | } | |
137 | } | |
138 | } | |
139 | ||
140 | void visit(ScopeStatement *s) | |
141 | { | |
142 | //printf("ScopeStatement::blockExit(%p)\n", s->statement); | |
143 | result = s->statement ? blockExit(s->statement, func, mustNotThrow) : BEfallthru; | |
144 | } | |
145 | ||
146 | void visit(WhileStatement *) | |
147 | { | |
148 | assert(global.errors); | |
149 | result = BEfallthru; | |
150 | } | |
151 | ||
152 | void visit(DoStatement *s) | |
153 | { | |
154 | if (s->_body) | |
155 | { | |
156 | result = blockExit(s->_body, func, mustNotThrow); | |
157 | if (result == BEbreak) | |
158 | { | |
159 | result = BEfallthru; | |
160 | return; | |
161 | } | |
162 | if (result & BEcontinue) | |
163 | result |= BEfallthru; | |
164 | } | |
165 | else | |
166 | result = BEfallthru; | |
167 | if (result & BEfallthru) | |
168 | { | |
169 | if (canThrow(s->condition, func, mustNotThrow)) | |
170 | result |= BEthrow; | |
171 | if (!(result & BEbreak) && s->condition->isBool(true)) | |
172 | result &= ~BEfallthru; | |
173 | } | |
174 | result &= ~(BEbreak | BEcontinue); | |
175 | } | |
176 | ||
177 | void visit(ForStatement *s) | |
178 | { | |
179 | result = BEfallthru; | |
180 | if (s->_init) | |
181 | { | |
182 | result = blockExit(s->_init, func, mustNotThrow); | |
183 | if (!(result & BEfallthru)) | |
184 | return; | |
185 | } | |
186 | if (s->condition) | |
187 | { | |
188 | if (canThrow(s->condition, func, mustNotThrow)) | |
189 | result |= BEthrow; | |
190 | if (s->condition->isBool(true)) | |
191 | result &= ~BEfallthru; | |
192 | else if (s->condition->isBool(false)) | |
193 | return; | |
194 | } | |
195 | else | |
196 | result &= ~BEfallthru; // the body must do the exiting | |
197 | if (s->_body) | |
198 | { | |
199 | int r = blockExit(s->_body, func, mustNotThrow); | |
200 | if (r & (BEbreak | BEgoto)) | |
201 | result |= BEfallthru; | |
202 | result |= r & ~(BEfallthru | BEbreak | BEcontinue); | |
203 | } | |
204 | if (s->increment && canThrow(s->increment, func, mustNotThrow)) | |
205 | result |= BEthrow; | |
206 | } | |
207 | ||
208 | void visit(ForeachStatement *s) | |
209 | { | |
210 | result = BEfallthru; | |
211 | if (canThrow(s->aggr, func, mustNotThrow)) | |
212 | result |= BEthrow; | |
213 | if (s->_body) | |
214 | result |= blockExit(s->_body, func, mustNotThrow) & ~(BEbreak | BEcontinue); | |
215 | } | |
216 | ||
217 | void visit(ForeachRangeStatement *) | |
218 | { | |
219 | assert(global.errors); | |
220 | result = BEfallthru; | |
221 | } | |
222 | ||
223 | void visit(IfStatement *s) | |
224 | { | |
225 | //printf("IfStatement::blockExit(%p)\n", s); | |
226 | ||
227 | result = BEnone; | |
228 | if (canThrow(s->condition, func, mustNotThrow)) | |
229 | result |= BEthrow; | |
230 | if (s->condition->isBool(true)) | |
231 | { | |
232 | if (s->ifbody) | |
233 | result |= blockExit(s->ifbody, func, mustNotThrow); | |
234 | else | |
235 | result |= BEfallthru; | |
236 | } | |
237 | else if (s->condition->isBool(false)) | |
238 | { | |
239 | if (s->elsebody) | |
240 | result |= blockExit(s->elsebody, func, mustNotThrow); | |
241 | else | |
242 | result |= BEfallthru; | |
243 | } | |
244 | else | |
245 | { | |
246 | if (s->ifbody) | |
247 | result |= blockExit(s->ifbody, func, mustNotThrow); | |
248 | else | |
249 | result |= BEfallthru; | |
250 | if (s->elsebody) | |
251 | result |= blockExit(s->elsebody, func, mustNotThrow); | |
252 | else | |
253 | result |= BEfallthru; | |
254 | } | |
255 | //printf("IfStatement::blockExit(%p) = x%x\n", s, result); | |
256 | } | |
257 | ||
258 | void visit(ConditionalStatement *s) | |
259 | { | |
260 | result = blockExit(s->ifbody, func, mustNotThrow); | |
261 | if (s->elsebody) | |
262 | result |= blockExit(s->elsebody, func, mustNotThrow); | |
263 | } | |
264 | ||
265 | void visit(PragmaStatement *) | |
266 | { | |
267 | result = BEfallthru; | |
268 | } | |
269 | ||
270 | void visit(StaticAssertStatement *) | |
271 | { | |
272 | result = BEfallthru; | |
273 | } | |
274 | ||
275 | void visit(SwitchStatement *s) | |
276 | { | |
277 | result = BEnone; | |
278 | if (canThrow(s->condition, func, mustNotThrow)) | |
279 | result |= BEthrow; | |
280 | if (s->_body) | |
281 | { | |
282 | result |= blockExit(s->_body, func, mustNotThrow); | |
283 | if (result & BEbreak) | |
284 | { | |
285 | result |= BEfallthru; | |
286 | result &= ~BEbreak; | |
287 | } | |
288 | } | |
289 | else | |
290 | result |= BEfallthru; | |
291 | } | |
292 | ||
293 | void visit(CaseStatement *s) | |
294 | { | |
295 | result = blockExit(s->statement, func, mustNotThrow); | |
296 | } | |
297 | ||
298 | void visit(DefaultStatement *s) | |
299 | { | |
300 | result = blockExit(s->statement, func, mustNotThrow); | |
301 | } | |
302 | ||
303 | void visit(GotoDefaultStatement *) | |
304 | { | |
305 | result = BEgoto; | |
306 | } | |
307 | ||
308 | void visit(GotoCaseStatement *) | |
309 | { | |
310 | result = BEgoto; | |
311 | } | |
312 | ||
313 | void visit(SwitchErrorStatement *) | |
314 | { | |
315 | // Switch errors are non-recoverable | |
316 | result = BEhalt; | |
317 | } | |
318 | ||
319 | void visit(ReturnStatement *s) | |
320 | { | |
321 | result = BEreturn; | |
322 | if (s->exp && canThrow(s->exp, func, mustNotThrow)) | |
323 | result |= BEthrow; | |
324 | } | |
325 | ||
326 | void visit(BreakStatement *s) | |
327 | { | |
328 | //printf("BreakStatement::blockExit(%p) = x%x\n", s, s->ident ? BEgoto : BEbreak); | |
329 | result = s->ident ? BEgoto : BEbreak; | |
330 | } | |
331 | ||
332 | void visit(ContinueStatement *s) | |
333 | { | |
334 | result = s->ident ? BEgoto : BEcontinue; | |
335 | } | |
336 | ||
337 | void visit(SynchronizedStatement *s) | |
338 | { | |
339 | result = s->_body ? blockExit(s->_body, func, mustNotThrow) : BEfallthru; | |
340 | } | |
341 | ||
342 | void visit(WithStatement *s) | |
343 | { | |
344 | result = BEnone; | |
345 | if (canThrow(s->exp, func, mustNotThrow)) | |
346 | result = BEthrow; | |
347 | if (s->_body) | |
348 | result |= blockExit(s->_body, func, mustNotThrow); | |
349 | else | |
350 | result |= BEfallthru; | |
351 | } | |
352 | ||
353 | void visit(TryCatchStatement *s) | |
354 | { | |
355 | assert(s->_body); | |
356 | result = blockExit(s->_body, func, false); | |
357 | ||
358 | int catchresult = 0; | |
359 | for (size_t i = 0; i < s->catches->dim; i++) | |
360 | { | |
361 | Catch *c = (*s->catches)[i]; | |
362 | if (c->type == Type::terror) | |
363 | continue; | |
364 | ||
365 | int cresult; | |
366 | if (c->handler) | |
367 | cresult = blockExit(c->handler, func, mustNotThrow); | |
368 | else | |
369 | cresult = BEfallthru; | |
370 | ||
371 | /* If we're catching Object, then there is no throwing | |
372 | */ | |
373 | Identifier *id = c->type->toBasetype()->isClassHandle()->ident; | |
374 | if (c->internalCatch && (cresult & BEfallthru)) | |
375 | { | |
376 | // Bugzilla 11542: leave blockExit flags of the body | |
377 | cresult &= ~BEfallthru; | |
378 | } | |
379 | else if (id == Id::Object || id == Id::Throwable) | |
380 | { | |
381 | result &= ~(BEthrow | BEerrthrow); | |
382 | } | |
383 | else if (id == Id::Exception) | |
384 | { | |
385 | result &= ~BEthrow; | |
386 | } | |
387 | catchresult |= cresult; | |
388 | } | |
389 | if (mustNotThrow && (result & BEthrow)) | |
390 | { | |
391 | // now explain why this is nothrow | |
392 | blockExit(s->_body, func, mustNotThrow); | |
393 | } | |
394 | result |= catchresult; | |
395 | } | |
396 | ||
397 | void visit(TryFinallyStatement *s) | |
398 | { | |
399 | result = BEfallthru; | |
400 | if (s->_body) | |
401 | result = blockExit(s->_body, func, false); | |
402 | ||
403 | // check finally body as well, it may throw (bug #4082) | |
404 | int finalresult = BEfallthru; | |
405 | if (s->finalbody) | |
406 | finalresult = blockExit(s->finalbody, func, false); | |
407 | ||
408 | // If either body or finalbody halts | |
409 | if (result == BEhalt) | |
410 | finalresult = BEnone; | |
411 | if (finalresult == BEhalt) | |
412 | result = BEnone; | |
413 | ||
414 | if (mustNotThrow) | |
415 | { | |
416 | // now explain why this is nothrow | |
417 | if (s->_body && (result & BEthrow)) | |
418 | blockExit(s->_body, func, mustNotThrow); | |
419 | if (s->finalbody && (finalresult & BEthrow)) | |
420 | blockExit(s->finalbody, func, mustNotThrow); | |
421 | } | |
422 | ||
423 | #if 0 | |
424 | // Bugzilla 13201: Mask to prevent spurious warnings for | |
425 | // destructor call, exit of synchronized statement, etc. | |
426 | if (result == BEhalt && finalresult != BEhalt && s->finalbody && | |
427 | s->finalbody->hasCode()) | |
428 | { | |
429 | s->finalbody->warning("statement is not reachable"); | |
430 | } | |
431 | #endif | |
432 | ||
433 | if (!(finalresult & BEfallthru)) | |
434 | result &= ~BEfallthru; | |
435 | result |= finalresult & ~BEfallthru; | |
436 | } | |
437 | ||
438 | void visit(OnScopeStatement *) | |
439 | { | |
440 | // At this point, this statement is just an empty placeholder | |
441 | result = BEfallthru; | |
442 | } | |
443 | ||
444 | void visit(ThrowStatement *s) | |
445 | { | |
446 | if (s->internalThrow) | |
447 | { | |
448 | // Bugzilla 8675: Allow throwing 'Throwable' object even if mustNotThrow. | |
449 | result = BEfallthru; | |
450 | return; | |
451 | } | |
452 | ||
453 | Type *t = s->exp->type->toBasetype(); | |
454 | ClassDeclaration *cd = t->isClassHandle(); | |
455 | assert(cd); | |
456 | ||
457 | if (cd == ClassDeclaration::errorException || | |
458 | ClassDeclaration::errorException->isBaseOf(cd, NULL)) | |
459 | { | |
460 | result = BEerrthrow; | |
461 | return; | |
462 | } | |
463 | if (mustNotThrow) | |
464 | s->error("%s is thrown but not caught", s->exp->type->toChars()); | |
465 | ||
466 | result = BEthrow; | |
467 | } | |
468 | ||
469 | void visit(GotoStatement *) | |
470 | { | |
471 | //printf("GotoStatement::blockExit(%p)\n", s); | |
472 | result = BEgoto; | |
473 | } | |
474 | ||
475 | void visit(LabelStatement *s) | |
476 | { | |
477 | //printf("LabelStatement::blockExit(%p)\n", s); | |
478 | result = s->statement ? blockExit(s->statement, func, mustNotThrow) : BEfallthru; | |
479 | if (s->breaks) | |
480 | result |= BEfallthru; | |
481 | } | |
482 | ||
483 | void visit(CompoundAsmStatement *s) | |
484 | { | |
485 | if (mustNotThrow && !(s->stc & STCnothrow)) | |
486 | s->deprecation("asm statement is assumed to throw - mark it with 'nothrow' if it does not"); | |
487 | ||
488 | // Assume the worst | |
489 | result = BEfallthru | BEreturn | BEgoto | BEhalt; | |
490 | if (!(s->stc & STCnothrow)) result |= BEthrow; | |
491 | } | |
492 | ||
493 | void visit(ImportStatement *) | |
494 | { | |
495 | result = BEfallthru; | |
496 | } | |
497 | }; | |
498 | ||
5767d76f IB |
499 | if (!s) |
500 | return BEfallthru; | |
b4c522fa IB |
501 | BlockExit be(func, mustNotThrow); |
502 | s->accept(&be); | |
503 | return be.result; | |
504 | } |