]>
Commit | Line | Data |
---|---|---|
4ee9c684 | 1 | /* Exception handling semantics and decomposition for trees. |
a9309f85 | 2 | Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 |
cfaf579d | 3 | Free Software Foundation, Inc. |
4ee9c684 | 4 | |
5 | This file is part of GCC. | |
6 | ||
7 | GCC is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
8c4c00c1 | 9 | the Free Software Foundation; either version 3, or (at your option) |
4ee9c684 | 10 | any later version. |
11 | ||
12 | GCC is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
8c4c00c1 | 18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ | |
4ee9c684 | 20 | |
21 | #include "config.h" | |
22 | #include "system.h" | |
23 | #include "coretypes.h" | |
24 | #include "tm.h" | |
25 | #include "tree.h" | |
4ee9c684 | 26 | #include "flags.h" |
27 | #include "function.h" | |
28 | #include "except.h" | |
778f5bdd | 29 | #include "pointer-set.h" |
4ee9c684 | 30 | #include "tree-flow.h" |
4ee9c684 | 31 | #include "tree-inline.h" |
4ee9c684 | 32 | #include "tree-pass.h" |
4ee9c684 | 33 | #include "langhooks.h" |
34 | #include "ggc.h" | |
0b205f4c | 35 | #include "diagnostic-core.h" |
75a70cf9 | 36 | #include "gimple.h" |
e38def9c | 37 | #include "target.h" |
79f958cb | 38 | #include "cfgloop.h" |
75a70cf9 | 39 | |
40 | /* In some instances a tree and a gimple need to be stored in a same table, | |
41 | i.e. in hash tables. This is a structure to do this. */ | |
42 | typedef union {tree *tp; tree t; gimple g;} treemple; | |
4ee9c684 | 43 | |
873f1e89 | 44 | /* Nonzero if we are using EH to handle cleanups. */ |
45 | static int using_eh_for_cleanups_p = 0; | |
46 | ||
47 | void | |
48 | using_eh_for_cleanups (void) | |
49 | { | |
50 | using_eh_for_cleanups_p = 1; | |
51 | } | |
75a70cf9 | 52 | |
4ee9c684 | 53 | /* Misc functions used in this file. */ |
54 | ||
e38def9c | 55 | /* Remember and lookup EH landing pad data for arbitrary statements. |
4ee9c684 | 56 | Really this means any statement that could_throw_p. We could |
57 | stuff this information into the stmt_ann data structure, but: | |
58 | ||
59 | (1) We absolutely rely on this information being kept until | |
60 | we get to rtl. Once we're done with lowering here, if we lose | |
61 | the information there's no way to recover it! | |
62 | ||
ac13e8d9 | 63 | (2) There are many more statements that *cannot* throw as |
4ee9c684 | 64 | compared to those that can. We should be saving some amount |
65 | of space by only allocating memory for those that can throw. */ | |
66 | ||
e38def9c | 67 | /* Add statement T in function IFUN to landing pad NUM. */ |
75a70cf9 | 68 | |
4ee9c684 | 69 | void |
e38def9c | 70 | add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num) |
4ee9c684 | 71 | { |
72 | struct throw_stmt_node *n; | |
73 | void **slot; | |
74 | ||
e38def9c | 75 | gcc_assert (num != 0); |
4ee9c684 | 76 | |
ba72912a | 77 | n = ggc_alloc_throw_stmt_node (); |
4ee9c684 | 78 | n->stmt = t; |
e38def9c | 79 | n->lp_nr = num; |
4ee9c684 | 80 | |
0de999f1 | 81 | if (!get_eh_throw_stmt_table (ifun)) |
82 | set_eh_throw_stmt_table (ifun, htab_create_ggc (31, struct_ptr_hash, | |
83 | struct_ptr_eq, | |
84 | ggc_free)); | |
85 | ||
b3f1469f | 86 | slot = htab_find_slot (get_eh_throw_stmt_table (ifun), n, INSERT); |
8c0963c4 | 87 | gcc_assert (!*slot); |
4ee9c684 | 88 | *slot = n; |
89 | } | |
35c15734 | 90 | |
e38def9c | 91 | /* Add statement T in the current function (cfun) to EH landing pad NUM. */ |
75a70cf9 | 92 | |
b3f1469f | 93 | void |
e38def9c | 94 | add_stmt_to_eh_lp (gimple t, int num) |
b3f1469f | 95 | { |
e38def9c | 96 | add_stmt_to_eh_lp_fn (cfun, t, num); |
97 | } | |
98 | ||
99 | /* Add statement T to the single EH landing pad in REGION. */ | |
100 | ||
101 | static void | |
102 | record_stmt_eh_region (eh_region region, gimple t) | |
103 | { | |
104 | if (region == NULL) | |
105 | return; | |
106 | if (region->type == ERT_MUST_NOT_THROW) | |
107 | add_stmt_to_eh_lp_fn (cfun, t, -region->index); | |
108 | else | |
109 | { | |
110 | eh_landing_pad lp = region->landing_pads; | |
111 | if (lp == NULL) | |
112 | lp = gen_eh_landing_pad (region); | |
113 | else | |
114 | gcc_assert (lp->next_lp == NULL); | |
115 | add_stmt_to_eh_lp_fn (cfun, t, lp->index); | |
116 | } | |
b3f1469f | 117 | } |
118 | ||
75a70cf9 | 119 | |
e38def9c | 120 | /* Remove statement T in function IFUN from its EH landing pad. */ |
75a70cf9 | 121 | |
35c15734 | 122 | bool |
e38def9c | 123 | remove_stmt_from_eh_lp_fn (struct function *ifun, gimple t) |
35c15734 | 124 | { |
125 | struct throw_stmt_node dummy; | |
126 | void **slot; | |
127 | ||
b3f1469f | 128 | if (!get_eh_throw_stmt_table (ifun)) |
35c15734 | 129 | return false; |
130 | ||
131 | dummy.stmt = t; | |
b3f1469f | 132 | slot = htab_find_slot (get_eh_throw_stmt_table (ifun), &dummy, |
133 | NO_INSERT); | |
35c15734 | 134 | if (slot) |
135 | { | |
b3f1469f | 136 | htab_clear_slot (get_eh_throw_stmt_table (ifun), slot); |
35c15734 | 137 | return true; |
138 | } | |
139 | else | |
140 | return false; | |
141 | } | |
142 | ||
75a70cf9 | 143 | |
e38def9c | 144 | /* Remove statement T in the current function (cfun) from its |
145 | EH landing pad. */ | |
75a70cf9 | 146 | |
b3f1469f | 147 | bool |
e38def9c | 148 | remove_stmt_from_eh_lp (gimple t) |
b3f1469f | 149 | { |
e38def9c | 150 | return remove_stmt_from_eh_lp_fn (cfun, t); |
b3f1469f | 151 | } |
152 | ||
75a70cf9 | 153 | /* Determine if statement T is inside an EH region in function IFUN. |
e38def9c | 154 | Positive numbers indicate a landing pad index; negative numbers |
155 | indicate a MUST_NOT_THROW region index; zero indicates that the | |
156 | statement is not recorded in the region table. */ | |
75a70cf9 | 157 | |
4ee9c684 | 158 | int |
e38def9c | 159 | lookup_stmt_eh_lp_fn (struct function *ifun, gimple t) |
4ee9c684 | 160 | { |
161 | struct throw_stmt_node *p, n; | |
162 | ||
e38def9c | 163 | if (ifun->eh->throw_stmt_table == NULL) |
164 | return 0; | |
4ee9c684 | 165 | |
75a70cf9 | 166 | n.stmt = t; |
e38def9c | 167 | p = (struct throw_stmt_node *) htab_find (ifun->eh->throw_stmt_table, &n); |
168 | return p ? p->lp_nr : 0; | |
4ee9c684 | 169 | } |
170 | ||
e38def9c | 171 | /* Likewise, but always use the current function. */ |
75a70cf9 | 172 | |
b3f1469f | 173 | int |
e38def9c | 174 | lookup_stmt_eh_lp (gimple t) |
b3f1469f | 175 | { |
176 | /* We can get called from initialized data when -fnon-call-exceptions | |
177 | is on; prevent crash. */ | |
178 | if (!cfun) | |
e38def9c | 179 | return 0; |
180 | return lookup_stmt_eh_lp_fn (cfun, t); | |
b3f1469f | 181 | } |
4ee9c684 | 182 | |
75a70cf9 | 183 | /* First pass of EH node decomposition. Build up a tree of GIMPLE_TRY_FINALLY |
4ee9c684 | 184 | nodes and LABEL_DECL nodes. We will use this during the second phase to |
185 | determine if a goto leaves the body of a TRY_FINALLY_EXPR node. */ | |
186 | ||
187 | struct finally_tree_node | |
188 | { | |
75a70cf9 | 189 | /* When storing a GIMPLE_TRY, we have to record a gimple. However |
190 | when deciding whether a GOTO to a certain LABEL_DECL (which is a | |
191 | tree) leaves the TRY block, its necessary to record a tree in | |
192 | this field. Thus a treemple is used. */ | |
e38def9c | 193 | treemple child; |
75a70cf9 | 194 | gimple parent; |
4ee9c684 | 195 | }; |
196 | ||
197 | /* Note that this table is *not* marked GTY. It is short-lived. */ | |
198 | static htab_t finally_tree; | |
199 | ||
200 | static void | |
75a70cf9 | 201 | record_in_finally_tree (treemple child, gimple parent) |
4ee9c684 | 202 | { |
203 | struct finally_tree_node *n; | |
204 | void **slot; | |
205 | ||
680a19b9 | 206 | n = XNEW (struct finally_tree_node); |
4ee9c684 | 207 | n->child = child; |
208 | n->parent = parent; | |
209 | ||
210 | slot = htab_find_slot (finally_tree, n, INSERT); | |
8c0963c4 | 211 | gcc_assert (!*slot); |
4ee9c684 | 212 | *slot = n; |
213 | } | |
214 | ||
215 | static void | |
75a70cf9 | 216 | collect_finally_tree (gimple stmt, gimple region); |
217 | ||
e38def9c | 218 | /* Go through the gimple sequence. Works with collect_finally_tree to |
75a70cf9 | 219 | record all GIMPLE_LABEL and GIMPLE_TRY statements. */ |
220 | ||
221 | static void | |
222 | collect_finally_tree_1 (gimple_seq seq, gimple region) | |
4ee9c684 | 223 | { |
75a70cf9 | 224 | gimple_stmt_iterator gsi; |
4ee9c684 | 225 | |
75a70cf9 | 226 | for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi)) |
227 | collect_finally_tree (gsi_stmt (gsi), region); | |
228 | } | |
4ee9c684 | 229 | |
75a70cf9 | 230 | static void |
231 | collect_finally_tree (gimple stmt, gimple region) | |
232 | { | |
233 | treemple temp; | |
234 | ||
235 | switch (gimple_code (stmt)) | |
236 | { | |
237 | case GIMPLE_LABEL: | |
238 | temp.t = gimple_label_label (stmt); | |
239 | record_in_finally_tree (temp, region); | |
240 | break; | |
4ee9c684 | 241 | |
75a70cf9 | 242 | case GIMPLE_TRY: |
243 | if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY) | |
244 | { | |
245 | temp.g = stmt; | |
246 | record_in_finally_tree (temp, region); | |
247 | collect_finally_tree_1 (gimple_try_eval (stmt), stmt); | |
248 | collect_finally_tree_1 (gimple_try_cleanup (stmt), region); | |
249 | } | |
250 | else if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH) | |
251 | { | |
252 | collect_finally_tree_1 (gimple_try_eval (stmt), region); | |
253 | collect_finally_tree_1 (gimple_try_cleanup (stmt), region); | |
254 | } | |
255 | break; | |
4ee9c684 | 256 | |
75a70cf9 | 257 | case GIMPLE_CATCH: |
258 | collect_finally_tree_1 (gimple_catch_handler (stmt), region); | |
259 | break; | |
4ee9c684 | 260 | |
75a70cf9 | 261 | case GIMPLE_EH_FILTER: |
262 | collect_finally_tree_1 (gimple_eh_filter_failure (stmt), region); | |
4ee9c684 | 263 | break; |
264 | ||
4c0315d0 | 265 | case GIMPLE_EH_ELSE: |
266 | collect_finally_tree_1 (gimple_eh_else_n_body (stmt), region); | |
267 | collect_finally_tree_1 (gimple_eh_else_e_body (stmt), region); | |
268 | break; | |
269 | ||
4ee9c684 | 270 | default: |
271 | /* A type, a decl, or some kind of statement that we're not | |
272 | interested in. Don't walk them. */ | |
273 | break; | |
274 | } | |
275 | } | |
276 | ||
75a70cf9 | 277 | |
4ee9c684 | 278 | /* Use the finally tree to determine if a jump from START to TARGET |
279 | would leave the try_finally node that START lives in. */ | |
280 | ||
281 | static bool | |
75a70cf9 | 282 | outside_finally_tree (treemple start, gimple target) |
4ee9c684 | 283 | { |
284 | struct finally_tree_node n, *p; | |
285 | ||
286 | do | |
287 | { | |
288 | n.child = start; | |
680a19b9 | 289 | p = (struct finally_tree_node *) htab_find (finally_tree, &n); |
4ee9c684 | 290 | if (!p) |
291 | return true; | |
75a70cf9 | 292 | start.g = p->parent; |
4ee9c684 | 293 | } |
75a70cf9 | 294 | while (start.g != target); |
4ee9c684 | 295 | |
296 | return false; | |
297 | } | |
75a70cf9 | 298 | |
299 | /* Second pass of EH node decomposition. Actually transform the GIMPLE_TRY | |
300 | nodes into a set of gotos, magic labels, and eh regions. | |
4ee9c684 | 301 | The eh region creation is straight-forward, but frobbing all the gotos |
302 | and such into shape isn't. */ | |
303 | ||
48e1416a | 304 | /* The sequence into which we record all EH stuff. This will be |
e38def9c | 305 | placed at the end of the function when we're all done. */ |
306 | static gimple_seq eh_seq; | |
307 | ||
308 | /* Record whether an EH region contains something that can throw, | |
309 | indexed by EH region number. */ | |
55d6d4e4 | 310 | static bitmap eh_region_may_contain_throw_map; |
e38def9c | 311 | |
0b09525f | 312 | /* The GOTO_QUEUE is is an array of GIMPLE_GOTO and GIMPLE_RETURN |
313 | statements that are seen to escape this GIMPLE_TRY_FINALLY node. | |
314 | The idea is to record a gimple statement for everything except for | |
315 | the conditionals, which get their labels recorded. Since labels are | |
316 | of type 'tree', we need this node to store both gimple and tree | |
317 | objects. REPL_STMT is the sequence used to replace the goto/return | |
318 | statement. CONT_STMT is used to store the statement that allows | |
319 | the return/goto to jump to the original destination. */ | |
320 | ||
321 | struct goto_queue_node | |
322 | { | |
323 | treemple stmt; | |
d7ebacec | 324 | location_t location; |
0b09525f | 325 | gimple_seq repl_stmt; |
326 | gimple cont_stmt; | |
327 | int index; | |
328 | /* This is used when index >= 0 to indicate that stmt is a label (as | |
329 | opposed to a goto stmt). */ | |
330 | int is_label; | |
331 | }; | |
332 | ||
4ee9c684 | 333 | /* State of the world while lowering. */ |
334 | ||
335 | struct leh_state | |
336 | { | |
ac13e8d9 | 337 | /* What's "current" while constructing the eh region tree. These |
4ee9c684 | 338 | correspond to variables of the same name in cfun->eh, which we |
339 | don't have easy access to. */ | |
e38def9c | 340 | eh_region cur_region; |
341 | ||
342 | /* What's "current" for the purposes of __builtin_eh_pointer. For | |
343 | a CATCH, this is the associated TRY. For an EH_FILTER, this is | |
344 | the associated ALLOWED_EXCEPTIONS, etc. */ | |
345 | eh_region ehp_region; | |
4ee9c684 | 346 | |
347 | /* Processing of TRY_FINALLY requires a bit more state. This is | |
348 | split out into a separate structure so that we don't have to | |
349 | copy so much when processing other nodes. */ | |
350 | struct leh_tf_state *tf; | |
351 | }; | |
352 | ||
353 | struct leh_tf_state | |
354 | { | |
75a70cf9 | 355 | /* Pointer to the GIMPLE_TRY_FINALLY node under discussion. The |
356 | try_finally_expr is the original GIMPLE_TRY_FINALLY. We need to retain | |
357 | this so that outside_finally_tree can reliably reference the tree used | |
358 | in the collect_finally_tree data structures. */ | |
359 | gimple try_finally_expr; | |
360 | gimple top_p; | |
e38def9c | 361 | |
75a70cf9 | 362 | /* While lowering a top_p usually it is expanded into multiple statements, |
363 | thus we need the following field to store them. */ | |
364 | gimple_seq top_p_seq; | |
4ee9c684 | 365 | |
366 | /* The state outside this try_finally node. */ | |
367 | struct leh_state *outer; | |
368 | ||
369 | /* The exception region created for it. */ | |
e38def9c | 370 | eh_region region; |
4ee9c684 | 371 | |
0b09525f | 372 | /* The goto queue. */ |
373 | struct goto_queue_node *goto_queue; | |
4ee9c684 | 374 | size_t goto_queue_size; |
375 | size_t goto_queue_active; | |
376 | ||
f0b5f617 | 377 | /* Pointer map to help in searching goto_queue when it is large. */ |
46699809 | 378 | struct pointer_map_t *goto_queue_map; |
379 | ||
4ee9c684 | 380 | /* The set of unique labels seen as entries in the goto queue. */ |
8cb529a5 | 381 | VEC(tree,heap) *dest_array; |
4ee9c684 | 382 | |
383 | /* A label to be added at the end of the completed transformed | |
384 | sequence. It will be set if may_fallthru was true *at one time*, | |
385 | though subsequent transformations may have cleared that flag. */ | |
386 | tree fallthru_label; | |
387 | ||
4ee9c684 | 388 | /* True if it is possible to fall out the bottom of the try block. |
389 | Cleared if the fallthru is converted to a goto. */ | |
390 | bool may_fallthru; | |
391 | ||
75a70cf9 | 392 | /* True if any entry in goto_queue is a GIMPLE_RETURN. */ |
4ee9c684 | 393 | bool may_return; |
394 | ||
395 | /* True if the finally block can receive an exception edge. | |
396 | Cleared if the exception case is handled by code duplication. */ | |
397 | bool may_throw; | |
398 | }; | |
399 | ||
e38def9c | 400 | static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple); |
4ee9c684 | 401 | |
4ee9c684 | 402 | /* Search for STMT in the goto queue. Return the replacement, |
403 | or null if the statement isn't in the queue. */ | |
404 | ||
46699809 | 405 | #define LARGE_GOTO_QUEUE 20 |
406 | ||
e3a19533 | 407 | static void lower_eh_constructs_1 (struct leh_state *state, gimple_seq *seq); |
75a70cf9 | 408 | |
409 | static gimple_seq | |
410 | find_goto_replacement (struct leh_tf_state *tf, treemple stmt) | |
4ee9c684 | 411 | { |
46699809 | 412 | unsigned int i; |
413 | void **slot; | |
414 | ||
415 | if (tf->goto_queue_active < LARGE_GOTO_QUEUE) | |
416 | { | |
417 | for (i = 0; i < tf->goto_queue_active; i++) | |
75a70cf9 | 418 | if ( tf->goto_queue[i].stmt.g == stmt.g) |
46699809 | 419 | return tf->goto_queue[i].repl_stmt; |
420 | return NULL; | |
421 | } | |
422 | ||
423 | /* If we have a large number of entries in the goto_queue, create a | |
424 | pointer map and use that for searching. */ | |
425 | ||
426 | if (!tf->goto_queue_map) | |
427 | { | |
428 | tf->goto_queue_map = pointer_map_create (); | |
429 | for (i = 0; i < tf->goto_queue_active; i++) | |
430 | { | |
75a70cf9 | 431 | slot = pointer_map_insert (tf->goto_queue_map, |
432 | tf->goto_queue[i].stmt.g); | |
46699809 | 433 | gcc_assert (*slot == NULL); |
75a70cf9 | 434 | *slot = &tf->goto_queue[i]; |
46699809 | 435 | } |
436 | } | |
437 | ||
75a70cf9 | 438 | slot = pointer_map_contains (tf->goto_queue_map, stmt.g); |
46699809 | 439 | if (slot != NULL) |
440 | return (((struct goto_queue_node *) *slot)->repl_stmt); | |
441 | ||
442 | return NULL; | |
4ee9c684 | 443 | } |
444 | ||
445 | /* A subroutine of replace_goto_queue_1. Handles the sub-clauses of a | |
75a70cf9 | 446 | lowered GIMPLE_COND. If, by chance, the replacement is a simple goto, |
4ee9c684 | 447 | then we can just splat it in, otherwise we add the new stmts immediately |
75a70cf9 | 448 | after the GIMPLE_COND and redirect. */ |
4ee9c684 | 449 | |
450 | static void | |
451 | replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf, | |
75a70cf9 | 452 | gimple_stmt_iterator *gsi) |
4ee9c684 | 453 | { |
75a70cf9 | 454 | tree label; |
f4e36c33 | 455 | gimple_seq new_seq; |
75a70cf9 | 456 | treemple temp; |
e60a6f7b | 457 | location_t loc = gimple_location (gsi_stmt (*gsi)); |
4ee9c684 | 458 | |
75a70cf9 | 459 | temp.tp = tp; |
f4e36c33 | 460 | new_seq = find_goto_replacement (tf, temp); |
461 | if (!new_seq) | |
4ee9c684 | 462 | return; |
463 | ||
f4e36c33 | 464 | if (gimple_seq_singleton_p (new_seq) |
465 | && gimple_code (gimple_seq_first_stmt (new_seq)) == GIMPLE_GOTO) | |
4ee9c684 | 466 | { |
f4e36c33 | 467 | *tp = gimple_goto_dest (gimple_seq_first_stmt (new_seq)); |
4ee9c684 | 468 | return; |
469 | } | |
470 | ||
e60a6f7b | 471 | label = create_artificial_label (loc); |
75a70cf9 | 472 | /* Set the new label for the GIMPLE_COND */ |
473 | *tp = label; | |
4ee9c684 | 474 | |
75a70cf9 | 475 | gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING); |
f4e36c33 | 476 | gsi_insert_seq_after (gsi, gimple_seq_copy (new_seq), GSI_CONTINUE_LINKING); |
4ee9c684 | 477 | } |
478 | ||
ac13e8d9 | 479 | /* The real work of replace_goto_queue. Returns with TSI updated to |
4ee9c684 | 480 | point to the next statement. */ |
481 | ||
e3a19533 | 482 | static void replace_goto_queue_stmt_list (gimple_seq *, struct leh_tf_state *); |
4ee9c684 | 483 | |
484 | static void | |
75a70cf9 | 485 | replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf, |
486 | gimple_stmt_iterator *gsi) | |
4ee9c684 | 487 | { |
75a70cf9 | 488 | gimple_seq seq; |
489 | treemple temp; | |
490 | temp.g = NULL; | |
491 | ||
492 | switch (gimple_code (stmt)) | |
4ee9c684 | 493 | { |
75a70cf9 | 494 | case GIMPLE_GOTO: |
495 | case GIMPLE_RETURN: | |
496 | temp.g = stmt; | |
497 | seq = find_goto_replacement (tf, temp); | |
498 | if (seq) | |
4ee9c684 | 499 | { |
75a70cf9 | 500 | gsi_insert_seq_before (gsi, gimple_seq_copy (seq), GSI_SAME_STMT); |
501 | gsi_remove (gsi, false); | |
4ee9c684 | 502 | return; |
503 | } | |
504 | break; | |
505 | ||
75a70cf9 | 506 | case GIMPLE_COND: |
507 | replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 2), tf, gsi); | |
508 | replace_goto_queue_cond_clause (gimple_op_ptr (stmt, 3), tf, gsi); | |
4ee9c684 | 509 | break; |
510 | ||
75a70cf9 | 511 | case GIMPLE_TRY: |
e3a19533 | 512 | replace_goto_queue_stmt_list (gimple_try_eval_ptr (stmt), tf); |
513 | replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt), tf); | |
4ee9c684 | 514 | break; |
75a70cf9 | 515 | case GIMPLE_CATCH: |
e3a19533 | 516 | replace_goto_queue_stmt_list (gimple_catch_handler_ptr (stmt), tf); |
4ee9c684 | 517 | break; |
75a70cf9 | 518 | case GIMPLE_EH_FILTER: |
e3a19533 | 519 | replace_goto_queue_stmt_list (gimple_eh_filter_failure_ptr (stmt), tf); |
4ee9c684 | 520 | break; |
4c0315d0 | 521 | case GIMPLE_EH_ELSE: |
e3a19533 | 522 | replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (stmt), tf); |
523 | replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (stmt), tf); | |
4c0315d0 | 524 | break; |
4ee9c684 | 525 | |
4ee9c684 | 526 | default: |
527 | /* These won't have gotos in them. */ | |
528 | break; | |
529 | } | |
530 | ||
75a70cf9 | 531 | gsi_next (gsi); |
4ee9c684 | 532 | } |
533 | ||
75a70cf9 | 534 | /* A subroutine of replace_goto_queue. Handles GIMPLE_SEQ. */ |
4ee9c684 | 535 | |
536 | static void | |
e3a19533 | 537 | replace_goto_queue_stmt_list (gimple_seq *seq, struct leh_tf_state *tf) |
4ee9c684 | 538 | { |
e3a19533 | 539 | gimple_stmt_iterator gsi = gsi_start (*seq); |
75a70cf9 | 540 | |
541 | while (!gsi_end_p (gsi)) | |
542 | replace_goto_queue_1 (gsi_stmt (gsi), tf, &gsi); | |
4ee9c684 | 543 | } |
544 | ||
545 | /* Replace all goto queue members. */ | |
546 | ||
547 | static void | |
548 | replace_goto_queue (struct leh_tf_state *tf) | |
549 | { | |
82a8c0dd | 550 | if (tf->goto_queue_active == 0) |
551 | return; | |
e3a19533 | 552 | replace_goto_queue_stmt_list (&tf->top_p_seq, tf); |
553 | replace_goto_queue_stmt_list (&eh_seq, tf); | |
4ee9c684 | 554 | } |
555 | ||
75a70cf9 | 556 | /* Add a new record to the goto queue contained in TF. NEW_STMT is the |
557 | data to be added, IS_LABEL indicates whether NEW_STMT is a label or | |
558 | a gimple return. */ | |
4ee9c684 | 559 | |
560 | static void | |
75a70cf9 | 561 | record_in_goto_queue (struct leh_tf_state *tf, |
562 | treemple new_stmt, | |
563 | int index, | |
d7ebacec | 564 | bool is_label, |
565 | location_t location) | |
4ee9c684 | 566 | { |
4ee9c684 | 567 | size_t active, size; |
75a70cf9 | 568 | struct goto_queue_node *q; |
4ee9c684 | 569 | |
46699809 | 570 | gcc_assert (!tf->goto_queue_map); |
571 | ||
4ee9c684 | 572 | active = tf->goto_queue_active; |
573 | size = tf->goto_queue_size; | |
574 | if (active >= size) | |
575 | { | |
576 | size = (size ? size * 2 : 32); | |
577 | tf->goto_queue_size = size; | |
578 | tf->goto_queue | |
680a19b9 | 579 | = XRESIZEVEC (struct goto_queue_node, tf->goto_queue, size); |
4ee9c684 | 580 | } |
581 | ||
582 | q = &tf->goto_queue[active]; | |
583 | tf->goto_queue_active = active + 1; | |
ac13e8d9 | 584 | |
4ee9c684 | 585 | memset (q, 0, sizeof (*q)); |
75a70cf9 | 586 | q->stmt = new_stmt; |
4ee9c684 | 587 | q->index = index; |
d7ebacec | 588 | q->location = location; |
75a70cf9 | 589 | q->is_label = is_label; |
590 | } | |
591 | ||
592 | /* Record the LABEL label in the goto queue contained in TF. | |
593 | TF is not null. */ | |
594 | ||
595 | static void | |
d7ebacec | 596 | record_in_goto_queue_label (struct leh_tf_state *tf, treemple stmt, tree label, |
597 | location_t location) | |
75a70cf9 | 598 | { |
599 | int index; | |
600 | treemple temp, new_stmt; | |
601 | ||
602 | if (!label) | |
603 | return; | |
604 | ||
605 | /* Computed and non-local gotos do not get processed. Given | |
606 | their nature we can neither tell whether we've escaped the | |
607 | finally block nor redirect them if we knew. */ | |
608 | if (TREE_CODE (label) != LABEL_DECL) | |
609 | return; | |
610 | ||
611 | /* No need to record gotos that don't leave the try block. */ | |
612 | temp.t = label; | |
613 | if (!outside_finally_tree (temp, tf->try_finally_expr)) | |
614 | return; | |
615 | ||
616 | if (! tf->dest_array) | |
617 | { | |
618 | tf->dest_array = VEC_alloc (tree, heap, 10); | |
619 | VEC_quick_push (tree, tf->dest_array, label); | |
620 | index = 0; | |
621 | } | |
622 | else | |
623 | { | |
624 | int n = VEC_length (tree, tf->dest_array); | |
625 | for (index = 0; index < n; ++index) | |
626 | if (VEC_index (tree, tf->dest_array, index) == label) | |
627 | break; | |
628 | if (index == n) | |
629 | VEC_safe_push (tree, heap, tf->dest_array, label); | |
630 | } | |
631 | ||
632 | /* In the case of a GOTO we want to record the destination label, | |
633 | since with a GIMPLE_COND we have an easy access to the then/else | |
634 | labels. */ | |
635 | new_stmt = stmt; | |
d7ebacec | 636 | record_in_goto_queue (tf, new_stmt, index, true, location); |
75a70cf9 | 637 | } |
638 | ||
639 | /* For any GIMPLE_GOTO or GIMPLE_RETURN, decide whether it leaves a try_finally | |
640 | node, and if so record that fact in the goto queue associated with that | |
641 | try_finally node. */ | |
642 | ||
643 | static void | |
644 | maybe_record_in_goto_queue (struct leh_state *state, gimple stmt) | |
645 | { | |
646 | struct leh_tf_state *tf = state->tf; | |
647 | treemple new_stmt; | |
648 | ||
649 | if (!tf) | |
650 | return; | |
651 | ||
652 | switch (gimple_code (stmt)) | |
653 | { | |
654 | case GIMPLE_COND: | |
655 | new_stmt.tp = gimple_op_ptr (stmt, 2); | |
d7ebacec | 656 | record_in_goto_queue_label (tf, new_stmt, gimple_cond_true_label (stmt), |
657 | EXPR_LOCATION (*new_stmt.tp)); | |
75a70cf9 | 658 | new_stmt.tp = gimple_op_ptr (stmt, 3); |
d7ebacec | 659 | record_in_goto_queue_label (tf, new_stmt, gimple_cond_false_label (stmt), |
660 | EXPR_LOCATION (*new_stmt.tp)); | |
75a70cf9 | 661 | break; |
662 | case GIMPLE_GOTO: | |
663 | new_stmt.g = stmt; | |
d7ebacec | 664 | record_in_goto_queue_label (tf, new_stmt, gimple_goto_dest (stmt), |
665 | gimple_location (stmt)); | |
75a70cf9 | 666 | break; |
667 | ||
668 | case GIMPLE_RETURN: | |
669 | tf->may_return = true; | |
670 | new_stmt.g = stmt; | |
d7ebacec | 671 | record_in_goto_queue (tf, new_stmt, -1, false, gimple_location (stmt)); |
75a70cf9 | 672 | break; |
673 | ||
674 | default: | |
675 | gcc_unreachable (); | |
676 | } | |
4ee9c684 | 677 | } |
678 | ||
75a70cf9 | 679 | |
4ee9c684 | 680 | #ifdef ENABLE_CHECKING |
75a70cf9 | 681 | /* We do not process GIMPLE_SWITCHes for now. As long as the original source |
4ee9c684 | 682 | was in fact structured, and we've not yet done jump threading, then none |
75a70cf9 | 683 | of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */ |
4ee9c684 | 684 | |
685 | static void | |
75a70cf9 | 686 | verify_norecord_switch_expr (struct leh_state *state, gimple switch_expr) |
4ee9c684 | 687 | { |
688 | struct leh_tf_state *tf = state->tf; | |
689 | size_t i, n; | |
4ee9c684 | 690 | |
691 | if (!tf) | |
692 | return; | |
693 | ||
75a70cf9 | 694 | n = gimple_switch_num_labels (switch_expr); |
4ee9c684 | 695 | |
696 | for (i = 0; i < n; ++i) | |
697 | { | |
75a70cf9 | 698 | treemple temp; |
699 | tree lab = CASE_LABEL (gimple_switch_label (switch_expr, i)); | |
700 | temp.t = lab; | |
701 | gcc_assert (!outside_finally_tree (temp, tf->try_finally_expr)); | |
4ee9c684 | 702 | } |
703 | } | |
704 | #else | |
705 | #define verify_norecord_switch_expr(state, switch_expr) | |
706 | #endif | |
707 | ||
9a14ac4f | 708 | /* Redirect a RETURN_EXPR pointed to by Q to FINLAB. If MOD is |
709 | non-null, insert it before the new branch. */ | |
4ee9c684 | 710 | |
711 | static void | |
9a14ac4f | 712 | do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod) |
4ee9c684 | 713 | { |
75a70cf9 | 714 | gimple x; |
715 | ||
9a14ac4f | 716 | /* In the case of a return, the queue node must be a gimple statement. */ |
75a70cf9 | 717 | gcc_assert (!q->is_label); |
718 | ||
9a14ac4f | 719 | /* Note that the return value may have already been computed, e.g., |
4ee9c684 | 720 | |
9a14ac4f | 721 | int x; |
722 | int foo (void) | |
4ee9c684 | 723 | { |
9a14ac4f | 724 | x = 0; |
725 | try { | |
726 | return x; | |
727 | } finally { | |
728 | x++; | |
729 | } | |
4ee9c684 | 730 | } |
9a14ac4f | 731 | |
732 | should return 0, not 1. We don't have to do anything to make | |
733 | this happens because the return value has been placed in the | |
734 | RESULT_DECL already. */ | |
735 | ||
736 | q->cont_stmt = q->stmt.g; | |
75a70cf9 | 737 | |
4ee9c684 | 738 | if (mod) |
75a70cf9 | 739 | gimple_seq_add_seq (&q->repl_stmt, mod); |
4ee9c684 | 740 | |
75a70cf9 | 741 | x = gimple_build_goto (finlab); |
ed4d69dc | 742 | gimple_set_location (x, q->location); |
75a70cf9 | 743 | gimple_seq_add_stmt (&q->repl_stmt, x); |
4ee9c684 | 744 | } |
745 | ||
75a70cf9 | 746 | /* Similar, but easier, for GIMPLE_GOTO. */ |
4ee9c684 | 747 | |
748 | static void | |
75a70cf9 | 749 | do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod, |
750 | struct leh_tf_state *tf) | |
4ee9c684 | 751 | { |
75a70cf9 | 752 | gimple x; |
753 | ||
754 | gcc_assert (q->is_label); | |
75a70cf9 | 755 | |
e38def9c | 756 | q->cont_stmt = gimple_build_goto (VEC_index (tree, tf->dest_array, q->index)); |
4ee9c684 | 757 | |
4ee9c684 | 758 | if (mod) |
75a70cf9 | 759 | gimple_seq_add_seq (&q->repl_stmt, mod); |
4ee9c684 | 760 | |
75a70cf9 | 761 | x = gimple_build_goto (finlab); |
ed4d69dc | 762 | gimple_set_location (x, q->location); |
75a70cf9 | 763 | gimple_seq_add_stmt (&q->repl_stmt, x); |
4ee9c684 | 764 | } |
765 | ||
e38def9c | 766 | /* Emit a standard landing pad sequence into SEQ for REGION. */ |
767 | ||
768 | static void | |
769 | emit_post_landing_pad (gimple_seq *seq, eh_region region) | |
770 | { | |
771 | eh_landing_pad lp = region->landing_pads; | |
772 | gimple x; | |
773 | ||
774 | if (lp == NULL) | |
775 | lp = gen_eh_landing_pad (region); | |
776 | ||
777 | lp->post_landing_pad = create_artificial_label (UNKNOWN_LOCATION); | |
778 | EH_LANDING_PAD_NR (lp->post_landing_pad) = lp->index; | |
779 | ||
780 | x = gimple_build_label (lp->post_landing_pad); | |
781 | gimple_seq_add_stmt (seq, x); | |
782 | } | |
783 | ||
784 | /* Emit a RESX statement into SEQ for REGION. */ | |
785 | ||
786 | static void | |
787 | emit_resx (gimple_seq *seq, eh_region region) | |
788 | { | |
789 | gimple x = gimple_build_resx (region->index); | |
790 | gimple_seq_add_stmt (seq, x); | |
791 | if (region->outer) | |
792 | record_stmt_eh_region (region->outer, x); | |
793 | } | |
794 | ||
795 | /* Emit an EH_DISPATCH statement into SEQ for REGION. */ | |
796 | ||
797 | static void | |
798 | emit_eh_dispatch (gimple_seq *seq, eh_region region) | |
799 | { | |
800 | gimple x = gimple_build_eh_dispatch (region->index); | |
801 | gimple_seq_add_stmt (seq, x); | |
802 | } | |
803 | ||
804 | /* Note that the current EH region may contain a throw, or a | |
805 | call to a function which itself may contain a throw. */ | |
806 | ||
807 | static void | |
808 | note_eh_region_may_contain_throw (eh_region region) | |
809 | { | |
6ef9bbe0 | 810 | while (bitmap_set_bit (eh_region_may_contain_throw_map, region->index)) |
e38def9c | 811 | { |
39efead8 | 812 | if (region->type == ERT_MUST_NOT_THROW) |
813 | break; | |
e38def9c | 814 | region = region->outer; |
815 | if (region == NULL) | |
816 | break; | |
817 | } | |
818 | } | |
819 | ||
55d6d4e4 | 820 | /* Check if REGION has been marked as containing a throw. If REGION is |
821 | NULL, this predicate is false. */ | |
822 | ||
823 | static inline bool | |
824 | eh_region_may_contain_throw (eh_region r) | |
825 | { | |
826 | return r && bitmap_bit_p (eh_region_may_contain_throw_map, r->index); | |
827 | } | |
828 | ||
4ee9c684 | 829 | /* We want to transform |
830 | try { body; } catch { stuff; } | |
831 | to | |
e38def9c | 832 | normal_seqence: |
833 | body; | |
834 | over: | |
835 | eh_seqence: | |
836 | landing_pad: | |
837 | stuff; | |
838 | goto over; | |
839 | ||
840 | TP is a GIMPLE_TRY node. REGION is the region whose post_landing_pad | |
4ee9c684 | 841 | should be placed before the second operand, or NULL. OVER is |
842 | an existing label that should be put at the exit, or NULL. */ | |
843 | ||
75a70cf9 | 844 | static gimple_seq |
e38def9c | 845 | frob_into_branch_around (gimple tp, eh_region region, tree over) |
4ee9c684 | 846 | { |
75a70cf9 | 847 | gimple x; |
848 | gimple_seq cleanup, result; | |
e60a6f7b | 849 | location_t loc = gimple_location (tp); |
4ee9c684 | 850 | |
75a70cf9 | 851 | cleanup = gimple_try_cleanup (tp); |
852 | result = gimple_try_eval (tp); | |
4ee9c684 | 853 | |
e38def9c | 854 | if (region) |
855 | emit_post_landing_pad (&eh_seq, region); | |
856 | ||
857 | if (gimple_seq_may_fallthru (cleanup)) | |
4ee9c684 | 858 | { |
859 | if (!over) | |
e60a6f7b | 860 | over = create_artificial_label (loc); |
75a70cf9 | 861 | x = gimple_build_goto (over); |
ed4d69dc | 862 | gimple_set_location (x, loc); |
e38def9c | 863 | gimple_seq_add_stmt (&cleanup, x); |
4ee9c684 | 864 | } |
e38def9c | 865 | gimple_seq_add_seq (&eh_seq, cleanup); |
4ee9c684 | 866 | |
867 | if (over) | |
868 | { | |
75a70cf9 | 869 | x = gimple_build_label (over); |
870 | gimple_seq_add_stmt (&result, x); | |
4ee9c684 | 871 | } |
75a70cf9 | 872 | return result; |
4ee9c684 | 873 | } |
874 | ||
875 | /* A subroutine of lower_try_finally. Duplicate the tree rooted at T. | |
876 | Make sure to record all new labels found. */ | |
877 | ||
75a70cf9 | 878 | static gimple_seq |
d7ebacec | 879 | lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state, |
880 | location_t loc) | |
4ee9c684 | 881 | { |
75a70cf9 | 882 | gimple region = NULL; |
883 | gimple_seq new_seq; | |
d7ebacec | 884 | gimple_stmt_iterator gsi; |
4ee9c684 | 885 | |
75a70cf9 | 886 | new_seq = copy_gimple_seq_and_replace_locals (seq); |
4ee9c684 | 887 | |
d7ebacec | 888 | for (gsi = gsi_start (new_seq); !gsi_end_p (gsi); gsi_next (&gsi)) |
cc9f317f | 889 | { |
890 | gimple stmt = gsi_stmt (gsi); | |
8e7408e3 | 891 | if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION) |
cc9f317f | 892 | { |
893 | tree block = gimple_block (stmt); | |
894 | gimple_set_location (stmt, loc); | |
895 | gimple_set_block (stmt, block); | |
896 | } | |
897 | } | |
d7ebacec | 898 | |
4ee9c684 | 899 | if (outer_state->tf) |
900 | region = outer_state->tf->try_finally_expr; | |
75a70cf9 | 901 | collect_finally_tree_1 (new_seq, region); |
4ee9c684 | 902 | |
75a70cf9 | 903 | return new_seq; |
4ee9c684 | 904 | } |
905 | ||
906 | /* A subroutine of lower_try_finally. Create a fallthru label for | |
907 | the given try_finally state. The only tricky bit here is that | |
908 | we have to make sure to record the label in our outer context. */ | |
909 | ||
910 | static tree | |
911 | lower_try_finally_fallthru_label (struct leh_tf_state *tf) | |
912 | { | |
913 | tree label = tf->fallthru_label; | |
75a70cf9 | 914 | treemple temp; |
915 | ||
4ee9c684 | 916 | if (!label) |
917 | { | |
e60a6f7b | 918 | label = create_artificial_label (gimple_location (tf->try_finally_expr)); |
4ee9c684 | 919 | tf->fallthru_label = label; |
920 | if (tf->outer->tf) | |
75a70cf9 | 921 | { |
922 | temp.t = label; | |
923 | record_in_finally_tree (temp, tf->outer->tf->try_finally_expr); | |
924 | } | |
4ee9c684 | 925 | } |
926 | return label; | |
927 | } | |
928 | ||
4c0315d0 | 929 | /* A subroutine of lower_try_finally. If FINALLY consits of a |
930 | GIMPLE_EH_ELSE node, return it. */ | |
931 | ||
932 | static inline gimple | |
933 | get_eh_else (gimple_seq finally) | |
934 | { | |
935 | gimple x = gimple_seq_first_stmt (finally); | |
936 | if (gimple_code (x) == GIMPLE_EH_ELSE) | |
937 | { | |
938 | gcc_assert (gimple_seq_singleton_p (finally)); | |
939 | return x; | |
940 | } | |
941 | return NULL; | |
942 | } | |
943 | ||
596981c8 | 944 | /* A subroutine of lower_try_finally. If the eh_protect_cleanup_actions |
945 | langhook returns non-null, then the language requires that the exception | |
946 | path out of a try_finally be treated specially. To wit: the code within | |
947 | the finally block may not itself throw an exception. We have two choices | |
948 | here. First we can duplicate the finally block and wrap it in a | |
949 | must_not_throw region. Second, we can generate code like | |
4ee9c684 | 950 | |
951 | try { | |
952 | finally_block; | |
953 | } catch { | |
954 | if (fintmp == eh_edge) | |
955 | protect_cleanup_actions; | |
956 | } | |
957 | ||
958 | where "fintmp" is the temporary used in the switch statement generation | |
959 | alternative considered below. For the nonce, we always choose the first | |
ac13e8d9 | 960 | option. |
4ee9c684 | 961 | |
822e391f | 962 | THIS_STATE may be null if this is a try-cleanup, not a try-finally. */ |
4ee9c684 | 963 | |
964 | static void | |
965 | honor_protect_cleanup_actions (struct leh_state *outer_state, | |
966 | struct leh_state *this_state, | |
967 | struct leh_tf_state *tf) | |
968 | { | |
e38def9c | 969 | tree protect_cleanup_actions; |
75a70cf9 | 970 | gimple_stmt_iterator gsi; |
4ee9c684 | 971 | bool finally_may_fallthru; |
75a70cf9 | 972 | gimple_seq finally; |
4c0315d0 | 973 | gimple x, eh_else; |
4ee9c684 | 974 | |
975 | /* First check for nothing to do. */ | |
596981c8 | 976 | if (lang_hooks.eh_protect_cleanup_actions == NULL) |
e38def9c | 977 | return; |
596981c8 | 978 | protect_cleanup_actions = lang_hooks.eh_protect_cleanup_actions (); |
e38def9c | 979 | if (protect_cleanup_actions == NULL) |
980 | return; | |
4ee9c684 | 981 | |
75a70cf9 | 982 | finally = gimple_try_cleanup (tf->top_p); |
4c0315d0 | 983 | eh_else = get_eh_else (finally); |
4ee9c684 | 984 | |
985 | /* Duplicate the FINALLY block. Only need to do this for try-finally, | |
4c0315d0 | 986 | and not for cleanups. If we've got an EH_ELSE, extract it now. */ |
987 | if (eh_else) | |
988 | { | |
989 | finally = gimple_eh_else_e_body (eh_else); | |
990 | gimple_try_set_cleanup (tf->top_p, gimple_eh_else_n_body (eh_else)); | |
991 | } | |
992 | else if (this_state) | |
d7ebacec | 993 | finally = lower_try_finally_dup_block (finally, outer_state, |
5169661d | 994 | gimple_location (tf->try_finally_expr)); |
4c0315d0 | 995 | finally_may_fallthru = gimple_seq_may_fallthru (finally); |
4ee9c684 | 996 | |
0bc060a4 | 997 | /* If this cleanup consists of a TRY_CATCH_EXPR with TRY_CATCH_IS_CLEANUP |
998 | set, the handler of the TRY_CATCH_EXPR is another cleanup which ought | |
999 | to be in an enclosing scope, but needs to be implemented at this level | |
1000 | to avoid a nesting violation (see wrap_temporary_cleanups in | |
1001 | cp/decl.c). Since it's logically at an outer level, we should call | |
1002 | terminate before we get to it, so strip it away before adding the | |
1003 | MUST_NOT_THROW filter. */ | |
75a70cf9 | 1004 | gsi = gsi_start (finally); |
1005 | x = gsi_stmt (gsi); | |
e38def9c | 1006 | if (gimple_code (x) == GIMPLE_TRY |
75a70cf9 | 1007 | && gimple_try_kind (x) == GIMPLE_TRY_CATCH |
1008 | && gimple_try_catch_is_cleanup (x)) | |
0bc060a4 | 1009 | { |
75a70cf9 | 1010 | gsi_insert_seq_before (&gsi, gimple_try_eval (x), GSI_SAME_STMT); |
1011 | gsi_remove (&gsi, false); | |
0bc060a4 | 1012 | } |
1013 | ||
4ee9c684 | 1014 | /* Wrap the block with protect_cleanup_actions as the action. */ |
e38def9c | 1015 | x = gimple_build_eh_must_not_throw (protect_cleanup_actions); |
1016 | x = gimple_build_try (finally, gimple_seq_alloc_with_stmt (x), | |
1017 | GIMPLE_TRY_CATCH); | |
1018 | finally = lower_eh_must_not_throw (outer_state, x); | |
1019 | ||
1020 | /* Drop all of this into the exception sequence. */ | |
1021 | emit_post_landing_pad (&eh_seq, tf->region); | |
1022 | gimple_seq_add_seq (&eh_seq, finally); | |
1023 | if (finally_may_fallthru) | |
1024 | emit_resx (&eh_seq, tf->region); | |
4ee9c684 | 1025 | |
1026 | /* Having now been handled, EH isn't to be considered with | |
1027 | the rest of the outgoing edges. */ | |
1028 | tf->may_throw = false; | |
1029 | } | |
1030 | ||
1031 | /* A subroutine of lower_try_finally. We have determined that there is | |
1032 | no fallthru edge out of the finally block. This means that there is | |
1033 | no outgoing edge corresponding to any incoming edge. Restructure the | |
1034 | try_finally node for this special case. */ | |
1035 | ||
1036 | static void | |
75a70cf9 | 1037 | lower_try_finally_nofallthru (struct leh_state *state, |
1038 | struct leh_tf_state *tf) | |
4ee9c684 | 1039 | { |
9a14ac4f | 1040 | tree lab; |
4c0315d0 | 1041 | gimple x, eh_else; |
75a70cf9 | 1042 | gimple_seq finally; |
4ee9c684 | 1043 | struct goto_queue_node *q, *qe; |
1044 | ||
e38def9c | 1045 | lab = create_artificial_label (gimple_location (tf->try_finally_expr)); |
4ee9c684 | 1046 | |
75a70cf9 | 1047 | /* We expect that tf->top_p is a GIMPLE_TRY. */ |
1048 | finally = gimple_try_cleanup (tf->top_p); | |
1049 | tf->top_p_seq = gimple_try_eval (tf->top_p); | |
4ee9c684 | 1050 | |
75a70cf9 | 1051 | x = gimple_build_label (lab); |
1052 | gimple_seq_add_stmt (&tf->top_p_seq, x); | |
4ee9c684 | 1053 | |
4ee9c684 | 1054 | q = tf->goto_queue; |
1055 | qe = q + tf->goto_queue_active; | |
1056 | for (; q < qe; ++q) | |
1057 | if (q->index < 0) | |
9a14ac4f | 1058 | do_return_redirection (q, lab, NULL); |
4ee9c684 | 1059 | else |
75a70cf9 | 1060 | do_goto_redirection (q, lab, NULL, tf); |
4ee9c684 | 1061 | |
1062 | replace_goto_queue (tf); | |
1063 | ||
4c0315d0 | 1064 | /* Emit the finally block into the stream. Lower EH_ELSE at this time. */ |
1065 | eh_else = get_eh_else (finally); | |
1066 | if (eh_else) | |
1067 | { | |
1068 | finally = gimple_eh_else_n_body (eh_else); | |
e3a19533 | 1069 | lower_eh_constructs_1 (state, &finally); |
4c0315d0 | 1070 | gimple_seq_add_seq (&tf->top_p_seq, finally); |
e38def9c | 1071 | |
4c0315d0 | 1072 | if (tf->may_throw) |
1073 | { | |
1074 | finally = gimple_eh_else_e_body (eh_else); | |
e3a19533 | 1075 | lower_eh_constructs_1 (state, &finally); |
4c0315d0 | 1076 | |
1077 | emit_post_landing_pad (&eh_seq, tf->region); | |
1078 | gimple_seq_add_seq (&eh_seq, finally); | |
1079 | } | |
1080 | } | |
1081 | else | |
e38def9c | 1082 | { |
e3a19533 | 1083 | lower_eh_constructs_1 (state, &finally); |
4c0315d0 | 1084 | gimple_seq_add_seq (&tf->top_p_seq, finally); |
e38def9c | 1085 | |
4c0315d0 | 1086 | if (tf->may_throw) |
1087 | { | |
1088 | emit_post_landing_pad (&eh_seq, tf->region); | |
1089 | ||
1090 | x = gimple_build_goto (lab); | |
ed4d69dc | 1091 | gimple_set_location (x, gimple_location (tf->try_finally_expr)); |
4c0315d0 | 1092 | gimple_seq_add_stmt (&eh_seq, x); |
1093 | } | |
e38def9c | 1094 | } |
4ee9c684 | 1095 | } |
1096 | ||
1097 | /* A subroutine of lower_try_finally. We have determined that there is | |
1098 | exactly one destination of the finally block. Restructure the | |
1099 | try_finally node for this special case. */ | |
1100 | ||
1101 | static void | |
1102 | lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf) | |
1103 | { | |
1104 | struct goto_queue_node *q, *qe; | |
75a70cf9 | 1105 | gimple x; |
1106 | gimple_seq finally; | |
ae117ec5 | 1107 | gimple_stmt_iterator gsi; |
75a70cf9 | 1108 | tree finally_label; |
e60a6f7b | 1109 | location_t loc = gimple_location (tf->try_finally_expr); |
4ee9c684 | 1110 | |
75a70cf9 | 1111 | finally = gimple_try_cleanup (tf->top_p); |
1112 | tf->top_p_seq = gimple_try_eval (tf->top_p); | |
4ee9c684 | 1113 | |
4c0315d0 | 1114 | /* Since there's only one destination, and the destination edge can only |
1115 | either be EH or non-EH, that implies that all of our incoming edges | |
1116 | are of the same type. Therefore we can lower EH_ELSE immediately. */ | |
1117 | x = get_eh_else (finally); | |
1118 | if (x) | |
1119 | { | |
1120 | if (tf->may_throw) | |
1121 | finally = gimple_eh_else_e_body (x); | |
1122 | else | |
1123 | finally = gimple_eh_else_n_body (x); | |
1124 | } | |
1125 | ||
e3a19533 | 1126 | lower_eh_constructs_1 (state, &finally); |
4ee9c684 | 1127 | |
ae117ec5 | 1128 | for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi)) |
1129 | { | |
1130 | gimple stmt = gsi_stmt (gsi); | |
1131 | if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION) | |
1132 | { | |
1133 | tree block = gimple_block (stmt); | |
1134 | gimple_set_location (stmt, gimple_location (tf->try_finally_expr)); | |
1135 | gimple_set_block (stmt, block); | |
1136 | } | |
1137 | } | |
1138 | ||
4ee9c684 | 1139 | if (tf->may_throw) |
1140 | { | |
1141 | /* Only reachable via the exception edge. Add the given label to | |
1142 | the head of the FINALLY block. Append a RESX at the end. */ | |
e38def9c | 1143 | emit_post_landing_pad (&eh_seq, tf->region); |
1144 | gimple_seq_add_seq (&eh_seq, finally); | |
1145 | emit_resx (&eh_seq, tf->region); | |
4ee9c684 | 1146 | return; |
1147 | } | |
1148 | ||
1149 | if (tf->may_fallthru) | |
1150 | { | |
1151 | /* Only reachable via the fallthru edge. Do nothing but let | |
1152 | the two blocks run together; we'll fall out the bottom. */ | |
75a70cf9 | 1153 | gimple_seq_add_seq (&tf->top_p_seq, finally); |
4ee9c684 | 1154 | return; |
1155 | } | |
1156 | ||
e60a6f7b | 1157 | finally_label = create_artificial_label (loc); |
75a70cf9 | 1158 | x = gimple_build_label (finally_label); |
1159 | gimple_seq_add_stmt (&tf->top_p_seq, x); | |
4ee9c684 | 1160 | |
75a70cf9 | 1161 | gimple_seq_add_seq (&tf->top_p_seq, finally); |
4ee9c684 | 1162 | |
1163 | q = tf->goto_queue; | |
1164 | qe = q + tf->goto_queue_active; | |
1165 | ||
1166 | if (tf->may_return) | |
1167 | { | |
1168 | /* Reachable by return expressions only. Redirect them. */ | |
4ee9c684 | 1169 | for (; q < qe; ++q) |
9a14ac4f | 1170 | do_return_redirection (q, finally_label, NULL); |
4ee9c684 | 1171 | replace_goto_queue (tf); |
1172 | } | |
1173 | else | |
1174 | { | |
1175 | /* Reachable by goto expressions only. Redirect them. */ | |
1176 | for (; q < qe; ++q) | |
75a70cf9 | 1177 | do_goto_redirection (q, finally_label, NULL, tf); |
4ee9c684 | 1178 | replace_goto_queue (tf); |
ac13e8d9 | 1179 | |
8cb529a5 | 1180 | if (VEC_index (tree, tf->dest_array, 0) == tf->fallthru_label) |
4ee9c684 | 1181 | { |
1182 | /* Reachable by goto to fallthru label only. Redirect it | |
1183 | to the new label (already created, sadly), and do not | |
1184 | emit the final branch out, or the fallthru label. */ | |
1185 | tf->fallthru_label = NULL; | |
1186 | return; | |
1187 | } | |
1188 | } | |
1189 | ||
75a70cf9 | 1190 | /* Place the original return/goto to the original destination |
1191 | immediately after the finally block. */ | |
1192 | x = tf->goto_queue[0].cont_stmt; | |
1193 | gimple_seq_add_stmt (&tf->top_p_seq, x); | |
1194 | maybe_record_in_goto_queue (state, x); | |
4ee9c684 | 1195 | } |
1196 | ||
1197 | /* A subroutine of lower_try_finally. There are multiple edges incoming | |
1198 | and outgoing from the finally block. Implement this by duplicating the | |
1199 | finally block for every destination. */ | |
1200 | ||
1201 | static void | |
1202 | lower_try_finally_copy (struct leh_state *state, struct leh_tf_state *tf) | |
1203 | { | |
75a70cf9 | 1204 | gimple_seq finally; |
1205 | gimple_seq new_stmt; | |
1206 | gimple_seq seq; | |
4c0315d0 | 1207 | gimple x, eh_else; |
75a70cf9 | 1208 | tree tmp; |
e60a6f7b | 1209 | location_t tf_loc = gimple_location (tf->try_finally_expr); |
4ee9c684 | 1210 | |
75a70cf9 | 1211 | finally = gimple_try_cleanup (tf->top_p); |
4c0315d0 | 1212 | |
1213 | /* Notice EH_ELSE, and simplify some of the remaining code | |
1214 | by considering FINALLY to be the normal return path only. */ | |
1215 | eh_else = get_eh_else (finally); | |
1216 | if (eh_else) | |
1217 | finally = gimple_eh_else_n_body (eh_else); | |
1218 | ||
75a70cf9 | 1219 | tf->top_p_seq = gimple_try_eval (tf->top_p); |
1220 | new_stmt = NULL; | |
4ee9c684 | 1221 | |
1222 | if (tf->may_fallthru) | |
1223 | { | |
d7ebacec | 1224 | seq = lower_try_finally_dup_block (finally, state, tf_loc); |
e3a19533 | 1225 | lower_eh_constructs_1 (state, &seq); |
75a70cf9 | 1226 | gimple_seq_add_seq (&new_stmt, seq); |
4ee9c684 | 1227 | |
75a70cf9 | 1228 | tmp = lower_try_finally_fallthru_label (tf); |
1229 | x = gimple_build_goto (tmp); | |
ed4d69dc | 1230 | gimple_set_location (x, tf_loc); |
75a70cf9 | 1231 | gimple_seq_add_stmt (&new_stmt, x); |
4ee9c684 | 1232 | } |
1233 | ||
1234 | if (tf->may_throw) | |
1235 | { | |
4c0315d0 | 1236 | /* We don't need to copy the EH path of EH_ELSE, |
1237 | since it is only emitted once. */ | |
1238 | if (eh_else) | |
1239 | seq = gimple_eh_else_e_body (eh_else); | |
1240 | else | |
d7ebacec | 1241 | seq = lower_try_finally_dup_block (finally, state, tf_loc); |
e3a19533 | 1242 | lower_eh_constructs_1 (state, &seq); |
4ee9c684 | 1243 | |
2fabdfdf | 1244 | emit_post_landing_pad (&eh_seq, tf->region); |
1245 | gimple_seq_add_seq (&eh_seq, seq); | |
e38def9c | 1246 | emit_resx (&eh_seq, tf->region); |
4ee9c684 | 1247 | } |
1248 | ||
1249 | if (tf->goto_queue) | |
1250 | { | |
1251 | struct goto_queue_node *q, *qe; | |
22347b24 | 1252 | int return_index, index; |
680a19b9 | 1253 | struct labels_s |
22347b24 | 1254 | { |
1255 | struct goto_queue_node *q; | |
1256 | tree label; | |
1257 | } *labels; | |
4ee9c684 | 1258 | |
8cb529a5 | 1259 | return_index = VEC_length (tree, tf->dest_array); |
680a19b9 | 1260 | labels = XCNEWVEC (struct labels_s, return_index + 1); |
4ee9c684 | 1261 | |
1262 | q = tf->goto_queue; | |
1263 | qe = q + tf->goto_queue_active; | |
1264 | for (; q < qe; q++) | |
1265 | { | |
22347b24 | 1266 | index = q->index < 0 ? return_index : q->index; |
1267 | ||
1268 | if (!labels[index].q) | |
1269 | labels[index].q = q; | |
1270 | } | |
1271 | ||
1272 | for (index = 0; index < return_index + 1; index++) | |
1273 | { | |
1274 | tree lab; | |
1275 | ||
1276 | q = labels[index].q; | |
1277 | if (! q) | |
1278 | continue; | |
1279 | ||
e60a6f7b | 1280 | lab = labels[index].label |
1281 | = create_artificial_label (tf_loc); | |
4ee9c684 | 1282 | |
1283 | if (index == return_index) | |
9a14ac4f | 1284 | do_return_redirection (q, lab, NULL); |
4ee9c684 | 1285 | else |
75a70cf9 | 1286 | do_goto_redirection (q, lab, NULL, tf); |
4ee9c684 | 1287 | |
75a70cf9 | 1288 | x = gimple_build_label (lab); |
1289 | gimple_seq_add_stmt (&new_stmt, x); | |
4ee9c684 | 1290 | |
d7ebacec | 1291 | seq = lower_try_finally_dup_block (finally, state, q->location); |
e3a19533 | 1292 | lower_eh_constructs_1 (state, &seq); |
75a70cf9 | 1293 | gimple_seq_add_seq (&new_stmt, seq); |
4ee9c684 | 1294 | |
75a70cf9 | 1295 | gimple_seq_add_stmt (&new_stmt, q->cont_stmt); |
22347b24 | 1296 | maybe_record_in_goto_queue (state, q->cont_stmt); |
4ee9c684 | 1297 | } |
22347b24 | 1298 | |
1299 | for (q = tf->goto_queue; q < qe; q++) | |
1300 | { | |
1301 | tree lab; | |
1302 | ||
1303 | index = q->index < 0 ? return_index : q->index; | |
1304 | ||
1305 | if (labels[index].q == q) | |
1306 | continue; | |
1307 | ||
1308 | lab = labels[index].label; | |
1309 | ||
1310 | if (index == return_index) | |
9a14ac4f | 1311 | do_return_redirection (q, lab, NULL); |
22347b24 | 1312 | else |
75a70cf9 | 1313 | do_goto_redirection (q, lab, NULL, tf); |
22347b24 | 1314 | } |
e38def9c | 1315 | |
4ee9c684 | 1316 | replace_goto_queue (tf); |
1317 | free (labels); | |
1318 | } | |
1319 | ||
1320 | /* Need to link new stmts after running replace_goto_queue due | |
1321 | to not wanting to process the same goto stmts twice. */ | |
75a70cf9 | 1322 | gimple_seq_add_seq (&tf->top_p_seq, new_stmt); |
4ee9c684 | 1323 | } |
1324 | ||
1325 | /* A subroutine of lower_try_finally. There are multiple edges incoming | |
1326 | and outgoing from the finally block. Implement this by instrumenting | |
1327 | each incoming edge and creating a switch statement at the end of the | |
1328 | finally block that branches to the appropriate destination. */ | |
1329 | ||
1330 | static void | |
1331 | lower_try_finally_switch (struct leh_state *state, struct leh_tf_state *tf) | |
1332 | { | |
1333 | struct goto_queue_node *q, *qe; | |
75a70cf9 | 1334 | tree finally_tmp, finally_label; |
4ee9c684 | 1335 | int return_index, eh_index, fallthru_index; |
1336 | int nlabels, ndests, j, last_case_index; | |
75a70cf9 | 1337 | tree last_case; |
1338 | VEC (tree,heap) *case_label_vec; | |
e3a19533 | 1339 | gimple_seq switch_body = NULL; |
4c0315d0 | 1340 | gimple x, eh_else; |
75a70cf9 | 1341 | tree tmp; |
1342 | gimple switch_stmt; | |
1343 | gimple_seq finally; | |
1344 | struct pointer_map_t *cont_map = NULL; | |
e60a6f7b | 1345 | /* The location of the TRY_FINALLY stmt. */ |
0b35068b | 1346 | location_t tf_loc = gimple_location (tf->try_finally_expr); |
e60a6f7b | 1347 | /* The location of the finally block. */ |
1348 | location_t finally_loc; | |
75a70cf9 | 1349 | |
4c0315d0 | 1350 | finally = gimple_try_cleanup (tf->top_p); |
1351 | eh_else = get_eh_else (finally); | |
4ee9c684 | 1352 | |
1353 | /* Mash the TRY block to the head of the chain. */ | |
75a70cf9 | 1354 | tf->top_p_seq = gimple_try_eval (tf->top_p); |
4ee9c684 | 1355 | |
e60a6f7b | 1356 | /* The location of the finally is either the last stmt in the finally |
1357 | block or the location of the TRY_FINALLY itself. */ | |
a6217c59 | 1358 | x = gimple_seq_last_stmt (finally); |
1359 | finally_loc = x ? gimple_location (x) : tf_loc; | |
e60a6f7b | 1360 | |
4ee9c684 | 1361 | /* Lower the finally block itself. */ |
e3a19533 | 1362 | lower_eh_constructs_1 (state, &finally); |
4ee9c684 | 1363 | |
1364 | /* Prepare for switch statement generation. */ | |
8cb529a5 | 1365 | nlabels = VEC_length (tree, tf->dest_array); |
4ee9c684 | 1366 | return_index = nlabels; |
1367 | eh_index = return_index + tf->may_return; | |
4c0315d0 | 1368 | fallthru_index = eh_index + (tf->may_throw && !eh_else); |
4ee9c684 | 1369 | ndests = fallthru_index + tf->may_fallthru; |
1370 | ||
1371 | finally_tmp = create_tmp_var (integer_type_node, "finally_tmp"); | |
e60a6f7b | 1372 | finally_label = create_artificial_label (finally_loc); |
4ee9c684 | 1373 | |
75a70cf9 | 1374 | /* We use VEC_quick_push on case_label_vec throughout this function, |
1375 | since we know the size in advance and allocate precisely as muce | |
1376 | space as needed. */ | |
1377 | case_label_vec = VEC_alloc (tree, heap, ndests); | |
4ee9c684 | 1378 | last_case = NULL; |
1379 | last_case_index = 0; | |
1380 | ||
1381 | /* Begin inserting code for getting to the finally block. Things | |
1382 | are done in this order to correspond to the sequence the code is | |
9d75589a | 1383 | laid out. */ |
4ee9c684 | 1384 | |
1385 | if (tf->may_fallthru) | |
1386 | { | |
e38def9c | 1387 | x = gimple_build_assign (finally_tmp, |
bad12c62 | 1388 | build_int_cst (integer_type_node, |
1389 | fallthru_index)); | |
75a70cf9 | 1390 | gimple_seq_add_stmt (&tf->top_p_seq, x); |
4ee9c684 | 1391 | |
b6e3dd65 | 1392 | tmp = build_int_cst (integer_type_node, fallthru_index); |
1393 | last_case = build_case_label (tmp, NULL, | |
1394 | create_artificial_label (tf_loc)); | |
75a70cf9 | 1395 | VEC_quick_push (tree, case_label_vec, last_case); |
4ee9c684 | 1396 | last_case_index++; |
1397 | ||
75a70cf9 | 1398 | x = gimple_build_label (CASE_LABEL (last_case)); |
1399 | gimple_seq_add_stmt (&switch_body, x); | |
4ee9c684 | 1400 | |
75a70cf9 | 1401 | tmp = lower_try_finally_fallthru_label (tf); |
1402 | x = gimple_build_goto (tmp); | |
ed4d69dc | 1403 | gimple_set_location (x, tf_loc); |
75a70cf9 | 1404 | gimple_seq_add_stmt (&switch_body, x); |
4ee9c684 | 1405 | } |
1406 | ||
4c0315d0 | 1407 | /* For EH_ELSE, emit the exception path (plus resx) now, then |
1408 | subsequently we only need consider the normal path. */ | |
1409 | if (eh_else) | |
1410 | { | |
1411 | if (tf->may_throw) | |
1412 | { | |
1413 | finally = gimple_eh_else_e_body (eh_else); | |
e3a19533 | 1414 | lower_eh_constructs_1 (state, &finally); |
4c0315d0 | 1415 | |
1416 | emit_post_landing_pad (&eh_seq, tf->region); | |
1417 | gimple_seq_add_seq (&eh_seq, finally); | |
1418 | emit_resx (&eh_seq, tf->region); | |
1419 | } | |
1420 | ||
1421 | finally = gimple_eh_else_n_body (eh_else); | |
1422 | } | |
1423 | else if (tf->may_throw) | |
4ee9c684 | 1424 | { |
e38def9c | 1425 | emit_post_landing_pad (&eh_seq, tf->region); |
4ee9c684 | 1426 | |
e38def9c | 1427 | x = gimple_build_assign (finally_tmp, |
bad12c62 | 1428 | build_int_cst (integer_type_node, eh_index)); |
e38def9c | 1429 | gimple_seq_add_stmt (&eh_seq, x); |
1430 | ||
1431 | x = gimple_build_goto (finally_label); | |
ed4d69dc | 1432 | gimple_set_location (x, tf_loc); |
e38def9c | 1433 | gimple_seq_add_stmt (&eh_seq, x); |
4ee9c684 | 1434 | |
b6e3dd65 | 1435 | tmp = build_int_cst (integer_type_node, eh_index); |
1436 | last_case = build_case_label (tmp, NULL, | |
1437 | create_artificial_label (tf_loc)); | |
75a70cf9 | 1438 | VEC_quick_push (tree, case_label_vec, last_case); |
4ee9c684 | 1439 | last_case_index++; |
1440 | ||
75a70cf9 | 1441 | x = gimple_build_label (CASE_LABEL (last_case)); |
e38def9c | 1442 | gimple_seq_add_stmt (&eh_seq, x); |
1443 | emit_resx (&eh_seq, tf->region); | |
4ee9c684 | 1444 | } |
1445 | ||
75a70cf9 | 1446 | x = gimple_build_label (finally_label); |
1447 | gimple_seq_add_stmt (&tf->top_p_seq, x); | |
4ee9c684 | 1448 | |
75a70cf9 | 1449 | gimple_seq_add_seq (&tf->top_p_seq, finally); |
4ee9c684 | 1450 | |
1451 | /* Redirect each incoming goto edge. */ | |
1452 | q = tf->goto_queue; | |
1453 | qe = q + tf->goto_queue_active; | |
1454 | j = last_case_index + tf->may_return; | |
75a70cf9 | 1455 | /* Prepare the assignments to finally_tmp that are executed upon the |
1456 | entrance through a particular edge. */ | |
4ee9c684 | 1457 | for (; q < qe; ++q) |
1458 | { | |
e3a19533 | 1459 | gimple_seq mod = NULL; |
75a70cf9 | 1460 | int switch_id; |
1461 | unsigned int case_index; | |
1462 | ||
4ee9c684 | 1463 | if (q->index < 0) |
1464 | { | |
75a70cf9 | 1465 | x = gimple_build_assign (finally_tmp, |
bad12c62 | 1466 | build_int_cst (integer_type_node, |
1467 | return_index)); | |
75a70cf9 | 1468 | gimple_seq_add_stmt (&mod, x); |
9a14ac4f | 1469 | do_return_redirection (q, finally_label, mod); |
4ee9c684 | 1470 | switch_id = return_index; |
1471 | } | |
1472 | else | |
1473 | { | |
75a70cf9 | 1474 | x = gimple_build_assign (finally_tmp, |
bad12c62 | 1475 | build_int_cst (integer_type_node, q->index)); |
75a70cf9 | 1476 | gimple_seq_add_stmt (&mod, x); |
1477 | do_goto_redirection (q, finally_label, mod, tf); | |
4ee9c684 | 1478 | switch_id = q->index; |
1479 | } | |
1480 | ||
1481 | case_index = j + q->index; | |
75a70cf9 | 1482 | if (VEC_length (tree, case_label_vec) <= case_index |
1483 | || !VEC_index (tree, case_label_vec, case_index)) | |
1484 | { | |
1485 | tree case_lab; | |
1486 | void **slot; | |
b6e3dd65 | 1487 | tmp = build_int_cst (integer_type_node, switch_id); |
1488 | case_lab = build_case_label (tmp, NULL, | |
1489 | create_artificial_label (tf_loc)); | |
75a70cf9 | 1490 | /* We store the cont_stmt in the pointer map, so that we can recover |
75a2cdc8 | 1491 | it in the loop below. */ |
75a70cf9 | 1492 | if (!cont_map) |
1493 | cont_map = pointer_map_create (); | |
1494 | slot = pointer_map_insert (cont_map, case_lab); | |
1495 | *slot = q->cont_stmt; | |
1496 | VEC_quick_push (tree, case_label_vec, case_lab); | |
1497 | } | |
22347b24 | 1498 | } |
1499 | for (j = last_case_index; j < last_case_index + nlabels; j++) | |
1500 | { | |
75a70cf9 | 1501 | gimple cont_stmt; |
1502 | void **slot; | |
22347b24 | 1503 | |
75a70cf9 | 1504 | last_case = VEC_index (tree, case_label_vec, j); |
22347b24 | 1505 | |
1506 | gcc_assert (last_case); | |
75a70cf9 | 1507 | gcc_assert (cont_map); |
22347b24 | 1508 | |
75a70cf9 | 1509 | slot = pointer_map_contains (cont_map, last_case); |
75a70cf9 | 1510 | gcc_assert (slot); |
1511 | cont_stmt = *(gimple *) slot; | |
22347b24 | 1512 | |
75a2cdc8 | 1513 | x = gimple_build_label (CASE_LABEL (last_case)); |
75a70cf9 | 1514 | gimple_seq_add_stmt (&switch_body, x); |
1515 | gimple_seq_add_stmt (&switch_body, cont_stmt); | |
22347b24 | 1516 | maybe_record_in_goto_queue (state, cont_stmt); |
4ee9c684 | 1517 | } |
75a70cf9 | 1518 | if (cont_map) |
1519 | pointer_map_destroy (cont_map); | |
1520 | ||
4ee9c684 | 1521 | replace_goto_queue (tf); |
4ee9c684 | 1522 | |
da41aa8e | 1523 | /* Make sure that the last case is the default label, as one is required. |
1524 | Then sort the labels, which is also required in GIMPLE. */ | |
4ee9c684 | 1525 | CASE_LOW (last_case) = NULL; |
da41aa8e | 1526 | sort_case_labels (case_label_vec); |
4ee9c684 | 1527 | |
75a70cf9 | 1528 | /* Build the switch statement, setting last_case to be the default |
1529 | label. */ | |
49a70175 | 1530 | switch_stmt = gimple_build_switch (finally_tmp, last_case, |
1531 | case_label_vec); | |
e60a6f7b | 1532 | gimple_set_location (switch_stmt, finally_loc); |
75a70cf9 | 1533 | |
1534 | /* Need to link SWITCH_STMT after running replace_goto_queue | |
1535 | due to not wanting to process the same goto stmts twice. */ | |
1536 | gimple_seq_add_stmt (&tf->top_p_seq, switch_stmt); | |
1537 | gimple_seq_add_seq (&tf->top_p_seq, switch_body); | |
4ee9c684 | 1538 | } |
1539 | ||
1540 | /* Decide whether or not we are going to duplicate the finally block. | |
1541 | There are several considerations. | |
1542 | ||
1543 | First, if this is Java, then the finally block contains code | |
1544 | written by the user. It has line numbers associated with it, | |
1545 | so duplicating the block means it's difficult to set a breakpoint. | |
1546 | Since controlling code generation via -g is verboten, we simply | |
1547 | never duplicate code without optimization. | |
1548 | ||
1549 | Second, we'd like to prevent egregious code growth. One way to | |
1550 | do this is to estimate the size of the finally block, multiply | |
1551 | that by the number of copies we'd need to make, and compare against | |
1552 | the estimate of the size of the switch machinery we'd have to add. */ | |
1553 | ||
1554 | static bool | |
4c0315d0 | 1555 | decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally) |
4ee9c684 | 1556 | { |
1557 | int f_estimate, sw_estimate; | |
4c0315d0 | 1558 | gimple eh_else; |
1559 | ||
1560 | /* If there's an EH_ELSE involved, the exception path is separate | |
1561 | and really doesn't come into play for this computation. */ | |
1562 | eh_else = get_eh_else (finally); | |
1563 | if (eh_else) | |
1564 | { | |
1565 | ndests -= may_throw; | |
1566 | finally = gimple_eh_else_n_body (eh_else); | |
1567 | } | |
4ee9c684 | 1568 | |
1569 | if (!optimize) | |
83480f35 | 1570 | { |
1571 | gimple_stmt_iterator gsi; | |
1572 | ||
1573 | if (ndests == 1) | |
1574 | return true; | |
1575 | ||
1576 | for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi)) | |
1577 | { | |
1578 | gimple stmt = gsi_stmt (gsi); | |
1579 | if (!is_gimple_debug (stmt) && !gimple_clobber_p (stmt)) | |
1580 | return false; | |
1581 | } | |
1582 | return true; | |
1583 | } | |
4ee9c684 | 1584 | |
1585 | /* Finally estimate N times, plus N gotos. */ | |
75a70cf9 | 1586 | f_estimate = count_insns_seq (finally, &eni_size_weights); |
4ee9c684 | 1587 | f_estimate = (f_estimate + 1) * ndests; |
1588 | ||
1589 | /* Switch statement (cost 10), N variable assignments, N gotos. */ | |
1590 | sw_estimate = 10 + 2 * ndests; | |
1591 | ||
1592 | /* Optimize for size clearly wants our best guess. */ | |
0bfd8d5c | 1593 | if (optimize_function_for_size_p (cfun)) |
4ee9c684 | 1594 | return f_estimate < sw_estimate; |
1595 | ||
1596 | /* ??? These numbers are completely made up so far. */ | |
1597 | if (optimize > 1) | |
72c90b15 | 1598 | return f_estimate < 100 || f_estimate < sw_estimate * 2; |
4ee9c684 | 1599 | else |
72c90b15 | 1600 | return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3; |
4ee9c684 | 1601 | } |
1602 | ||
f340b9ff | 1603 | /* REG is the enclosing region for a possible cleanup region, or the region |
1604 | itself. Returns TRUE if such a region would be unreachable. | |
1605 | ||
1606 | Cleanup regions within a must-not-throw region aren't actually reachable | |
1607 | even if there are throwing stmts within them, because the personality | |
1608 | routine will call terminate before unwinding. */ | |
1609 | ||
1610 | static bool | |
1611 | cleanup_is_dead_in (eh_region reg) | |
1612 | { | |
1613 | while (reg && reg->type == ERT_CLEANUP) | |
1614 | reg = reg->outer; | |
1615 | return (reg && reg->type == ERT_MUST_NOT_THROW); | |
1616 | } | |
75a70cf9 | 1617 | |
1618 | /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_FINALLY nodes | |
4ee9c684 | 1619 | to a sequence of labels and blocks, plus the exception region trees |
ac13e8d9 | 1620 | that record all the magic. This is complicated by the need to |
4ee9c684 | 1621 | arrange for the FINALLY block to be executed on all exits. */ |
1622 | ||
75a70cf9 | 1623 | static gimple_seq |
1624 | lower_try_finally (struct leh_state *state, gimple tp) | |
4ee9c684 | 1625 | { |
1626 | struct leh_tf_state this_tf; | |
1627 | struct leh_state this_state; | |
1628 | int ndests; | |
fa5d8988 | 1629 | gimple_seq old_eh_seq; |
4ee9c684 | 1630 | |
1631 | /* Process the try block. */ | |
1632 | ||
1633 | memset (&this_tf, 0, sizeof (this_tf)); | |
75a70cf9 | 1634 | this_tf.try_finally_expr = tp; |
4ee9c684 | 1635 | this_tf.top_p = tp; |
1636 | this_tf.outer = state; | |
f340b9ff | 1637 | if (using_eh_for_cleanups_p && !cleanup_is_dead_in (state->cur_region)) |
1638 | { | |
1639 | this_tf.region = gen_eh_region_cleanup (state->cur_region); | |
1640 | this_state.cur_region = this_tf.region; | |
1641 | } | |
4ee9c684 | 1642 | else |
f340b9ff | 1643 | { |
1644 | this_tf.region = NULL; | |
1645 | this_state.cur_region = state->cur_region; | |
1646 | } | |
4ee9c684 | 1647 | |
e38def9c | 1648 | this_state.ehp_region = state->ehp_region; |
4ee9c684 | 1649 | this_state.tf = &this_tf; |
1650 | ||
fa5d8988 | 1651 | old_eh_seq = eh_seq; |
1652 | eh_seq = NULL; | |
1653 | ||
e3a19533 | 1654 | lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
4ee9c684 | 1655 | |
1656 | /* Determine if the try block is escaped through the bottom. */ | |
75a70cf9 | 1657 | this_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp)); |
4ee9c684 | 1658 | |
1659 | /* Determine if any exceptions are possible within the try block. */ | |
f340b9ff | 1660 | if (this_tf.region) |
55d6d4e4 | 1661 | this_tf.may_throw = eh_region_may_contain_throw (this_tf.region); |
4ee9c684 | 1662 | if (this_tf.may_throw) |
e38def9c | 1663 | honor_protect_cleanup_actions (state, &this_state, &this_tf); |
4ee9c684 | 1664 | |
4ee9c684 | 1665 | /* Determine how many edges (still) reach the finally block. Or rather, |
1666 | how many destinations are reached by the finally block. Use this to | |
1667 | determine how we process the finally block itself. */ | |
1668 | ||
8cb529a5 | 1669 | ndests = VEC_length (tree, this_tf.dest_array); |
4ee9c684 | 1670 | ndests += this_tf.may_fallthru; |
1671 | ndests += this_tf.may_return; | |
1672 | ndests += this_tf.may_throw; | |
1673 | ||
1674 | /* If the FINALLY block is not reachable, dike it out. */ | |
1675 | if (ndests == 0) | |
75a70cf9 | 1676 | { |
1677 | gimple_seq_add_seq (&this_tf.top_p_seq, gimple_try_eval (tp)); | |
1678 | gimple_try_set_cleanup (tp, NULL); | |
1679 | } | |
4ee9c684 | 1680 | /* If the finally block doesn't fall through, then any destination |
1681 | we might try to impose there isn't reached either. There may be | |
1682 | some minor amount of cleanup and redirection still needed. */ | |
75a70cf9 | 1683 | else if (!gimple_seq_may_fallthru (gimple_try_cleanup (tp))) |
4ee9c684 | 1684 | lower_try_finally_nofallthru (state, &this_tf); |
1685 | ||
1686 | /* We can easily special-case redirection to a single destination. */ | |
1687 | else if (ndests == 1) | |
1688 | lower_try_finally_onedest (state, &this_tf); | |
4c0315d0 | 1689 | else if (decide_copy_try_finally (ndests, this_tf.may_throw, |
1690 | gimple_try_cleanup (tp))) | |
4ee9c684 | 1691 | lower_try_finally_copy (state, &this_tf); |
1692 | else | |
1693 | lower_try_finally_switch (state, &this_tf); | |
1694 | ||
1695 | /* If someone requested we add a label at the end of the transformed | |
1696 | block, do so. */ | |
1697 | if (this_tf.fallthru_label) | |
1698 | { | |
75a70cf9 | 1699 | /* This must be reached only if ndests == 0. */ |
1700 | gimple x = gimple_build_label (this_tf.fallthru_label); | |
1701 | gimple_seq_add_stmt (&this_tf.top_p_seq, x); | |
4ee9c684 | 1702 | } |
1703 | ||
8cb529a5 | 1704 | VEC_free (tree, heap, this_tf.dest_array); |
dd045aee | 1705 | free (this_tf.goto_queue); |
46699809 | 1706 | if (this_tf.goto_queue_map) |
1707 | pointer_map_destroy (this_tf.goto_queue_map); | |
75a70cf9 | 1708 | |
fa5d8988 | 1709 | /* If there was an old (aka outer) eh_seq, append the current eh_seq. |
1710 | If there was no old eh_seq, then the append is trivially already done. */ | |
1711 | if (old_eh_seq) | |
1712 | { | |
1713 | if (eh_seq == NULL) | |
1714 | eh_seq = old_eh_seq; | |
1715 | else | |
1716 | { | |
1717 | gimple_seq new_eh_seq = eh_seq; | |
1718 | eh_seq = old_eh_seq; | |
1719 | gimple_seq_add_seq(&eh_seq, new_eh_seq); | |
1720 | } | |
1721 | } | |
1722 | ||
75a70cf9 | 1723 | return this_tf.top_p_seq; |
4ee9c684 | 1724 | } |
1725 | ||
75a70cf9 | 1726 | /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY_CATCH with a |
1727 | list of GIMPLE_CATCH to a sequence of labels and blocks, plus the | |
1728 | exception region trees that records all the magic. */ | |
4ee9c684 | 1729 | |
75a70cf9 | 1730 | static gimple_seq |
1731 | lower_catch (struct leh_state *state, gimple tp) | |
4ee9c684 | 1732 | { |
55d6d4e4 | 1733 | eh_region try_region = NULL; |
1734 | struct leh_state this_state = *state; | |
75a70cf9 | 1735 | gimple_stmt_iterator gsi; |
4ee9c684 | 1736 | tree out_label; |
e3a19533 | 1737 | gimple_seq new_seq, cleanup; |
e38def9c | 1738 | gimple x; |
e60a6f7b | 1739 | location_t try_catch_loc = gimple_location (tp); |
4ee9c684 | 1740 | |
55d6d4e4 | 1741 | if (flag_exceptions) |
1742 | { | |
1743 | try_region = gen_eh_region_try (state->cur_region); | |
1744 | this_state.cur_region = try_region; | |
1745 | } | |
4ee9c684 | 1746 | |
e3a19533 | 1747 | lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
4ee9c684 | 1748 | |
55d6d4e4 | 1749 | if (!eh_region_may_contain_throw (try_region)) |
e38def9c | 1750 | return gimple_try_eval (tp); |
1751 | ||
1752 | new_seq = NULL; | |
1753 | emit_eh_dispatch (&new_seq, try_region); | |
1754 | emit_resx (&new_seq, try_region); | |
1755 | ||
1756 | this_state.cur_region = state->cur_region; | |
1757 | this_state.ehp_region = try_region; | |
4ee9c684 | 1758 | |
1759 | out_label = NULL; | |
e3a19533 | 1760 | cleanup = gimple_try_cleanup (tp); |
1761 | for (gsi = gsi_start (cleanup); | |
e38def9c | 1762 | !gsi_end_p (gsi); |
1763 | gsi_next (&gsi)) | |
4ee9c684 | 1764 | { |
e38def9c | 1765 | eh_catch c; |
1766 | gimple gcatch; | |
1767 | gimple_seq handler; | |
4ee9c684 | 1768 | |
f4e36c33 | 1769 | gcatch = gsi_stmt (gsi); |
e38def9c | 1770 | c = gen_eh_region_catch (try_region, gimple_catch_types (gcatch)); |
4ee9c684 | 1771 | |
e38def9c | 1772 | handler = gimple_catch_handler (gcatch); |
e3a19533 | 1773 | lower_eh_constructs_1 (&this_state, &handler); |
4ee9c684 | 1774 | |
e38def9c | 1775 | c->label = create_artificial_label (UNKNOWN_LOCATION); |
1776 | x = gimple_build_label (c->label); | |
1777 | gimple_seq_add_stmt (&new_seq, x); | |
4ee9c684 | 1778 | |
e38def9c | 1779 | gimple_seq_add_seq (&new_seq, handler); |
4ee9c684 | 1780 | |
e38def9c | 1781 | if (gimple_seq_may_fallthru (new_seq)) |
4ee9c684 | 1782 | { |
1783 | if (!out_label) | |
e60a6f7b | 1784 | out_label = create_artificial_label (try_catch_loc); |
4ee9c684 | 1785 | |
75a70cf9 | 1786 | x = gimple_build_goto (out_label); |
e38def9c | 1787 | gimple_seq_add_stmt (&new_seq, x); |
4ee9c684 | 1788 | } |
3ded67b5 | 1789 | if (!c->type_list) |
1790 | break; | |
4ee9c684 | 1791 | } |
1792 | ||
e38def9c | 1793 | gimple_try_set_cleanup (tp, new_seq); |
1794 | ||
1795 | return frob_into_branch_around (tp, try_region, out_label); | |
4ee9c684 | 1796 | } |
1797 | ||
75a70cf9 | 1798 | /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with a |
1799 | GIMPLE_EH_FILTER to a sequence of labels and blocks, plus the exception | |
4ee9c684 | 1800 | region trees that record all the magic. */ |
1801 | ||
75a70cf9 | 1802 | static gimple_seq |
1803 | lower_eh_filter (struct leh_state *state, gimple tp) | |
4ee9c684 | 1804 | { |
55d6d4e4 | 1805 | struct leh_state this_state = *state; |
1806 | eh_region this_region = NULL; | |
e38def9c | 1807 | gimple inner, x; |
1808 | gimple_seq new_seq; | |
ac13e8d9 | 1809 | |
75a70cf9 | 1810 | inner = gimple_seq_first_stmt (gimple_try_cleanup (tp)); |
1811 | ||
55d6d4e4 | 1812 | if (flag_exceptions) |
1813 | { | |
1814 | this_region = gen_eh_region_allowed (state->cur_region, | |
1815 | gimple_eh_filter_types (inner)); | |
1816 | this_state.cur_region = this_region; | |
1817 | } | |
ac13e8d9 | 1818 | |
e3a19533 | 1819 | lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
4ee9c684 | 1820 | |
55d6d4e4 | 1821 | if (!eh_region_may_contain_throw (this_region)) |
e38def9c | 1822 | return gimple_try_eval (tp); |
1823 | ||
1824 | new_seq = NULL; | |
1825 | this_state.cur_region = state->cur_region; | |
1826 | this_state.ehp_region = this_region; | |
1827 | ||
1828 | emit_eh_dispatch (&new_seq, this_region); | |
1829 | emit_resx (&new_seq, this_region); | |
1830 | ||
1831 | this_region->u.allowed.label = create_artificial_label (UNKNOWN_LOCATION); | |
1832 | x = gimple_build_label (this_region->u.allowed.label); | |
1833 | gimple_seq_add_stmt (&new_seq, x); | |
1834 | ||
e3a19533 | 1835 | lower_eh_constructs_1 (&this_state, gimple_eh_filter_failure_ptr (inner)); |
e38def9c | 1836 | gimple_seq_add_seq (&new_seq, gimple_eh_filter_failure (inner)); |
1837 | ||
1838 | gimple_try_set_cleanup (tp, new_seq); | |
4ee9c684 | 1839 | |
e38def9c | 1840 | return frob_into_branch_around (tp, this_region, NULL); |
1841 | } | |
1842 | ||
1843 | /* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with | |
1844 | an GIMPLE_EH_MUST_NOT_THROW to a sequence of labels and blocks, | |
1845 | plus the exception region trees that record all the magic. */ | |
1846 | ||
1847 | static gimple_seq | |
1848 | lower_eh_must_not_throw (struct leh_state *state, gimple tp) | |
1849 | { | |
55d6d4e4 | 1850 | struct leh_state this_state = *state; |
e38def9c | 1851 | |
55d6d4e4 | 1852 | if (flag_exceptions) |
1853 | { | |
1854 | gimple inner = gimple_seq_first_stmt (gimple_try_cleanup (tp)); | |
1855 | eh_region this_region; | |
e38def9c | 1856 | |
55d6d4e4 | 1857 | this_region = gen_eh_region_must_not_throw (state->cur_region); |
1858 | this_region->u.must_not_throw.failure_decl | |
1859 | = gimple_eh_must_not_throw_fndecl (inner); | |
1860 | this_region->u.must_not_throw.failure_loc = gimple_location (tp); | |
e38def9c | 1861 | |
55d6d4e4 | 1862 | /* In order to get mangling applied to this decl, we must mark it |
1863 | used now. Otherwise, pass_ipa_free_lang_data won't think it | |
1864 | needs to happen. */ | |
1865 | TREE_USED (this_region->u.must_not_throw.failure_decl) = 1; | |
e38def9c | 1866 | |
55d6d4e4 | 1867 | this_state.cur_region = this_region; |
1868 | } | |
4ee9c684 | 1869 | |
e3a19533 | 1870 | lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
4ee9c684 | 1871 | |
e38def9c | 1872 | return gimple_try_eval (tp); |
4ee9c684 | 1873 | } |
1874 | ||
1875 | /* Implement a cleanup expression. This is similar to try-finally, | |
1876 | except that we only execute the cleanup block for exception edges. */ | |
1877 | ||
75a70cf9 | 1878 | static gimple_seq |
1879 | lower_cleanup (struct leh_state *state, gimple tp) | |
4ee9c684 | 1880 | { |
55d6d4e4 | 1881 | struct leh_state this_state = *state; |
1882 | eh_region this_region = NULL; | |
4ee9c684 | 1883 | struct leh_tf_state fake_tf; |
75a70cf9 | 1884 | gimple_seq result; |
f340b9ff | 1885 | bool cleanup_dead = cleanup_is_dead_in (state->cur_region); |
4ee9c684 | 1886 | |
f340b9ff | 1887 | if (flag_exceptions && !cleanup_dead) |
4ee9c684 | 1888 | { |
55d6d4e4 | 1889 | this_region = gen_eh_region_cleanup (state->cur_region); |
1890 | this_state.cur_region = this_region; | |
4ee9c684 | 1891 | } |
1892 | ||
e3a19533 | 1893 | lower_eh_constructs_1 (&this_state, gimple_try_eval_ptr (tp)); |
4ee9c684 | 1894 | |
f340b9ff | 1895 | if (cleanup_dead || !eh_region_may_contain_throw (this_region)) |
e38def9c | 1896 | return gimple_try_eval (tp); |
4ee9c684 | 1897 | |
1898 | /* Build enough of a try-finally state so that we can reuse | |
1899 | honor_protect_cleanup_actions. */ | |
1900 | memset (&fake_tf, 0, sizeof (fake_tf)); | |
e60a6f7b | 1901 | fake_tf.top_p = fake_tf.try_finally_expr = tp; |
4ee9c684 | 1902 | fake_tf.outer = state; |
1903 | fake_tf.region = this_region; | |
75a70cf9 | 1904 | fake_tf.may_fallthru = gimple_seq_may_fallthru (gimple_try_eval (tp)); |
4ee9c684 | 1905 | fake_tf.may_throw = true; |
1906 | ||
4ee9c684 | 1907 | honor_protect_cleanup_actions (state, NULL, &fake_tf); |
1908 | ||
1909 | if (fake_tf.may_throw) | |
1910 | { | |
1911 | /* In this case honor_protect_cleanup_actions had nothing to do, | |
1912 | and we should process this normally. */ | |
e3a19533 | 1913 | lower_eh_constructs_1 (state, gimple_try_cleanup_ptr (tp)); |
e38def9c | 1914 | result = frob_into_branch_around (tp, this_region, |
1915 | fake_tf.fallthru_label); | |
4ee9c684 | 1916 | } |
1917 | else | |
1918 | { | |
1919 | /* In this case honor_protect_cleanup_actions did nearly all of | |
1920 | the work. All we have left is to append the fallthru_label. */ | |
1921 | ||
75a70cf9 | 1922 | result = gimple_try_eval (tp); |
4ee9c684 | 1923 | if (fake_tf.fallthru_label) |
1924 | { | |
75a70cf9 | 1925 | gimple x = gimple_build_label (fake_tf.fallthru_label); |
1926 | gimple_seq_add_stmt (&result, x); | |
4ee9c684 | 1927 | } |
1928 | } | |
75a70cf9 | 1929 | return result; |
4ee9c684 | 1930 | } |
1931 | ||
e38def9c | 1932 | /* Main loop for lowering eh constructs. Also moves gsi to the next |
75a70cf9 | 1933 | statement. */ |
4ee9c684 | 1934 | |
1935 | static void | |
75a70cf9 | 1936 | lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi) |
4ee9c684 | 1937 | { |
75a70cf9 | 1938 | gimple_seq replace; |
1939 | gimple x; | |
1940 | gimple stmt = gsi_stmt (*gsi); | |
4ee9c684 | 1941 | |
75a70cf9 | 1942 | switch (gimple_code (stmt)) |
4ee9c684 | 1943 | { |
75a70cf9 | 1944 | case GIMPLE_CALL: |
e38def9c | 1945 | { |
1946 | tree fndecl = gimple_call_fndecl (stmt); | |
1947 | tree rhs, lhs; | |
1948 | ||
1949 | if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL) | |
1950 | switch (DECL_FUNCTION_CODE (fndecl)) | |
1951 | { | |
1952 | case BUILT_IN_EH_POINTER: | |
1953 | /* The front end may have generated a call to | |
1954 | __builtin_eh_pointer (0) within a catch region. Replace | |
1955 | this zero argument with the current catch region number. */ | |
1956 | if (state->ehp_region) | |
1957 | { | |
bad12c62 | 1958 | tree nr = build_int_cst (integer_type_node, |
1959 | state->ehp_region->index); | |
e38def9c | 1960 | gimple_call_set_arg (stmt, 0, nr); |
1961 | } | |
1962 | else | |
1963 | { | |
1964 | /* The user has dome something silly. Remove it. */ | |
2512209b | 1965 | rhs = null_pointer_node; |
e38def9c | 1966 | goto do_replace; |
1967 | } | |
1968 | break; | |
1969 | ||
1970 | case BUILT_IN_EH_FILTER: | |
1971 | /* ??? This should never appear, but since it's a builtin it | |
1972 | is accessible to abuse by users. Just remove it and | |
1973 | replace the use with the arbitrary value zero. */ | |
1974 | rhs = build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0); | |
1975 | do_replace: | |
1976 | lhs = gimple_call_lhs (stmt); | |
1977 | x = gimple_build_assign (lhs, rhs); | |
1978 | gsi_insert_before (gsi, x, GSI_SAME_STMT); | |
1979 | /* FALLTHRU */ | |
1980 | ||
1981 | case BUILT_IN_EH_COPY_VALUES: | |
1982 | /* Likewise this should not appear. Remove it. */ | |
1983 | gsi_remove (gsi, true); | |
1984 | return; | |
1985 | ||
1986 | default: | |
1987 | break; | |
1988 | } | |
1989 | } | |
1990 | /* FALLTHRU */ | |
1991 | ||
75a70cf9 | 1992 | case GIMPLE_ASSIGN: |
47f11e84 | 1993 | /* If the stmt can throw use a new temporary for the assignment |
1994 | to a LHS. This makes sure the old value of the LHS is | |
fa916956 | 1995 | available on the EH edge. Only do so for statements that |
9d75589a | 1996 | potentially fall through (no noreturn calls e.g.), otherwise |
fa916956 | 1997 | this new assignment might create fake fallthru regions. */ |
47f11e84 | 1998 | if (stmt_could_throw_p (stmt) |
1999 | && gimple_has_lhs (stmt) | |
fa916956 | 2000 | && gimple_stmt_may_fallthru (stmt) |
47f11e84 | 2001 | && !tree_could_throw_p (gimple_get_lhs (stmt)) |
2002 | && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt)))) | |
2003 | { | |
2004 | tree lhs = gimple_get_lhs (stmt); | |
2005 | tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL); | |
2006 | gimple s = gimple_build_assign (lhs, tmp); | |
2007 | gimple_set_location (s, gimple_location (stmt)); | |
2008 | gimple_set_block (s, gimple_block (stmt)); | |
2009 | gimple_set_lhs (stmt, tmp); | |
2010 | if (TREE_CODE (TREE_TYPE (tmp)) == COMPLEX_TYPE | |
2011 | || TREE_CODE (TREE_TYPE (tmp)) == VECTOR_TYPE) | |
2012 | DECL_GIMPLE_REG_P (tmp) = 1; | |
2013 | gsi_insert_after (gsi, s, GSI_SAME_STMT); | |
2014 | } | |
4ee9c684 | 2015 | /* Look for things that can throw exceptions, and record them. */ |
75a70cf9 | 2016 | if (state->cur_region && stmt_could_throw_p (stmt)) |
4ee9c684 | 2017 | { |
75a70cf9 | 2018 | record_stmt_eh_region (state->cur_region, stmt); |
4ee9c684 | 2019 | note_eh_region_may_contain_throw (state->cur_region); |
4ee9c684 | 2020 | } |
2021 | break; | |
2022 | ||
75a70cf9 | 2023 | case GIMPLE_COND: |
2024 | case GIMPLE_GOTO: | |
2025 | case GIMPLE_RETURN: | |
2026 | maybe_record_in_goto_queue (state, stmt); | |
4ee9c684 | 2027 | break; |
2028 | ||
75a70cf9 | 2029 | case GIMPLE_SWITCH: |
2030 | verify_norecord_switch_expr (state, stmt); | |
4ee9c684 | 2031 | break; |
2032 | ||
75a70cf9 | 2033 | case GIMPLE_TRY: |
2034 | if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY) | |
2035 | replace = lower_try_finally (state, stmt); | |
2036 | else | |
4ee9c684 | 2037 | { |
75a70cf9 | 2038 | x = gimple_seq_first_stmt (gimple_try_cleanup (stmt)); |
c90b5d40 | 2039 | if (!x) |
4ee9c684 | 2040 | { |
c90b5d40 | 2041 | replace = gimple_try_eval (stmt); |
e3a19533 | 2042 | lower_eh_constructs_1 (state, &replace); |
4ee9c684 | 2043 | } |
c90b5d40 | 2044 | else |
2045 | switch (gimple_code (x)) | |
2046 | { | |
2047 | case GIMPLE_CATCH: | |
2048 | replace = lower_catch (state, stmt); | |
2049 | break; | |
2050 | case GIMPLE_EH_FILTER: | |
2051 | replace = lower_eh_filter (state, stmt); | |
2052 | break; | |
2053 | case GIMPLE_EH_MUST_NOT_THROW: | |
2054 | replace = lower_eh_must_not_throw (state, stmt); | |
2055 | break; | |
4c0315d0 | 2056 | case GIMPLE_EH_ELSE: |
2057 | /* This code is only valid with GIMPLE_TRY_FINALLY. */ | |
2058 | gcc_unreachable (); | |
c90b5d40 | 2059 | default: |
2060 | replace = lower_cleanup (state, stmt); | |
2061 | break; | |
2062 | } | |
4ee9c684 | 2063 | } |
75a70cf9 | 2064 | |
2065 | /* Remove the old stmt and insert the transformed sequence | |
2066 | instead. */ | |
2067 | gsi_insert_seq_before (gsi, replace, GSI_SAME_STMT); | |
2068 | gsi_remove (gsi, true); | |
2069 | ||
2070 | /* Return since we don't want gsi_next () */ | |
2071 | return; | |
4ee9c684 | 2072 | |
4c0315d0 | 2073 | case GIMPLE_EH_ELSE: |
2074 | /* We should be eliminating this in lower_try_finally et al. */ | |
2075 | gcc_unreachable (); | |
2076 | ||
4ee9c684 | 2077 | default: |
2078 | /* A type, a decl, or some kind of statement that we're not | |
2079 | interested in. Don't walk them. */ | |
2080 | break; | |
2081 | } | |
75a70cf9 | 2082 | |
2083 | gsi_next (gsi); | |
2084 | } | |
2085 | ||
2086 | /* A helper to unwrap a gimple_seq and feed stmts to lower_eh_constructs_2. */ | |
2087 | ||
2088 | static void | |
e3a19533 | 2089 | lower_eh_constructs_1 (struct leh_state *state, gimple_seq *pseq) |
75a70cf9 | 2090 | { |
2091 | gimple_stmt_iterator gsi; | |
e3a19533 | 2092 | for (gsi = gsi_start (*pseq); !gsi_end_p (gsi);) |
75a70cf9 | 2093 | lower_eh_constructs_2 (state, &gsi); |
4ee9c684 | 2094 | } |
2095 | ||
2a1990e9 | 2096 | static unsigned int |
4ee9c684 | 2097 | lower_eh_constructs (void) |
2098 | { | |
2099 | struct leh_state null_state; | |
e38def9c | 2100 | gimple_seq bodyp; |
75a70cf9 | 2101 | |
e38def9c | 2102 | bodyp = gimple_body (current_function_decl); |
2103 | if (bodyp == NULL) | |
2104 | return 0; | |
4ee9c684 | 2105 | |
2106 | finally_tree = htab_create (31, struct_ptr_hash, struct_ptr_eq, free); | |
55d6d4e4 | 2107 | eh_region_may_contain_throw_map = BITMAP_ALLOC (NULL); |
e38def9c | 2108 | memset (&null_state, 0, sizeof (null_state)); |
4ee9c684 | 2109 | |
75a70cf9 | 2110 | collect_finally_tree_1 (bodyp, NULL); |
e3a19533 | 2111 | lower_eh_constructs_1 (&null_state, &bodyp); |
2112 | gimple_set_body (current_function_decl, bodyp); | |
4ee9c684 | 2113 | |
e38def9c | 2114 | /* We assume there's a return statement, or something, at the end of |
2115 | the function, and thus ploping the EH sequence afterward won't | |
2116 | change anything. */ | |
2117 | gcc_assert (!gimple_seq_may_fallthru (bodyp)); | |
2118 | gimple_seq_add_seq (&bodyp, eh_seq); | |
2119 | ||
2120 | /* We assume that since BODYP already existed, adding EH_SEQ to it | |
2121 | didn't change its value, and we don't have to re-set the function. */ | |
2122 | gcc_assert (bodyp == gimple_body (current_function_decl)); | |
4ee9c684 | 2123 | |
e38def9c | 2124 | htab_delete (finally_tree); |
55d6d4e4 | 2125 | BITMAP_FREE (eh_region_may_contain_throw_map); |
e38def9c | 2126 | eh_seq = NULL; |
58d82cd0 | 2127 | |
2128 | /* If this function needs a language specific EH personality routine | |
2129 | and the frontend didn't already set one do so now. */ | |
2130 | if (function_needs_eh_personality (cfun) == eh_personality_lang | |
2131 | && !DECL_FUNCTION_PERSONALITY (current_function_decl)) | |
2132 | DECL_FUNCTION_PERSONALITY (current_function_decl) | |
2133 | = lang_hooks.eh_personality (); | |
2134 | ||
2a1990e9 | 2135 | return 0; |
4ee9c684 | 2136 | } |
2137 | ||
20099e35 | 2138 | struct gimple_opt_pass pass_lower_eh = |
4ee9c684 | 2139 | { |
20099e35 | 2140 | { |
2141 | GIMPLE_PASS, | |
4ee9c684 | 2142 | "eh", /* name */ |
c7875731 | 2143 | OPTGROUP_NONE, /* optinfo_flags */ |
4ee9c684 | 2144 | NULL, /* gate */ |
2145 | lower_eh_constructs, /* execute */ | |
2146 | NULL, /* sub */ | |
2147 | NULL, /* next */ | |
2148 | 0, /* static_pass_number */ | |
2149 | TV_TREE_EH, /* tv_id */ | |
2150 | PROP_gimple_lcf, /* properties_required */ | |
2151 | PROP_gimple_leh, /* properties_provided */ | |
6354626c | 2152 | 0, /* properties_destroyed */ |
4ee9c684 | 2153 | 0, /* todo_flags_start */ |
771e2890 | 2154 | 0 /* todo_flags_finish */ |
20099e35 | 2155 | } |
4ee9c684 | 2156 | }; |
4ee9c684 | 2157 | \f |
e38def9c | 2158 | /* Create the multiple edges from an EH_DISPATCH statement to all of |
2159 | the possible handlers for its EH region. Return true if there's | |
2160 | no fallthru edge; false if there is. */ | |
4ee9c684 | 2161 | |
e38def9c | 2162 | bool |
2163 | make_eh_dispatch_edges (gimple stmt) | |
4ee9c684 | 2164 | { |
e38def9c | 2165 | eh_region r; |
2166 | eh_catch c; | |
4ee9c684 | 2167 | basic_block src, dst; |
2168 | ||
e38def9c | 2169 | r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); |
75a70cf9 | 2170 | src = gimple_bb (stmt); |
4ee9c684 | 2171 | |
e38def9c | 2172 | switch (r->type) |
2173 | { | |
2174 | case ERT_TRY: | |
2175 | for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) | |
2176 | { | |
2177 | dst = label_to_block (c->label); | |
2178 | make_edge (src, dst, 0); | |
ac13e8d9 | 2179 | |
e38def9c | 2180 | /* A catch-all handler doesn't have a fallthru. */ |
2181 | if (c->type_list == NULL) | |
2182 | return false; | |
2183 | } | |
2184 | break; | |
a5bfef5b | 2185 | |
e38def9c | 2186 | case ERT_ALLOWED_EXCEPTIONS: |
2187 | dst = label_to_block (r->u.allowed.label); | |
2188 | make_edge (src, dst, 0); | |
2189 | break; | |
2190 | ||
2191 | default: | |
2192 | gcc_unreachable (); | |
2193 | } | |
2194 | ||
2195 | return true; | |
a5bfef5b | 2196 | } |
2197 | ||
e38def9c | 2198 | /* Create the single EH edge from STMT to its nearest landing pad, |
2199 | if there is such a landing pad within the current function. */ | |
2200 | ||
4ee9c684 | 2201 | void |
75a70cf9 | 2202 | make_eh_edges (gimple stmt) |
4ee9c684 | 2203 | { |
e38def9c | 2204 | basic_block src, dst; |
2205 | eh_landing_pad lp; | |
2206 | int lp_nr; | |
4ee9c684 | 2207 | |
e38def9c | 2208 | lp_nr = lookup_stmt_eh_lp (stmt); |
2209 | if (lp_nr <= 0) | |
2210 | return; | |
4ee9c684 | 2211 | |
e38def9c | 2212 | lp = get_eh_landing_pad_from_number (lp_nr); |
2213 | gcc_assert (lp != NULL); | |
d6d5ab2d | 2214 | |
e38def9c | 2215 | src = gimple_bb (stmt); |
2216 | dst = label_to_block (lp->post_landing_pad); | |
2217 | make_edge (src, dst, EDGE_EH); | |
4ee9c684 | 2218 | } |
2219 | ||
e38def9c | 2220 | /* Do the work in redirecting EDGE_IN to NEW_BB within the EH region tree; |
2221 | do not actually perform the final edge redirection. | |
927a6b6b | 2222 | |
e38def9c | 2223 | CHANGE_REGION is true when we're being called from cleanup_empty_eh and |
2224 | we intend to change the destination EH region as well; this means | |
2225 | EH_LANDING_PAD_NR must already be set on the destination block label. | |
2226 | If false, we're being called from generic cfg manipulation code and we | |
2227 | should preserve our place within the region tree. */ | |
2228 | ||
2229 | static void | |
2230 | redirect_eh_edge_1 (edge edge_in, basic_block new_bb, bool change_region) | |
927a6b6b | 2231 | { |
e38def9c | 2232 | eh_landing_pad old_lp, new_lp; |
2233 | basic_block old_bb; | |
2234 | gimple throw_stmt; | |
2235 | int old_lp_nr, new_lp_nr; | |
2236 | tree old_label, new_label; | |
2237 | edge_iterator ei; | |
2238 | edge e; | |
2239 | ||
2240 | old_bb = edge_in->dest; | |
2241 | old_label = gimple_block_label (old_bb); | |
2242 | old_lp_nr = EH_LANDING_PAD_NR (old_label); | |
2243 | gcc_assert (old_lp_nr > 0); | |
2244 | old_lp = get_eh_landing_pad_from_number (old_lp_nr); | |
2245 | ||
2246 | throw_stmt = last_stmt (edge_in->src); | |
2247 | gcc_assert (lookup_stmt_eh_lp (throw_stmt) == old_lp_nr); | |
2248 | ||
2249 | new_label = gimple_block_label (new_bb); | |
927a6b6b | 2250 | |
e38def9c | 2251 | /* Look for an existing region that might be using NEW_BB already. */ |
2252 | new_lp_nr = EH_LANDING_PAD_NR (new_label); | |
2253 | if (new_lp_nr) | |
927a6b6b | 2254 | { |
e38def9c | 2255 | new_lp = get_eh_landing_pad_from_number (new_lp_nr); |
2256 | gcc_assert (new_lp); | |
48e1416a | 2257 | |
e38def9c | 2258 | /* Unless CHANGE_REGION is true, the new and old landing pad |
2259 | had better be associated with the same EH region. */ | |
2260 | gcc_assert (change_region || new_lp->region == old_lp->region); | |
927a6b6b | 2261 | } |
2262 | else | |
2263 | { | |
e38def9c | 2264 | new_lp = NULL; |
2265 | gcc_assert (!change_region); | |
927a6b6b | 2266 | } |
2267 | ||
e38def9c | 2268 | /* Notice when we redirect the last EH edge away from OLD_BB. */ |
2269 | FOR_EACH_EDGE (e, ei, old_bb->preds) | |
2270 | if (e != edge_in && (e->flags & EDGE_EH)) | |
2271 | break; | |
b4ba5e9d | 2272 | |
e38def9c | 2273 | if (new_lp) |
b4ba5e9d | 2274 | { |
e38def9c | 2275 | /* NEW_LP already exists. If there are still edges into OLD_LP, |
2276 | there's nothing to do with the EH tree. If there are no more | |
2277 | edges into OLD_LP, then we want to remove OLD_LP as it is unused. | |
2278 | If CHANGE_REGION is true, then our caller is expecting to remove | |
2279 | the landing pad. */ | |
2280 | if (e == NULL && !change_region) | |
2281 | remove_eh_landing_pad (old_lp); | |
b4ba5e9d | 2282 | } |
e38def9c | 2283 | else |
b4ba5e9d | 2284 | { |
e38def9c | 2285 | /* No correct landing pad exists. If there are no more edges |
2286 | into OLD_LP, then we can simply re-use the existing landing pad. | |
2287 | Otherwise, we have to create a new landing pad. */ | |
2288 | if (e == NULL) | |
2289 | { | |
2290 | EH_LANDING_PAD_NR (old_lp->post_landing_pad) = 0; | |
2291 | new_lp = old_lp; | |
2292 | } | |
2293 | else | |
2294 | new_lp = gen_eh_landing_pad (old_lp->region); | |
2295 | new_lp->post_landing_pad = new_label; | |
2296 | EH_LANDING_PAD_NR (new_label) = new_lp->index; | |
b4ba5e9d | 2297 | } |
e38def9c | 2298 | |
2299 | /* Maybe move the throwing statement to the new region. */ | |
2300 | if (old_lp != new_lp) | |
b4ba5e9d | 2301 | { |
e38def9c | 2302 | remove_stmt_from_eh_lp (throw_stmt); |
2303 | add_stmt_to_eh_lp (throw_stmt, new_lp->index); | |
b4ba5e9d | 2304 | } |
b4ba5e9d | 2305 | } |
2306 | ||
e38def9c | 2307 | /* Redirect EH edge E to NEW_BB. */ |
75a70cf9 | 2308 | |
e38def9c | 2309 | edge |
2310 | redirect_eh_edge (edge edge_in, basic_block new_bb) | |
b4ba5e9d | 2311 | { |
e38def9c | 2312 | redirect_eh_edge_1 (edge_in, new_bb, false); |
2313 | return ssa_redirect_edge (edge_in, new_bb); | |
2314 | } | |
b4ba5e9d | 2315 | |
e38def9c | 2316 | /* This is a subroutine of gimple_redirect_edge_and_branch. Update the |
2317 | labels for redirecting a non-fallthru EH_DISPATCH edge E to NEW_BB. | |
2318 | The actual edge update will happen in the caller. */ | |
b4ba5e9d | 2319 | |
e38def9c | 2320 | void |
2321 | redirect_eh_dispatch_edge (gimple stmt, edge e, basic_block new_bb) | |
2322 | { | |
2323 | tree new_lab = gimple_block_label (new_bb); | |
2324 | bool any_changed = false; | |
2325 | basic_block old_bb; | |
2326 | eh_region r; | |
2327 | eh_catch c; | |
2328 | ||
2329 | r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); | |
2330 | switch (r->type) | |
b4ba5e9d | 2331 | { |
e38def9c | 2332 | case ERT_TRY: |
2333 | for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) | |
b4ba5e9d | 2334 | { |
e38def9c | 2335 | old_bb = label_to_block (c->label); |
2336 | if (old_bb == e->dest) | |
2337 | { | |
2338 | c->label = new_lab; | |
2339 | any_changed = true; | |
2340 | } | |
b4ba5e9d | 2341 | } |
e38def9c | 2342 | break; |
2343 | ||
2344 | case ERT_ALLOWED_EXCEPTIONS: | |
2345 | old_bb = label_to_block (r->u.allowed.label); | |
2346 | gcc_assert (old_bb == e->dest); | |
2347 | r->u.allowed.label = new_lab; | |
2348 | any_changed = true; | |
2349 | break; | |
2350 | ||
2351 | default: | |
2352 | gcc_unreachable (); | |
b4ba5e9d | 2353 | } |
75a70cf9 | 2354 | |
e38def9c | 2355 | gcc_assert (any_changed); |
b4ba5e9d | 2356 | } |
4ee9c684 | 2357 | \f |
75a70cf9 | 2358 | /* Helper function for operation_could_trap_p and stmt_could_throw_p. */ |
2359 | ||
2ac47fdf | 2360 | bool |
75a70cf9 | 2361 | operation_could_trap_helper_p (enum tree_code op, |
2362 | bool fp_operation, | |
2363 | bool honor_trapv, | |
2364 | bool honor_nans, | |
2365 | bool honor_snans, | |
2366 | tree divisor, | |
2367 | bool *handled) | |
2368 | { | |
2369 | *handled = true; | |
2370 | switch (op) | |
2371 | { | |
2372 | case TRUNC_DIV_EXPR: | |
2373 | case CEIL_DIV_EXPR: | |
2374 | case FLOOR_DIV_EXPR: | |
2375 | case ROUND_DIV_EXPR: | |
2376 | case EXACT_DIV_EXPR: | |
2377 | case CEIL_MOD_EXPR: | |
2378 | case FLOOR_MOD_EXPR: | |
2379 | case ROUND_MOD_EXPR: | |
2380 | case TRUNC_MOD_EXPR: | |
2381 | case RDIV_EXPR: | |
2382 | if (honor_snans || honor_trapv) | |
2383 | return true; | |
2384 | if (fp_operation) | |
2385 | return flag_trapping_math; | |
2386 | if (!TREE_CONSTANT (divisor) || integer_zerop (divisor)) | |
2387 | return true; | |
2388 | return false; | |
2389 | ||
2390 | case LT_EXPR: | |
2391 | case LE_EXPR: | |
2392 | case GT_EXPR: | |
2393 | case GE_EXPR: | |
2394 | case LTGT_EXPR: | |
2395 | /* Some floating point comparisons may trap. */ | |
2396 | return honor_nans; | |
2397 | ||
2398 | case EQ_EXPR: | |
2399 | case NE_EXPR: | |
2400 | case UNORDERED_EXPR: | |
2401 | case ORDERED_EXPR: | |
2402 | case UNLT_EXPR: | |
2403 | case UNLE_EXPR: | |
2404 | case UNGT_EXPR: | |
2405 | case UNGE_EXPR: | |
2406 | case UNEQ_EXPR: | |
2407 | return honor_snans; | |
2408 | ||
2409 | case CONVERT_EXPR: | |
2410 | case FIX_TRUNC_EXPR: | |
2411 | /* Conversion of floating point might trap. */ | |
2412 | return honor_nans; | |
2413 | ||
2414 | case NEGATE_EXPR: | |
2415 | case ABS_EXPR: | |
2416 | case CONJ_EXPR: | |
2417 | /* These operations don't trap with floating point. */ | |
2418 | if (honor_trapv) | |
2419 | return true; | |
2420 | return false; | |
2421 | ||
2422 | case PLUS_EXPR: | |
2423 | case MINUS_EXPR: | |
2424 | case MULT_EXPR: | |
2425 | /* Any floating arithmetic may trap. */ | |
2426 | if (fp_operation && flag_trapping_math) | |
2427 | return true; | |
2428 | if (honor_trapv) | |
2429 | return true; | |
2430 | return false; | |
2431 | ||
aa9d6f35 | 2432 | case COMPLEX_EXPR: |
2433 | case CONSTRUCTOR: | |
2434 | /* Constructing an object cannot trap. */ | |
2435 | return false; | |
2436 | ||
75a70cf9 | 2437 | default: |
2438 | /* Any floating arithmetic may trap. */ | |
2439 | if (fp_operation && flag_trapping_math) | |
2440 | return true; | |
2441 | ||
2442 | *handled = false; | |
2443 | return false; | |
2444 | } | |
2445 | } | |
2446 | ||
2447 | /* Return true if operation OP may trap. FP_OPERATION is true if OP is applied | |
2448 | on floating-point values. HONOR_TRAPV is true if OP is applied on integer | |
2449 | type operands that may trap. If OP is a division operator, DIVISOR contains | |
2450 | the value of the divisor. */ | |
2451 | ||
2452 | bool | |
2453 | operation_could_trap_p (enum tree_code op, bool fp_operation, bool honor_trapv, | |
2454 | tree divisor) | |
2455 | { | |
2456 | bool honor_nans = (fp_operation && flag_trapping_math | |
2457 | && !flag_finite_math_only); | |
2458 | bool honor_snans = fp_operation && flag_signaling_nans != 0; | |
2459 | bool handled; | |
2460 | ||
2461 | if (TREE_CODE_CLASS (op) != tcc_comparison | |
2462 | && TREE_CODE_CLASS (op) != tcc_unary | |
2463 | && TREE_CODE_CLASS (op) != tcc_binary) | |
2464 | return false; | |
2465 | ||
2466 | return operation_could_trap_helper_p (op, fp_operation, honor_trapv, | |
2467 | honor_nans, honor_snans, divisor, | |
2468 | &handled); | |
2469 | } | |
2470 | ||
2471 | /* Return true if EXPR can trap, as in dereferencing an invalid pointer | |
35c15734 | 2472 | location or floating point arithmetic. C.f. the rtl version, may_trap_p. |
2473 | This routine expects only GIMPLE lhs or rhs input. */ | |
4ee9c684 | 2474 | |
2475 | bool | |
2476 | tree_could_trap_p (tree expr) | |
2477 | { | |
75a70cf9 | 2478 | enum tree_code code; |
35c15734 | 2479 | bool fp_operation = false; |
db97ad41 | 2480 | bool honor_trapv = false; |
75a70cf9 | 2481 | tree t, base, div = NULL_TREE; |
4ee9c684 | 2482 | |
75a70cf9 | 2483 | if (!expr) |
2484 | return false; | |
e38def9c | 2485 | |
75a70cf9 | 2486 | code = TREE_CODE (expr); |
2487 | t = TREE_TYPE (expr); | |
2488 | ||
2489 | if (t) | |
35c15734 | 2490 | { |
7076cb5d | 2491 | if (COMPARISON_CLASS_P (expr)) |
2492 | fp_operation = FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0))); | |
2493 | else | |
2494 | fp_operation = FLOAT_TYPE_P (t); | |
75a70cf9 | 2495 | honor_trapv = INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t); |
35c15734 | 2496 | } |
2497 | ||
75a70cf9 | 2498 | if (TREE_CODE_CLASS (code) == tcc_binary) |
2499 | div = TREE_OPERAND (expr, 1); | |
2500 | if (operation_could_trap_p (code, fp_operation, honor_trapv, div)) | |
2501 | return true; | |
2502 | ||
80f06481 | 2503 | restart: |
4ee9c684 | 2504 | switch (code) |
2505 | { | |
aed164c3 | 2506 | case TARGET_MEM_REF: |
28daba6f | 2507 | if (TREE_CODE (TMR_BASE (expr)) == ADDR_EXPR |
2508 | && !TMR_INDEX (expr) && !TMR_INDEX2 (expr)) | |
9a14ba4f | 2509 | return false; |
2510 | return !TREE_THIS_NOTRAP (expr); | |
aed164c3 | 2511 | |
4ee9c684 | 2512 | case COMPONENT_REF: |
2513 | case REALPART_EXPR: | |
2514 | case IMAGPART_EXPR: | |
2515 | case BIT_FIELD_REF: | |
26d2ad79 | 2516 | case VIEW_CONVERT_EXPR: |
80f06481 | 2517 | case WITH_SIZE_EXPR: |
2518 | expr = TREE_OPERAND (expr, 0); | |
2519 | code = TREE_CODE (expr); | |
2520 | goto restart; | |
7d23383d | 2521 | |
2522 | case ARRAY_RANGE_REF: | |
2100c228 | 2523 | base = TREE_OPERAND (expr, 0); |
2524 | if (tree_could_trap_p (base)) | |
7d23383d | 2525 | return true; |
2100c228 | 2526 | if (TREE_THIS_NOTRAP (expr)) |
2527 | return false; | |
2100c228 | 2528 | return !range_in_array_bounds_p (expr); |
7d23383d | 2529 | |
2530 | case ARRAY_REF: | |
2531 | base = TREE_OPERAND (expr, 0); | |
7d23383d | 2532 | if (tree_could_trap_p (base)) |
2533 | return true; | |
7d23383d | 2534 | if (TREE_THIS_NOTRAP (expr)) |
2535 | return false; | |
7d23383d | 2536 | return !in_array_bounds_p (expr); |
4ee9c684 | 2537 | |
182cf5a9 | 2538 | case MEM_REF: |
2539 | if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR) | |
2540 | return false; | |
2541 | /* Fallthru. */ | |
4ee9c684 | 2542 | case INDIRECT_REF: |
35c15734 | 2543 | return !TREE_THIS_NOTRAP (expr); |
2544 | ||
2545 | case ASM_EXPR: | |
2546 | return TREE_THIS_VOLATILE (expr); | |
010d0641 | 2547 | |
75a70cf9 | 2548 | case CALL_EXPR: |
2549 | t = get_callee_fndecl (expr); | |
2550 | /* Assume that calls to weak functions may trap. */ | |
7e49f1a1 | 2551 | if (!t || !DECL_P (t)) |
35c15734 | 2552 | return true; |
7e49f1a1 | 2553 | if (DECL_WEAK (t)) |
2554 | return tree_could_trap_p (t); | |
2555 | return false; | |
2556 | ||
2557 | case FUNCTION_DECL: | |
2558 | /* Assume that accesses to weak functions may trap, unless we know | |
2559 | they are certainly defined in current TU or in some other | |
2560 | LTO partition. */ | |
2561 | if (DECL_WEAK (expr)) | |
2562 | { | |
2563 | struct cgraph_node *node; | |
2564 | if (!DECL_EXTERNAL (expr)) | |
2565 | return false; | |
2566 | node = cgraph_function_node (cgraph_get_node (expr), NULL); | |
7d0d0ce1 | 2567 | if (node && node->symbol.in_other_partition) |
7e49f1a1 | 2568 | return false; |
2569 | return true; | |
2570 | } | |
2571 | return false; | |
2572 | ||
2573 | case VAR_DECL: | |
2574 | /* Assume that accesses to weak vars may trap, unless we know | |
2575 | they are certainly defined in current TU or in some other | |
2576 | LTO partition. */ | |
2577 | if (DECL_WEAK (expr)) | |
2578 | { | |
2579 | struct varpool_node *node; | |
2580 | if (!DECL_EXTERNAL (expr)) | |
2581 | return false; | |
2582 | node = varpool_variable_node (varpool_get_node (expr), NULL); | |
7d0d0ce1 | 2583 | if (node && node->symbol.in_other_partition) |
7e49f1a1 | 2584 | return false; |
2585 | return true; | |
2586 | } | |
35c15734 | 2587 | return false; |
2588 | ||
75a70cf9 | 2589 | default: |
2590 | return false; | |
2591 | } | |
2592 | } | |
35c15734 | 2593 | |
35c15734 | 2594 | |
75a70cf9 | 2595 | /* Helper for stmt_could_throw_p. Return true if STMT (assumed to be a |
2596 | an assignment or a conditional) may throw. */ | |
35c15734 | 2597 | |
75a70cf9 | 2598 | static bool |
2599 | stmt_could_throw_1_p (gimple stmt) | |
2600 | { | |
2601 | enum tree_code code = gimple_expr_code (stmt); | |
2602 | bool honor_nans = false; | |
2603 | bool honor_snans = false; | |
2604 | bool fp_operation = false; | |
2605 | bool honor_trapv = false; | |
2606 | tree t; | |
2607 | size_t i; | |
2608 | bool handled, ret; | |
db97ad41 | 2609 | |
75a70cf9 | 2610 | if (TREE_CODE_CLASS (code) == tcc_comparison |
2611 | || TREE_CODE_CLASS (code) == tcc_unary | |
2612 | || TREE_CODE_CLASS (code) == tcc_binary) | |
2613 | { | |
25f48be0 | 2614 | if (is_gimple_assign (stmt) |
2615 | && TREE_CODE_CLASS (code) == tcc_comparison) | |
2616 | t = TREE_TYPE (gimple_assign_rhs1 (stmt)); | |
2617 | else if (gimple_code (stmt) == GIMPLE_COND) | |
2618 | t = TREE_TYPE (gimple_cond_lhs (stmt)); | |
2619 | else | |
2620 | t = gimple_expr_type (stmt); | |
75a70cf9 | 2621 | fp_operation = FLOAT_TYPE_P (t); |
2622 | if (fp_operation) | |
2623 | { | |
2624 | honor_nans = flag_trapping_math && !flag_finite_math_only; | |
2625 | honor_snans = flag_signaling_nans != 0; | |
2626 | } | |
2627 | else if (INTEGRAL_TYPE_P (t) && TYPE_OVERFLOW_TRAPS (t)) | |
2628 | honor_trapv = true; | |
2629 | } | |
2630 | ||
2631 | /* Check if the main expression may trap. */ | |
2632 | t = is_gimple_assign (stmt) ? gimple_assign_rhs2 (stmt) : NULL; | |
2633 | ret = operation_could_trap_helper_p (code, fp_operation, honor_trapv, | |
2634 | honor_nans, honor_snans, t, | |
2635 | &handled); | |
2636 | if (handled) | |
2637 | return ret; | |
2638 | ||
2639 | /* If the expression does not trap, see if any of the individual operands may | |
2640 | trap. */ | |
2641 | for (i = 0; i < gimple_num_ops (stmt); i++) | |
2642 | if (tree_could_trap_p (gimple_op (stmt, i))) | |
2643 | return true; | |
2644 | ||
2645 | return false; | |
2646 | } | |
2647 | ||
2648 | ||
2649 | /* Return true if statement STMT could throw an exception. */ | |
2650 | ||
2651 | bool | |
2652 | stmt_could_throw_p (gimple stmt) | |
2653 | { | |
75a70cf9 | 2654 | if (!flag_exceptions) |
2655 | return false; | |
2656 | ||
2657 | /* The only statements that can throw an exception are assignments, | |
e38def9c | 2658 | conditionals, calls, resx, and asms. */ |
2659 | switch (gimple_code (stmt)) | |
2660 | { | |
2661 | case GIMPLE_RESX: | |
2662 | return true; | |
75a70cf9 | 2663 | |
e38def9c | 2664 | case GIMPLE_CALL: |
2665 | return !gimple_call_nothrow_p (stmt); | |
75a70cf9 | 2666 | |
e38def9c | 2667 | case GIMPLE_ASSIGN: |
2668 | case GIMPLE_COND: | |
cbeb677e | 2669 | if (!cfun->can_throw_non_call_exceptions) |
e38def9c | 2670 | return false; |
2671 | return stmt_could_throw_1_p (stmt); | |
75a70cf9 | 2672 | |
e38def9c | 2673 | case GIMPLE_ASM: |
cbeb677e | 2674 | if (!cfun->can_throw_non_call_exceptions) |
e38def9c | 2675 | return false; |
2676 | return gimple_asm_volatile_p (stmt); | |
2677 | ||
2678 | default: | |
2679 | return false; | |
2680 | } | |
4ee9c684 | 2681 | } |
2682 | ||
75a70cf9 | 2683 | |
2684 | /* Return true if expression T could throw an exception. */ | |
2685 | ||
4ee9c684 | 2686 | bool |
2687 | tree_could_throw_p (tree t) | |
2688 | { | |
2689 | if (!flag_exceptions) | |
2690 | return false; | |
75a70cf9 | 2691 | if (TREE_CODE (t) == MODIFY_EXPR) |
4ee9c684 | 2692 | { |
cbeb677e | 2693 | if (cfun->can_throw_non_call_exceptions |
e38def9c | 2694 | && tree_could_trap_p (TREE_OPERAND (t, 0))) |
2695 | return true; | |
75a70cf9 | 2696 | t = TREE_OPERAND (t, 1); |
4ee9c684 | 2697 | } |
2698 | ||
80f06481 | 2699 | if (TREE_CODE (t) == WITH_SIZE_EXPR) |
2700 | t = TREE_OPERAND (t, 0); | |
4ee9c684 | 2701 | if (TREE_CODE (t) == CALL_EXPR) |
2702 | return (call_expr_flags (t) & ECF_NOTHROW) == 0; | |
cbeb677e | 2703 | if (cfun->can_throw_non_call_exceptions) |
3864ad30 | 2704 | return tree_could_trap_p (t); |
4ee9c684 | 2705 | return false; |
2706 | } | |
2707 | ||
b5cebd44 | 2708 | /* Return true if STMT can throw an exception that is not caught within |
2709 | the current function (CFUN). */ | |
2710 | ||
2711 | bool | |
2712 | stmt_can_throw_external (gimple stmt) | |
2713 | { | |
e38def9c | 2714 | int lp_nr; |
b5cebd44 | 2715 | |
2716 | if (!stmt_could_throw_p (stmt)) | |
2717 | return false; | |
2718 | ||
e38def9c | 2719 | lp_nr = lookup_stmt_eh_lp (stmt); |
2720 | return lp_nr == 0; | |
b5cebd44 | 2721 | } |
75a70cf9 | 2722 | |
2723 | /* Return true if STMT can throw an exception that is caught within | |
2724 | the current function (CFUN). */ | |
2725 | ||
4ee9c684 | 2726 | bool |
75a70cf9 | 2727 | stmt_can_throw_internal (gimple stmt) |
4ee9c684 | 2728 | { |
e38def9c | 2729 | int lp_nr; |
75a70cf9 | 2730 | |
e38def9c | 2731 | if (!stmt_could_throw_p (stmt)) |
4ee9c684 | 2732 | return false; |
75a70cf9 | 2733 | |
e38def9c | 2734 | lp_nr = lookup_stmt_eh_lp (stmt); |
2735 | return lp_nr > 0; | |
2736 | } | |
2737 | ||
2738 | /* Given a statement STMT in IFUN, if STMT can no longer throw, then | |
2739 | remove any entry it might have from the EH table. Return true if | |
2740 | any change was made. */ | |
2741 | ||
2742 | bool | |
2743 | maybe_clean_eh_stmt_fn (struct function *ifun, gimple stmt) | |
2744 | { | |
2745 | if (stmt_could_throw_p (stmt)) | |
2746 | return false; | |
2747 | return remove_stmt_from_eh_lp_fn (ifun, stmt); | |
4ee9c684 | 2748 | } |
2749 | ||
e38def9c | 2750 | /* Likewise, but always use the current function. */ |
2751 | ||
2752 | bool | |
2753 | maybe_clean_eh_stmt (gimple stmt) | |
2754 | { | |
2755 | return maybe_clean_eh_stmt_fn (cfun, stmt); | |
2756 | } | |
4ee9c684 | 2757 | |
4c27dd45 | 2758 | /* Given a statement OLD_STMT and a new statement NEW_STMT that has replaced |
2759 | OLD_STMT in the function, remove OLD_STMT from the EH table and put NEW_STMT | |
2760 | in the table if it should be in there. Return TRUE if a replacement was | |
2761 | done that my require an EH edge purge. */ | |
2762 | ||
e38def9c | 2763 | bool |
2764 | maybe_clean_or_replace_eh_stmt (gimple old_stmt, gimple new_stmt) | |
35c15734 | 2765 | { |
e38def9c | 2766 | int lp_nr = lookup_stmt_eh_lp (old_stmt); |
4c27dd45 | 2767 | |
e38def9c | 2768 | if (lp_nr != 0) |
4c27dd45 | 2769 | { |
75a70cf9 | 2770 | bool new_stmt_could_throw = stmt_could_throw_p (new_stmt); |
4c27dd45 | 2771 | |
2772 | if (new_stmt == old_stmt && new_stmt_could_throw) | |
2773 | return false; | |
2774 | ||
e38def9c | 2775 | remove_stmt_from_eh_lp (old_stmt); |
4c27dd45 | 2776 | if (new_stmt_could_throw) |
2777 | { | |
e38def9c | 2778 | add_stmt_to_eh_lp (new_stmt, lp_nr); |
4c27dd45 | 2779 | return false; |
2780 | } | |
2781 | else | |
2782 | return true; | |
2783 | } | |
2784 | ||
35c15734 | 2785 | return false; |
2786 | } | |
e38def9c | 2787 | |
9d75589a | 2788 | /* Given a statement OLD_STMT in OLD_FUN and a duplicate statement NEW_STMT |
e38def9c | 2789 | in NEW_FUN, copy the EH table data from OLD_STMT to NEW_STMT. The MAP |
2790 | operand is the return value of duplicate_eh_regions. */ | |
2791 | ||
2792 | bool | |
2793 | maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple new_stmt, | |
2794 | struct function *old_fun, gimple old_stmt, | |
2795 | struct pointer_map_t *map, int default_lp_nr) | |
2796 | { | |
2797 | int old_lp_nr, new_lp_nr; | |
2798 | void **slot; | |
2799 | ||
2800 | if (!stmt_could_throw_p (new_stmt)) | |
2801 | return false; | |
2802 | ||
2803 | old_lp_nr = lookup_stmt_eh_lp_fn (old_fun, old_stmt); | |
2804 | if (old_lp_nr == 0) | |
2805 | { | |
2806 | if (default_lp_nr == 0) | |
2807 | return false; | |
2808 | new_lp_nr = default_lp_nr; | |
2809 | } | |
2810 | else if (old_lp_nr > 0) | |
2811 | { | |
2812 | eh_landing_pad old_lp, new_lp; | |
2813 | ||
2814 | old_lp = VEC_index (eh_landing_pad, old_fun->eh->lp_array, old_lp_nr); | |
2815 | slot = pointer_map_contains (map, old_lp); | |
2816 | new_lp = (eh_landing_pad) *slot; | |
2817 | new_lp_nr = new_lp->index; | |
2818 | } | |
2819 | else | |
2820 | { | |
2821 | eh_region old_r, new_r; | |
2822 | ||
2823 | old_r = VEC_index (eh_region, old_fun->eh->region_array, -old_lp_nr); | |
2824 | slot = pointer_map_contains (map, old_r); | |
2825 | new_r = (eh_region) *slot; | |
2826 | new_lp_nr = -new_r->index; | |
2827 | } | |
2828 | ||
2829 | add_stmt_to_eh_lp_fn (new_fun, new_stmt, new_lp_nr); | |
2830 | return true; | |
2831 | } | |
2832 | ||
2833 | /* Similar, but both OLD_STMT and NEW_STMT are within the current function, | |
2834 | and thus no remapping is required. */ | |
2835 | ||
2836 | bool | |
2837 | maybe_duplicate_eh_stmt (gimple new_stmt, gimple old_stmt) | |
2838 | { | |
2839 | int lp_nr; | |
2840 | ||
2841 | if (!stmt_could_throw_p (new_stmt)) | |
2842 | return false; | |
2843 | ||
2844 | lp_nr = lookup_stmt_eh_lp (old_stmt); | |
2845 | if (lp_nr == 0) | |
2846 | return false; | |
2847 | ||
2848 | add_stmt_to_eh_lp (new_stmt, lp_nr); | |
2849 | return true; | |
2850 | } | |
4888ab9a | 2851 | \f |
75a70cf9 | 2852 | /* Returns TRUE if oneh and twoh are exception handlers (gimple_try_cleanup of |
2853 | GIMPLE_TRY) that are similar enough to be considered the same. Currently | |
2854 | this only handles handlers consisting of a single call, as that's the | |
2855 | important case for C++: a destructor call for a particular object showing | |
2856 | up in multiple handlers. */ | |
4888ab9a | 2857 | |
2858 | static bool | |
75a70cf9 | 2859 | same_handler_p (gimple_seq oneh, gimple_seq twoh) |
4888ab9a | 2860 | { |
75a70cf9 | 2861 | gimple_stmt_iterator gsi; |
2862 | gimple ones, twos; | |
2863 | unsigned int ai; | |
4888ab9a | 2864 | |
75a70cf9 | 2865 | gsi = gsi_start (oneh); |
2866 | if (!gsi_one_before_end_p (gsi)) | |
4888ab9a | 2867 | return false; |
75a70cf9 | 2868 | ones = gsi_stmt (gsi); |
4888ab9a | 2869 | |
75a70cf9 | 2870 | gsi = gsi_start (twoh); |
2871 | if (!gsi_one_before_end_p (gsi)) | |
4888ab9a | 2872 | return false; |
75a70cf9 | 2873 | twos = gsi_stmt (gsi); |
2874 | ||
2875 | if (!is_gimple_call (ones) | |
2876 | || !is_gimple_call (twos) | |
2877 | || gimple_call_lhs (ones) | |
2878 | || gimple_call_lhs (twos) | |
2879 | || gimple_call_chain (ones) | |
2880 | || gimple_call_chain (twos) | |
fb049fba | 2881 | || !gimple_call_same_target_p (ones, twos) |
75a70cf9 | 2882 | || gimple_call_num_args (ones) != gimple_call_num_args (twos)) |
4888ab9a | 2883 | return false; |
2884 | ||
75a70cf9 | 2885 | for (ai = 0; ai < gimple_call_num_args (ones); ++ai) |
2886 | if (!operand_equal_p (gimple_call_arg (ones, ai), | |
e38def9c | 2887 | gimple_call_arg (twos, ai), 0)) |
4888ab9a | 2888 | return false; |
2889 | ||
2890 | return true; | |
2891 | } | |
2892 | ||
2893 | /* Optimize | |
2894 | try { A() } finally { try { ~B() } catch { ~A() } } | |
2895 | try { ... } finally { ~A() } | |
2896 | into | |
2897 | try { A() } catch { ~B() } | |
2898 | try { ~B() ... } finally { ~A() } | |
2899 | ||
2900 | This occurs frequently in C++, where A is a local variable and B is a | |
2901 | temporary used in the initializer for A. */ | |
2902 | ||
2903 | static void | |
75a70cf9 | 2904 | optimize_double_finally (gimple one, gimple two) |
4888ab9a | 2905 | { |
75a70cf9 | 2906 | gimple oneh; |
2907 | gimple_stmt_iterator gsi; | |
e3a19533 | 2908 | gimple_seq cleanup; |
4888ab9a | 2909 | |
e3a19533 | 2910 | cleanup = gimple_try_cleanup (one); |
2911 | gsi = gsi_start (cleanup); | |
75a70cf9 | 2912 | if (!gsi_one_before_end_p (gsi)) |
4888ab9a | 2913 | return; |
2914 | ||
75a70cf9 | 2915 | oneh = gsi_stmt (gsi); |
2916 | if (gimple_code (oneh) != GIMPLE_TRY | |
2917 | || gimple_try_kind (oneh) != GIMPLE_TRY_CATCH) | |
4888ab9a | 2918 | return; |
2919 | ||
75a70cf9 | 2920 | if (same_handler_p (gimple_try_cleanup (oneh), gimple_try_cleanup (two))) |
4888ab9a | 2921 | { |
75a70cf9 | 2922 | gimple_seq seq = gimple_try_eval (oneh); |
4888ab9a | 2923 | |
75a70cf9 | 2924 | gimple_try_set_cleanup (one, seq); |
2925 | gimple_try_set_kind (one, GIMPLE_TRY_CATCH); | |
2926 | seq = copy_gimple_seq_and_replace_locals (seq); | |
2927 | gimple_seq_add_seq (&seq, gimple_try_eval (two)); | |
2928 | gimple_try_set_eval (two, seq); | |
4888ab9a | 2929 | } |
2930 | } | |
2931 | ||
2932 | /* Perform EH refactoring optimizations that are simpler to do when code | |
c7684b8e | 2933 | flow has been lowered but EH structures haven't. */ |
4888ab9a | 2934 | |
2935 | static void | |
75a70cf9 | 2936 | refactor_eh_r (gimple_seq seq) |
4888ab9a | 2937 | { |
75a70cf9 | 2938 | gimple_stmt_iterator gsi; |
2939 | gimple one, two; | |
4888ab9a | 2940 | |
75a70cf9 | 2941 | one = NULL; |
2942 | two = NULL; | |
2943 | gsi = gsi_start (seq); | |
2944 | while (1) | |
2945 | { | |
2946 | one = two; | |
2947 | if (gsi_end_p (gsi)) | |
2948 | two = NULL; | |
2949 | else | |
2950 | two = gsi_stmt (gsi); | |
2951 | if (one | |
2952 | && two | |
2953 | && gimple_code (one) == GIMPLE_TRY | |
2954 | && gimple_code (two) == GIMPLE_TRY | |
2955 | && gimple_try_kind (one) == GIMPLE_TRY_FINALLY | |
2956 | && gimple_try_kind (two) == GIMPLE_TRY_FINALLY) | |
2957 | optimize_double_finally (one, two); | |
2958 | if (one) | |
2959 | switch (gimple_code (one)) | |
4888ab9a | 2960 | { |
75a70cf9 | 2961 | case GIMPLE_TRY: |
2962 | refactor_eh_r (gimple_try_eval (one)); | |
2963 | refactor_eh_r (gimple_try_cleanup (one)); | |
2964 | break; | |
2965 | case GIMPLE_CATCH: | |
2966 | refactor_eh_r (gimple_catch_handler (one)); | |
2967 | break; | |
2968 | case GIMPLE_EH_FILTER: | |
2969 | refactor_eh_r (gimple_eh_filter_failure (one)); | |
2970 | break; | |
4c0315d0 | 2971 | case GIMPLE_EH_ELSE: |
2972 | refactor_eh_r (gimple_eh_else_n_body (one)); | |
2973 | refactor_eh_r (gimple_eh_else_e_body (one)); | |
2974 | break; | |
75a70cf9 | 2975 | default: |
2976 | break; | |
4888ab9a | 2977 | } |
75a70cf9 | 2978 | if (two) |
2979 | gsi_next (&gsi); | |
2980 | else | |
2981 | break; | |
4888ab9a | 2982 | } |
2983 | } | |
2984 | ||
2985 | static unsigned | |
2986 | refactor_eh (void) | |
2987 | { | |
75a70cf9 | 2988 | refactor_eh_r (gimple_body (current_function_decl)); |
4888ab9a | 2989 | return 0; |
2990 | } | |
2991 | ||
e38def9c | 2992 | static bool |
2993 | gate_refactor_eh (void) | |
2994 | { | |
2995 | return flag_exceptions != 0; | |
2996 | } | |
2997 | ||
20099e35 | 2998 | struct gimple_opt_pass pass_refactor_eh = |
4888ab9a | 2999 | { |
20099e35 | 3000 | { |
3001 | GIMPLE_PASS, | |
4888ab9a | 3002 | "ehopt", /* name */ |
c7875731 | 3003 | OPTGROUP_NONE, /* optinfo_flags */ |
e38def9c | 3004 | gate_refactor_eh, /* gate */ |
4888ab9a | 3005 | refactor_eh, /* execute */ |
3006 | NULL, /* sub */ | |
3007 | NULL, /* next */ | |
3008 | 0, /* static_pass_number */ | |
3009 | TV_TREE_EH, /* tv_id */ | |
3010 | PROP_gimple_lcf, /* properties_required */ | |
3011 | 0, /* properties_provided */ | |
3012 | 0, /* properties_destroyed */ | |
3013 | 0, /* todo_flags_start */ | |
771e2890 | 3014 | 0 /* todo_flags_finish */ |
20099e35 | 3015 | } |
4888ab9a | 3016 | }; |
e38def9c | 3017 | \f |
3018 | /* At the end of gimple optimization, we can lower RESX. */ | |
4c5fcca6 | 3019 | |
e38def9c | 3020 | static bool |
3021 | lower_resx (basic_block bb, gimple stmt, struct pointer_map_t *mnt_map) | |
4c5fcca6 | 3022 | { |
e38def9c | 3023 | int lp_nr; |
3024 | eh_region src_r, dst_r; | |
3025 | gimple_stmt_iterator gsi; | |
3026 | gimple x; | |
3027 | tree fn, src_nr; | |
3028 | bool ret = false; | |
4c5fcca6 | 3029 | |
e38def9c | 3030 | lp_nr = lookup_stmt_eh_lp (stmt); |
3031 | if (lp_nr != 0) | |
3032 | dst_r = get_eh_region_from_lp_number (lp_nr); | |
3033 | else | |
3034 | dst_r = NULL; | |
4c5fcca6 | 3035 | |
e38def9c | 3036 | src_r = get_eh_region_from_number (gimple_resx_region (stmt)); |
e38def9c | 3037 | gsi = gsi_last_bb (bb); |
4c5fcca6 | 3038 | |
395fc2bb | 3039 | if (src_r == NULL) |
3040 | { | |
3041 | /* We can wind up with no source region when pass_cleanup_eh shows | |
3042 | that there are no entries into an eh region and deletes it, but | |
3043 | then the block that contains the resx isn't removed. This can | |
3044 | happen without optimization when the switch statement created by | |
3045 | lower_try_finally_switch isn't simplified to remove the eh case. | |
3046 | ||
3047 | Resolve this by expanding the resx node to an abort. */ | |
3048 | ||
b9a16870 | 3049 | fn = builtin_decl_implicit (BUILT_IN_TRAP); |
395fc2bb | 3050 | x = gimple_build_call (fn, 0); |
3051 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
3052 | ||
3053 | while (EDGE_COUNT (bb->succs) > 0) | |
3054 | remove_edge (EDGE_SUCC (bb, 0)); | |
3055 | } | |
3056 | else if (dst_r) | |
e38def9c | 3057 | { |
3058 | /* When we have a destination region, we resolve this by copying | |
3059 | the excptr and filter values into place, and changing the edge | |
3060 | to immediately after the landing pad. */ | |
3061 | edge e; | |
4c5fcca6 | 3062 | |
e38def9c | 3063 | if (lp_nr < 0) |
3064 | { | |
3065 | basic_block new_bb; | |
3066 | void **slot; | |
3067 | tree lab; | |
3d1eacdb | 3068 | |
e38def9c | 3069 | /* We are resuming into a MUST_NOT_CALL region. Expand a call to |
3070 | the failure decl into a new block, if needed. */ | |
3071 | gcc_assert (dst_r->type == ERT_MUST_NOT_THROW); | |
4c5fcca6 | 3072 | |
e38def9c | 3073 | slot = pointer_map_contains (mnt_map, dst_r); |
3074 | if (slot == NULL) | |
3075 | { | |
3076 | gimple_stmt_iterator gsi2; | |
4c5fcca6 | 3077 | |
e38def9c | 3078 | new_bb = create_empty_bb (bb); |
79f958cb | 3079 | if (current_loops) |
3080 | add_bb_to_loop (new_bb, bb->loop_father); | |
e38def9c | 3081 | lab = gimple_block_label (new_bb); |
3082 | gsi2 = gsi_start_bb (new_bb); | |
4c5fcca6 | 3083 | |
e38def9c | 3084 | fn = dst_r->u.must_not_throw.failure_decl; |
3085 | x = gimple_build_call (fn, 0); | |
3086 | gimple_set_location (x, dst_r->u.must_not_throw.failure_loc); | |
3087 | gsi_insert_after (&gsi2, x, GSI_CONTINUE_LINKING); | |
3bd82487 | 3088 | |
e38def9c | 3089 | slot = pointer_map_insert (mnt_map, dst_r); |
3090 | *slot = lab; | |
3091 | } | |
3092 | else | |
3093 | { | |
3094 | lab = (tree) *slot; | |
3095 | new_bb = label_to_block (lab); | |
3096 | } | |
4c5fcca6 | 3097 | |
e38def9c | 3098 | gcc_assert (EDGE_COUNT (bb->succs) == 0); |
3099 | e = make_edge (bb, new_bb, EDGE_FALLTHRU); | |
3100 | e->count = bb->count; | |
3101 | e->probability = REG_BR_PROB_BASE; | |
3102 | } | |
3103 | else | |
3104 | { | |
3105 | edge_iterator ei; | |
bad12c62 | 3106 | tree dst_nr = build_int_cst (integer_type_node, dst_r->index); |
4c5fcca6 | 3107 | |
b9a16870 | 3108 | fn = builtin_decl_implicit (BUILT_IN_EH_COPY_VALUES); |
bad12c62 | 3109 | src_nr = build_int_cst (integer_type_node, src_r->index); |
e38def9c | 3110 | x = gimple_build_call (fn, 2, dst_nr, src_nr); |
3111 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
4c5fcca6 | 3112 | |
e38def9c | 3113 | /* Update the flags for the outgoing edge. */ |
3114 | e = single_succ_edge (bb); | |
3115 | gcc_assert (e->flags & EDGE_EH); | |
3116 | e->flags = (e->flags & ~EDGE_EH) | EDGE_FALLTHRU; | |
4c5fcca6 | 3117 | |
e38def9c | 3118 | /* If there are no more EH users of the landing pad, delete it. */ |
3119 | FOR_EACH_EDGE (e, ei, e->dest->preds) | |
3120 | if (e->flags & EDGE_EH) | |
3121 | break; | |
3122 | if (e == NULL) | |
3123 | { | |
3124 | eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr); | |
3125 | remove_eh_landing_pad (lp); | |
3126 | } | |
3127 | } | |
4c5fcca6 | 3128 | |
e38def9c | 3129 | ret = true; |
3130 | } | |
3131 | else | |
3132 | { | |
3133 | tree var; | |
4c5fcca6 | 3134 | |
e38def9c | 3135 | /* When we don't have a destination region, this exception escapes |
3136 | up the call chain. We resolve this by generating a call to the | |
3137 | _Unwind_Resume library function. */ | |
4c5fcca6 | 3138 | |
471eff36 | 3139 | /* The ARM EABI redefines _Unwind_Resume as __cxa_end_cleanup |
e38def9c | 3140 | with no arguments for C++ and Java. Check for that. */ |
471eff36 | 3141 | if (src_r->use_cxa_end_cleanup) |
3142 | { | |
b9a16870 | 3143 | fn = builtin_decl_implicit (BUILT_IN_CXA_END_CLEANUP); |
471eff36 | 3144 | x = gimple_build_call (fn, 0); |
3145 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
3146 | } | |
3147 | else | |
3bd82487 | 3148 | { |
b9a16870 | 3149 | fn = builtin_decl_implicit (BUILT_IN_EH_POINTER); |
bad12c62 | 3150 | src_nr = build_int_cst (integer_type_node, src_r->index); |
e38def9c | 3151 | x = gimple_build_call (fn, 1, src_nr); |
3152 | var = create_tmp_var (ptr_type_node, NULL); | |
3153 | var = make_ssa_name (var, x); | |
3154 | gimple_call_set_lhs (x, var); | |
3155 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
3156 | ||
b9a16870 | 3157 | fn = builtin_decl_implicit (BUILT_IN_UNWIND_RESUME); |
e38def9c | 3158 | x = gimple_build_call (fn, 1, var); |
3159 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
3bd82487 | 3160 | } |
4c5fcca6 | 3161 | |
e38def9c | 3162 | gcc_assert (EDGE_COUNT (bb->succs) == 0); |
3bd82487 | 3163 | } |
3d1eacdb | 3164 | |
e38def9c | 3165 | gsi_remove (&gsi, true); |
3166 | ||
3167 | return ret; | |
3bd82487 | 3168 | } |
3169 | ||
e38def9c | 3170 | static unsigned |
3171 | execute_lower_resx (void) | |
3172 | { | |
3173 | basic_block bb; | |
3174 | struct pointer_map_t *mnt_map; | |
3175 | bool dominance_invalidated = false; | |
3176 | bool any_rewritten = false; | |
3bd82487 | 3177 | |
e38def9c | 3178 | mnt_map = pointer_map_create (); |
3bd82487 | 3179 | |
e38def9c | 3180 | FOR_EACH_BB (bb) |
3181 | { | |
3182 | gimple last = last_stmt (bb); | |
3183 | if (last && is_gimple_resx (last)) | |
3184 | { | |
3185 | dominance_invalidated |= lower_resx (bb, last, mnt_map); | |
3186 | any_rewritten = true; | |
3187 | } | |
3188 | } | |
3189 | ||
3190 | pointer_map_destroy (mnt_map); | |
3191 | ||
3192 | if (dominance_invalidated) | |
3193 | { | |
3194 | free_dominance_info (CDI_DOMINATORS); | |
3195 | free_dominance_info (CDI_POST_DOMINATORS); | |
3bd82487 | 3196 | } |
4c5fcca6 | 3197 | |
e38def9c | 3198 | return any_rewritten ? TODO_update_ssa_only_virtuals : 0; |
3199 | } | |
4c5fcca6 | 3200 | |
e38def9c | 3201 | static bool |
395fc2bb | 3202 | gate_lower_resx (void) |
e38def9c | 3203 | { |
395fc2bb | 3204 | return flag_exceptions != 0; |
e38def9c | 3205 | } |
3bd82487 | 3206 | |
e38def9c | 3207 | struct gimple_opt_pass pass_lower_resx = |
3bd82487 | 3208 | { |
e38def9c | 3209 | { |
3210 | GIMPLE_PASS, | |
3211 | "resx", /* name */ | |
c7875731 | 3212 | OPTGROUP_NONE, /* optinfo_flags */ |
395fc2bb | 3213 | gate_lower_resx, /* gate */ |
e38def9c | 3214 | execute_lower_resx, /* execute */ |
3215 | NULL, /* sub */ | |
3216 | NULL, /* next */ | |
3217 | 0, /* static_pass_number */ | |
3218 | TV_TREE_EH, /* tv_id */ | |
3219 | PROP_gimple_lcf, /* properties_required */ | |
3220 | 0, /* properties_provided */ | |
3221 | 0, /* properties_destroyed */ | |
3222 | 0, /* todo_flags_start */ | |
771e2890 | 3223 | TODO_verify_flow /* todo_flags_finish */ |
e38def9c | 3224 | } |
3bd82487 | 3225 | }; |
3226 | ||
1227a337 | 3227 | /* Try to optimize var = {v} {CLOBBER} stmts followed just by |
3228 | external throw. */ | |
3229 | ||
3230 | static void | |
3231 | optimize_clobbers (basic_block bb) | |
3232 | { | |
3233 | gimple_stmt_iterator gsi = gsi_last_bb (bb); | |
d1d905ee | 3234 | for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi)) |
1227a337 | 3235 | { |
3236 | gimple stmt = gsi_stmt (gsi); | |
3237 | if (is_gimple_debug (stmt)) | |
d1d905ee | 3238 | continue; |
3239 | if (!gimple_clobber_p (stmt) | |
3240 | || TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME) | |
1227a337 | 3241 | return; |
3242 | unlink_stmt_vdef (stmt); | |
3243 | gsi_remove (&gsi, true); | |
3244 | release_defs (stmt); | |
3245 | } | |
3246 | } | |
e38def9c | 3247 | |
07428872 | 3248 | /* Try to sink var = {v} {CLOBBER} stmts followed just by |
3249 | internal throw to successor BB. */ | |
3250 | ||
3251 | static int | |
3252 | sink_clobbers (basic_block bb) | |
3253 | { | |
3254 | edge e; | |
3255 | edge_iterator ei; | |
3256 | gimple_stmt_iterator gsi, dgsi; | |
3257 | basic_block succbb; | |
3258 | bool any_clobbers = false; | |
3259 | ||
3260 | /* Only optimize if BB has a single EH successor and | |
3261 | all predecessor edges are EH too. */ | |
3262 | if (!single_succ_p (bb) | |
3263 | || (single_succ_edge (bb)->flags & EDGE_EH) == 0) | |
3264 | return 0; | |
3265 | ||
3266 | FOR_EACH_EDGE (e, ei, bb->preds) | |
3267 | { | |
3268 | if ((e->flags & EDGE_EH) == 0) | |
3269 | return 0; | |
3270 | } | |
3271 | ||
3272 | /* And BB contains only CLOBBER stmts before the final | |
3273 | RESX. */ | |
3274 | gsi = gsi_last_bb (bb); | |
3275 | for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi)) | |
3276 | { | |
3277 | gimple stmt = gsi_stmt (gsi); | |
3278 | if (is_gimple_debug (stmt)) | |
3279 | continue; | |
3280 | if (gimple_code (stmt) == GIMPLE_LABEL) | |
3281 | break; | |
3282 | if (!gimple_clobber_p (stmt) | |
3283 | || TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME) | |
3284 | return 0; | |
3285 | any_clobbers = true; | |
3286 | } | |
3287 | if (!any_clobbers) | |
3288 | return 0; | |
3289 | ||
3290 | succbb = single_succ (bb); | |
3291 | dgsi = gsi_after_labels (succbb); | |
3292 | gsi = gsi_last_bb (bb); | |
3293 | for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi)) | |
3294 | { | |
3295 | gimple stmt = gsi_stmt (gsi); | |
07428872 | 3296 | if (is_gimple_debug (stmt)) |
3297 | continue; | |
3298 | if (gimple_code (stmt) == GIMPLE_LABEL) | |
3299 | break; | |
3300 | unlink_stmt_vdef (stmt); | |
3301 | gsi_remove (&gsi, false); | |
278611f2 | 3302 | /* Trigger the operand scanner to cause renaming for virtual |
3303 | operands for this statement. | |
3304 | ??? Given the simple structure of this code manually | |
3305 | figuring out the reaching definition should not be too hard. */ | |
3306 | if (gimple_vuse (stmt)) | |
3307 | gimple_set_vuse (stmt, NULL_TREE); | |
07428872 | 3308 | gsi_insert_before (&dgsi, stmt, GSI_SAME_STMT); |
3309 | } | |
3310 | ||
3311 | return TODO_update_ssa_only_virtuals; | |
3312 | } | |
3313 | ||
778f5bdd | 3314 | /* At the end of inlining, we can lower EH_DISPATCH. Return true when |
3315 | we have found some duplicate labels and removed some edges. */ | |
3bd82487 | 3316 | |
778f5bdd | 3317 | static bool |
e38def9c | 3318 | lower_eh_dispatch (basic_block src, gimple stmt) |
3bd82487 | 3319 | { |
e38def9c | 3320 | gimple_stmt_iterator gsi; |
3321 | int region_nr; | |
3322 | eh_region r; | |
3323 | tree filter, fn; | |
3324 | gimple x; | |
778f5bdd | 3325 | bool redirected = false; |
3bd82487 | 3326 | |
e38def9c | 3327 | region_nr = gimple_eh_dispatch_region (stmt); |
3328 | r = get_eh_region_from_number (region_nr); | |
3bd82487 | 3329 | |
e38def9c | 3330 | gsi = gsi_last_bb (src); |
3bd82487 | 3331 | |
e38def9c | 3332 | switch (r->type) |
3bd82487 | 3333 | { |
e38def9c | 3334 | case ERT_TRY: |
3335 | { | |
3336 | VEC (tree, heap) *labels = NULL; | |
3337 | tree default_label = NULL; | |
3338 | eh_catch c; | |
3339 | edge_iterator ei; | |
3340 | edge e; | |
778f5bdd | 3341 | struct pointer_set_t *seen_values = pointer_set_create (); |
e38def9c | 3342 | |
3343 | /* Collect the labels for a switch. Zero the post_landing_pad | |
3344 | field becase we'll no longer have anything keeping these labels | |
9d75589a | 3345 | in existence and the optimizer will be free to merge these |
e38def9c | 3346 | blocks at will. */ |
3347 | for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) | |
3348 | { | |
3349 | tree tp_node, flt_node, lab = c->label; | |
778f5bdd | 3350 | bool have_label = false; |
3bd82487 | 3351 | |
e38def9c | 3352 | c->label = NULL; |
3353 | tp_node = c->type_list; | |
3354 | flt_node = c->filter_list; | |
3355 | ||
3356 | if (tp_node == NULL) | |
3357 | { | |
3358 | default_label = lab; | |
3359 | break; | |
3360 | } | |
3361 | do | |
3362 | { | |
778f5bdd | 3363 | /* Filter out duplicate labels that arise when this handler |
3364 | is shadowed by an earlier one. When no labels are | |
3365 | attached to the handler anymore, we remove | |
3366 | the corresponding edge and then we delete unreachable | |
3367 | blocks at the end of this pass. */ | |
3368 | if (! pointer_set_contains (seen_values, TREE_VALUE (flt_node))) | |
3369 | { | |
b6e3dd65 | 3370 | tree t = build_case_label (TREE_VALUE (flt_node), |
3371 | NULL, lab); | |
778f5bdd | 3372 | VEC_safe_push (tree, heap, labels, t); |
3373 | pointer_set_insert (seen_values, TREE_VALUE (flt_node)); | |
3374 | have_label = true; | |
3375 | } | |
e38def9c | 3376 | |
3377 | tp_node = TREE_CHAIN (tp_node); | |
3378 | flt_node = TREE_CHAIN (flt_node); | |
3379 | } | |
3380 | while (tp_node); | |
778f5bdd | 3381 | if (! have_label) |
3382 | { | |
3383 | remove_edge (find_edge (src, label_to_block (lab))); | |
3384 | redirected = true; | |
3385 | } | |
e38def9c | 3386 | } |
3387 | ||
3388 | /* Clean up the edge flags. */ | |
3389 | FOR_EACH_EDGE (e, ei, src->succs) | |
3390 | { | |
3391 | if (e->flags & EDGE_FALLTHRU) | |
3392 | { | |
3393 | /* If there was no catch-all, use the fallthru edge. */ | |
3394 | if (default_label == NULL) | |
3395 | default_label = gimple_block_label (e->dest); | |
3396 | e->flags &= ~EDGE_FALLTHRU; | |
3397 | } | |
3398 | } | |
3399 | gcc_assert (default_label != NULL); | |
3400 | ||
3401 | /* Don't generate a switch if there's only a default case. | |
3402 | This is common in the form of try { A; } catch (...) { B; }. */ | |
3403 | if (labels == NULL) | |
3404 | { | |
3405 | e = single_succ_edge (src); | |
3406 | e->flags |= EDGE_FALLTHRU; | |
3407 | } | |
3408 | else | |
3409 | { | |
b9a16870 | 3410 | fn = builtin_decl_implicit (BUILT_IN_EH_FILTER); |
bad12c62 | 3411 | x = gimple_build_call (fn, 1, build_int_cst (integer_type_node, |
3412 | region_nr)); | |
e38def9c | 3413 | filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL); |
3414 | filter = make_ssa_name (filter, x); | |
3415 | gimple_call_set_lhs (x, filter); | |
3416 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
3417 | ||
3418 | /* Turn the default label into a default case. */ | |
b6e3dd65 | 3419 | default_label = build_case_label (NULL, NULL, default_label); |
e38def9c | 3420 | sort_case_labels (labels); |
3421 | ||
49a70175 | 3422 | x = gimple_build_switch (filter, default_label, labels); |
e38def9c | 3423 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); |
3424 | ||
3425 | VEC_free (tree, heap, labels); | |
3426 | } | |
778f5bdd | 3427 | pointer_set_destroy (seen_values); |
e38def9c | 3428 | } |
3429 | break; | |
3430 | ||
3431 | case ERT_ALLOWED_EXCEPTIONS: | |
3432 | { | |
3433 | edge b_e = BRANCH_EDGE (src); | |
3434 | edge f_e = FALLTHRU_EDGE (src); | |
3435 | ||
b9a16870 | 3436 | fn = builtin_decl_implicit (BUILT_IN_EH_FILTER); |
bad12c62 | 3437 | x = gimple_build_call (fn, 1, build_int_cst (integer_type_node, |
3438 | region_nr)); | |
e38def9c | 3439 | filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL); |
3440 | filter = make_ssa_name (filter, x); | |
3441 | gimple_call_set_lhs (x, filter); | |
3442 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
3443 | ||
3444 | r->u.allowed.label = NULL; | |
3445 | x = gimple_build_cond (EQ_EXPR, filter, | |
3446 | build_int_cst (TREE_TYPE (filter), | |
3447 | r->u.allowed.filter), | |
3448 | NULL_TREE, NULL_TREE); | |
3449 | gsi_insert_before (&gsi, x, GSI_SAME_STMT); | |
3450 | ||
3451 | b_e->flags = b_e->flags | EDGE_TRUE_VALUE; | |
3452 | f_e->flags = (f_e->flags & ~EDGE_FALLTHRU) | EDGE_FALSE_VALUE; | |
3453 | } | |
3454 | break; | |
3455 | ||
3456 | default: | |
3457 | gcc_unreachable (); | |
3bd82487 | 3458 | } |
e38def9c | 3459 | |
3460 | /* Replace the EH_DISPATCH with the SWITCH or COND generated above. */ | |
3461 | gsi_remove (&gsi, true); | |
778f5bdd | 3462 | return redirected; |
3bd82487 | 3463 | } |
3464 | ||
e38def9c | 3465 | static unsigned |
3466 | execute_lower_eh_dispatch (void) | |
3467 | { | |
3468 | basic_block bb; | |
07428872 | 3469 | int flags = 0; |
778f5bdd | 3470 | bool redirected = false; |
3bd82487 | 3471 | |
e38def9c | 3472 | assign_filter_values (); |
3d1eacdb | 3473 | |
e38def9c | 3474 | FOR_EACH_BB (bb) |
3475 | { | |
3476 | gimple last = last_stmt (bb); | |
1227a337 | 3477 | if (last == NULL) |
3478 | continue; | |
3479 | if (gimple_code (last) == GIMPLE_EH_DISPATCH) | |
e38def9c | 3480 | { |
778f5bdd | 3481 | redirected |= lower_eh_dispatch (bb, last); |
07428872 | 3482 | flags |= TODO_update_ssa_only_virtuals; |
3483 | } | |
3484 | else if (gimple_code (last) == GIMPLE_RESX) | |
3485 | { | |
3486 | if (stmt_can_throw_external (last)) | |
3487 | optimize_clobbers (bb); | |
3488 | else | |
3489 | flags |= sink_clobbers (bb); | |
e38def9c | 3490 | } |
3491 | } | |
3492 | ||
778f5bdd | 3493 | if (redirected) |
3494 | delete_unreachable_blocks (); | |
07428872 | 3495 | return flags; |
e38def9c | 3496 | } |
3497 | ||
395fc2bb | 3498 | static bool |
3499 | gate_lower_eh_dispatch (void) | |
3500 | { | |
de2ca00d | 3501 | return cfun->eh->region_tree != NULL; |
395fc2bb | 3502 | } |
3503 | ||
e38def9c | 3504 | struct gimple_opt_pass pass_lower_eh_dispatch = |
3bd82487 | 3505 | { |
e38def9c | 3506 | { |
3507 | GIMPLE_PASS, | |
3508 | "ehdisp", /* name */ | |
c7875731 | 3509 | OPTGROUP_NONE, /* optinfo_flags */ |
395fc2bb | 3510 | gate_lower_eh_dispatch, /* gate */ |
e38def9c | 3511 | execute_lower_eh_dispatch, /* execute */ |
3512 | NULL, /* sub */ | |
3513 | NULL, /* next */ | |
3514 | 0, /* static_pass_number */ | |
3515 | TV_TREE_EH, /* tv_id */ | |
3516 | PROP_gimple_lcf, /* properties_required */ | |
3517 | 0, /* properties_provided */ | |
3518 | 0, /* properties_destroyed */ | |
3519 | 0, /* todo_flags_start */ | |
771e2890 | 3520 | TODO_verify_flow /* todo_flags_finish */ |
e38def9c | 3521 | } |
3522 | }; | |
3523 | \f | |
3524 | /* Walk statements, see what regions are really referenced and remove | |
3525 | those that are unused. */ | |
3526 | ||
3527 | static void | |
3528 | remove_unreachable_handlers (void) | |
3529 | { | |
3530 | sbitmap r_reachable, lp_reachable; | |
3531 | eh_region region; | |
3532 | eh_landing_pad lp; | |
3533 | basic_block bb; | |
3534 | int lp_nr, r_nr; | |
3bd82487 | 3535 | |
e38def9c | 3536 | r_reachable = sbitmap_alloc (VEC_length (eh_region, cfun->eh->region_array)); |
3537 | lp_reachable | |
3538 | = sbitmap_alloc (VEC_length (eh_landing_pad, cfun->eh->lp_array)); | |
53c5d9d4 | 3539 | bitmap_clear (r_reachable); |
3540 | bitmap_clear (lp_reachable); | |
3bd82487 | 3541 | |
e38def9c | 3542 | FOR_EACH_BB (bb) |
3bd82487 | 3543 | { |
d0ac3b8a | 3544 | gimple_stmt_iterator gsi; |
e38def9c | 3545 | |
3546 | for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) | |
3547 | { | |
3548 | gimple stmt = gsi_stmt (gsi); | |
3549 | lp_nr = lookup_stmt_eh_lp (stmt); | |
3550 | ||
3551 | /* Negative LP numbers are MUST_NOT_THROW regions which | |
3552 | are not considered BB enders. */ | |
3553 | if (lp_nr < 0) | |
3554 | SET_BIT (r_reachable, -lp_nr); | |
3555 | ||
3556 | /* Positive LP numbers are real landing pads, are are BB enders. */ | |
3557 | else if (lp_nr > 0) | |
3558 | { | |
3559 | gcc_assert (gsi_one_before_end_p (gsi)); | |
3560 | region = get_eh_region_from_lp_number (lp_nr); | |
3561 | SET_BIT (r_reachable, region->index); | |
3562 | SET_BIT (lp_reachable, lp_nr); | |
3563 | } | |
4e392ca1 | 3564 | |
3565 | /* Avoid removing regions referenced from RESX/EH_DISPATCH. */ | |
3566 | switch (gimple_code (stmt)) | |
3567 | { | |
3568 | case GIMPLE_RESX: | |
3569 | SET_BIT (r_reachable, gimple_resx_region (stmt)); | |
3570 | break; | |
3571 | case GIMPLE_EH_DISPATCH: | |
3572 | SET_BIT (r_reachable, gimple_eh_dispatch_region (stmt)); | |
3573 | break; | |
3574 | default: | |
3575 | break; | |
3576 | } | |
e38def9c | 3577 | } |
3bd82487 | 3578 | } |
e38def9c | 3579 | |
3580 | if (dump_file) | |
3bd82487 | 3581 | { |
e38def9c | 3582 | fprintf (dump_file, "Before removal of unreachable regions:\n"); |
3583 | dump_eh_tree (dump_file, cfun); | |
3584 | fprintf (dump_file, "Reachable regions: "); | |
53c5d9d4 | 3585 | dump_bitmap_file (dump_file, r_reachable); |
e38def9c | 3586 | fprintf (dump_file, "Reachable landing pads: "); |
53c5d9d4 | 3587 | dump_bitmap_file (dump_file, lp_reachable); |
3bd82487 | 3588 | } |
3589 | ||
e38def9c | 3590 | for (r_nr = 1; |
3591 | VEC_iterate (eh_region, cfun->eh->region_array, r_nr, region); ++r_nr) | |
3592 | if (region && !TEST_BIT (r_reachable, r_nr)) | |
3593 | { | |
3594 | if (dump_file) | |
3595 | fprintf (dump_file, "Removing unreachable region %d\n", r_nr); | |
3596 | remove_eh_handler (region); | |
3597 | } | |
3bd82487 | 3598 | |
e38def9c | 3599 | for (lp_nr = 1; |
3600 | VEC_iterate (eh_landing_pad, cfun->eh->lp_array, lp_nr, lp); ++lp_nr) | |
3601 | if (lp && !TEST_BIT (lp_reachable, lp_nr)) | |
3602 | { | |
3603 | if (dump_file) | |
3604 | fprintf (dump_file, "Removing unreachable landing pad %d\n", lp_nr); | |
3605 | remove_eh_landing_pad (lp); | |
3606 | } | |
48e1416a | 3607 | |
e38def9c | 3608 | if (dump_file) |
3bd82487 | 3609 | { |
e38def9c | 3610 | fprintf (dump_file, "\n\nAfter removal of unreachable regions:\n"); |
3611 | dump_eh_tree (dump_file, cfun); | |
3612 | fprintf (dump_file, "\n\n"); | |
3bd82487 | 3613 | } |
3614 | ||
e38def9c | 3615 | sbitmap_free (r_reachable); |
3616 | sbitmap_free (lp_reachable); | |
3617 | ||
3618 | #ifdef ENABLE_CHECKING | |
3619 | verify_eh_tree (cfun); | |
3620 | #endif | |
3621 | } | |
3622 | ||
b00b0dc4 | 3623 | /* Remove unreachable handlers if any landing pads have been removed after |
3624 | last ehcleanup pass (due to gimple_purge_dead_eh_edges). */ | |
3625 | ||
3626 | void | |
3627 | maybe_remove_unreachable_handlers (void) | |
3628 | { | |
3629 | eh_landing_pad lp; | |
3630 | int i; | |
3631 | ||
3632 | if (cfun->eh == NULL) | |
3633 | return; | |
3634 | ||
3635 | for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i) | |
3636 | if (lp && lp->post_landing_pad) | |
3637 | { | |
3638 | if (label_to_block (lp->post_landing_pad) == NULL) | |
3639 | { | |
3640 | remove_unreachable_handlers (); | |
3641 | return; | |
3642 | } | |
3643 | } | |
3644 | } | |
3645 | ||
e38def9c | 3646 | /* Remove regions that do not have landing pads. This assumes |
3647 | that remove_unreachable_handlers has already been run, and | |
3648 | that we've just manipulated the landing pads since then. */ | |
3649 | ||
3650 | static void | |
3651 | remove_unreachable_handlers_no_lp (void) | |
3652 | { | |
3653 | eh_region r; | |
3654 | int i; | |
4b393c71 | 3655 | sbitmap r_reachable; |
3656 | basic_block bb; | |
3657 | ||
3658 | r_reachable = sbitmap_alloc (VEC_length (eh_region, cfun->eh->region_array)); | |
53c5d9d4 | 3659 | bitmap_clear (r_reachable); |
4b393c71 | 3660 | |
3661 | FOR_EACH_BB (bb) | |
3662 | { | |
3663 | gimple stmt = last_stmt (bb); | |
3664 | if (stmt) | |
3665 | /* Avoid removing regions referenced from RESX/EH_DISPATCH. */ | |
3666 | switch (gimple_code (stmt)) | |
3667 | { | |
3668 | case GIMPLE_RESX: | |
3669 | SET_BIT (r_reachable, gimple_resx_region (stmt)); | |
3670 | break; | |
3671 | case GIMPLE_EH_DISPATCH: | |
3672 | SET_BIT (r_reachable, gimple_eh_dispatch_region (stmt)); | |
3673 | break; | |
3674 | default: | |
3675 | break; | |
3676 | } | |
3677 | } | |
e38def9c | 3678 | |
3679 | for (i = 1; VEC_iterate (eh_region, cfun->eh->region_array, i, r); ++i) | |
4b393c71 | 3680 | if (r && r->landing_pads == NULL && r->type != ERT_MUST_NOT_THROW |
3681 | && !TEST_BIT (r_reachable, i)) | |
e38def9c | 3682 | { |
3683 | if (dump_file) | |
3684 | fprintf (dump_file, "Removing unreachable region %d\n", i); | |
3685 | remove_eh_handler (r); | |
3686 | } | |
4b393c71 | 3687 | |
3688 | sbitmap_free (r_reachable); | |
3bd82487 | 3689 | } |
3690 | ||
e38def9c | 3691 | /* Undo critical edge splitting on an EH landing pad. Earlier, we |
3692 | optimisticaly split all sorts of edges, including EH edges. The | |
3693 | optimization passes in between may not have needed them; if not, | |
3694 | we should undo the split. | |
3695 | ||
3696 | Recognize this case by having one EH edge incoming to the BB and | |
3697 | one normal edge outgoing; BB should be empty apart from the | |
3698 | post_landing_pad label. | |
3699 | ||
3700 | Note that this is slightly different from the empty handler case | |
3701 | handled by cleanup_empty_eh, in that the actual handler may yet | |
3702 | have actual code but the landing pad has been separated from the | |
3703 | handler. As such, cleanup_empty_eh relies on this transformation | |
3704 | having been done first. */ | |
4c5fcca6 | 3705 | |
3706 | static bool | |
e38def9c | 3707 | unsplit_eh (eh_landing_pad lp) |
4c5fcca6 | 3708 | { |
e38def9c | 3709 | basic_block bb = label_to_block (lp->post_landing_pad); |
3710 | gimple_stmt_iterator gsi; | |
3711 | edge e_in, e_out; | |
3712 | ||
3713 | /* Quickly check the edge counts on BB for singularity. */ | |
3714 | if (EDGE_COUNT (bb->preds) != 1 || EDGE_COUNT (bb->succs) != 1) | |
3715 | return false; | |
3716 | e_in = EDGE_PRED (bb, 0); | |
3717 | e_out = EDGE_SUCC (bb, 0); | |
4c5fcca6 | 3718 | |
e38def9c | 3719 | /* Input edge must be EH and output edge must be normal. */ |
3720 | if ((e_in->flags & EDGE_EH) == 0 || (e_out->flags & EDGE_EH) != 0) | |
3721 | return false; | |
3722 | ||
0b76e49c | 3723 | /* The block must be empty except for the labels and debug insns. */ |
3724 | gsi = gsi_after_labels (bb); | |
3725 | if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) | |
3726 | gsi_next_nondebug (&gsi); | |
3727 | if (!gsi_end_p (gsi)) | |
e38def9c | 3728 | return false; |
3729 | ||
3730 | /* The destination block must not already have a landing pad | |
3731 | for a different region. */ | |
3732 | for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi)) | |
4c5fcca6 | 3733 | { |
e38def9c | 3734 | gimple stmt = gsi_stmt (gsi); |
3735 | tree lab; | |
3736 | int lp_nr; | |
4c5fcca6 | 3737 | |
e38def9c | 3738 | if (gimple_code (stmt) != GIMPLE_LABEL) |
3739 | break; | |
3740 | lab = gimple_label_label (stmt); | |
3741 | lp_nr = EH_LANDING_PAD_NR (lab); | |
3742 | if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region) | |
3743 | return false; | |
3744 | } | |
4c5fcca6 | 3745 | |
e9d5f86f | 3746 | /* The new destination block must not already be a destination of |
3747 | the source block, lest we merge fallthru and eh edges and get | |
3748 | all sorts of confused. */ | |
3749 | if (find_edge (e_in->src, e_out->dest)) | |
3750 | return false; | |
3751 | ||
c57e3b9d | 3752 | /* ??? We can get degenerate phis due to cfg cleanups. I would have |
3753 | thought this should have been cleaned up by a phicprop pass, but | |
3754 | that doesn't appear to handle virtuals. Propagate by hand. */ | |
3755 | if (!gimple_seq_empty_p (phi_nodes (bb))) | |
3756 | { | |
3757 | for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); ) | |
3758 | { | |
3759 | gimple use_stmt, phi = gsi_stmt (gsi); | |
3760 | tree lhs = gimple_phi_result (phi); | |
3761 | tree rhs = gimple_phi_arg_def (phi, 0); | |
3762 | use_operand_p use_p; | |
3763 | imm_use_iterator iter; | |
3764 | ||
3765 | FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs) | |
3766 | { | |
3767 | FOR_EACH_IMM_USE_ON_STMT (use_p, iter) | |
3768 | SET_USE (use_p, rhs); | |
3769 | } | |
3770 | ||
3771 | if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs)) | |
3772 | SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1; | |
3773 | ||
3774 | remove_phi_node (&gsi, true); | |
3775 | } | |
3776 | } | |
3d1eacdb | 3777 | |
e38def9c | 3778 | if (dump_file && (dump_flags & TDF_DETAILS)) |
3779 | fprintf (dump_file, "Unsplit EH landing pad %d to block %i.\n", | |
3780 | lp->index, e_out->dest->index); | |
3781 | ||
3782 | /* Redirect the edge. Since redirect_eh_edge_1 expects to be moving | |
3783 | a successor edge, humor it. But do the real CFG change with the | |
3784 | predecessor of E_OUT in order to preserve the ordering of arguments | |
3785 | to the PHI nodes in E_OUT->DEST. */ | |
3786 | redirect_eh_edge_1 (e_in, e_out->dest, false); | |
3787 | redirect_edge_pred (e_out, e_in->src); | |
3788 | e_out->flags = e_in->flags; | |
3789 | e_out->probability = e_in->probability; | |
3790 | e_out->count = e_in->count; | |
3791 | remove_edge (e_in); | |
3d1eacdb | 3792 | |
e38def9c | 3793 | return true; |
3794 | } | |
3d1eacdb | 3795 | |
e38def9c | 3796 | /* Examine each landing pad block and see if it matches unsplit_eh. */ |
3d1eacdb | 3797 | |
e38def9c | 3798 | static bool |
3799 | unsplit_all_eh (void) | |
3800 | { | |
3801 | bool changed = false; | |
3802 | eh_landing_pad lp; | |
3803 | int i; | |
3d1eacdb | 3804 | |
e38def9c | 3805 | for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i) |
3806 | if (lp) | |
3807 | changed |= unsplit_eh (lp); | |
3808 | ||
3809 | return changed; | |
3810 | } | |
3811 | ||
3812 | /* A subroutine of cleanup_empty_eh. Redirect all EH edges incoming | |
3813 | to OLD_BB to NEW_BB; return true on success, false on failure. | |
3814 | ||
3815 | OLD_BB_OUT is the edge into NEW_BB from OLD_BB, so if we miss any | |
3816 | PHI variables from OLD_BB we can pick them up from OLD_BB_OUT. | |
3817 | Virtual PHIs may be deleted and marked for renaming. */ | |
3818 | ||
3819 | static bool | |
3820 | cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb, | |
c57e3b9d | 3821 | edge old_bb_out, bool change_region) |
e38def9c | 3822 | { |
3823 | gimple_stmt_iterator ngsi, ogsi; | |
3824 | edge_iterator ei; | |
3825 | edge e; | |
3826 | bitmap rename_virts; | |
3827 | bitmap ophi_handled; | |
3828 | ||
19bcc424 | 3829 | /* The destination block must not be a regular successor for any |
3830 | of the preds of the landing pad. Thus, avoid turning | |
3831 | <..> | |
3832 | | \ EH | |
3833 | | <..> | |
3834 | | / | |
3835 | <..> | |
3836 | into | |
3837 | <..> | |
3838 | | | EH | |
3839 | <..> | |
3840 | which CFG verification would choke on. See PR45172 and PR51089. */ | |
3841 | FOR_EACH_EDGE (e, ei, old_bb->preds) | |
3842 | if (find_edge (e->src, new_bb)) | |
3843 | return false; | |
3844 | ||
e38def9c | 3845 | FOR_EACH_EDGE (e, ei, old_bb->preds) |
3846 | redirect_edge_var_map_clear (e); | |
3847 | ||
3848 | ophi_handled = BITMAP_ALLOC (NULL); | |
3849 | rename_virts = BITMAP_ALLOC (NULL); | |
3850 | ||
3851 | /* First, iterate through the PHIs on NEW_BB and set up the edge_var_map | |
3852 | for the edges we're going to move. */ | |
3853 | for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); gsi_next (&ngsi)) | |
3854 | { | |
3855 | gimple ophi, nphi = gsi_stmt (ngsi); | |
3856 | tree nresult, nop; | |
3857 | ||
3858 | nresult = gimple_phi_result (nphi); | |
3859 | nop = gimple_phi_arg_def (nphi, old_bb_out->dest_idx); | |
3860 | ||
3861 | /* Find the corresponding PHI in OLD_BB so we can forward-propagate | |
3862 | the source ssa_name. */ | |
3863 | ophi = NULL; | |
3864 | for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi)) | |
3865 | { | |
3866 | ophi = gsi_stmt (ogsi); | |
3867 | if (gimple_phi_result (ophi) == nop) | |
3868 | break; | |
3869 | ophi = NULL; | |
927a6b6b | 3870 | } |
3d1eacdb | 3871 | |
e38def9c | 3872 | /* If we did find the corresponding PHI, copy those inputs. */ |
3873 | if (ophi) | |
4c5fcca6 | 3874 | { |
6e21b2e0 | 3875 | /* If NOP is used somewhere else beyond phis in new_bb, give up. */ |
3876 | if (!has_single_use (nop)) | |
3877 | { | |
3878 | imm_use_iterator imm_iter; | |
3879 | use_operand_p use_p; | |
3880 | ||
3881 | FOR_EACH_IMM_USE_FAST (use_p, imm_iter, nop) | |
3882 | { | |
3883 | if (!gimple_debug_bind_p (USE_STMT (use_p)) | |
3884 | && (gimple_code (USE_STMT (use_p)) != GIMPLE_PHI | |
3885 | || gimple_bb (USE_STMT (use_p)) != new_bb)) | |
3886 | goto fail; | |
3887 | } | |
3888 | } | |
e38def9c | 3889 | bitmap_set_bit (ophi_handled, SSA_NAME_VERSION (nop)); |
3890 | FOR_EACH_EDGE (e, ei, old_bb->preds) | |
3d1eacdb | 3891 | { |
e38def9c | 3892 | location_t oloc; |
3893 | tree oop; | |
3894 | ||
3895 | if ((e->flags & EDGE_EH) == 0) | |
3896 | continue; | |
3897 | oop = gimple_phi_arg_def (ophi, e->dest_idx); | |
3898 | oloc = gimple_phi_arg_location (ophi, e->dest_idx); | |
60d535d2 | 3899 | redirect_edge_var_map_add (e, nresult, oop, oloc); |
3d1eacdb | 3900 | } |
e38def9c | 3901 | } |
3902 | /* If we didn't find the PHI, but it's a VOP, remember to rename | |
3903 | it later, assuming all other tests succeed. */ | |
7c782c9b | 3904 | else if (virtual_operand_p (nresult)) |
e38def9c | 3905 | bitmap_set_bit (rename_virts, SSA_NAME_VERSION (nresult)); |
3906 | /* If we didn't find the PHI, and it's a real variable, we know | |
3907 | from the fact that OLD_BB is tree_empty_eh_handler_p that the | |
3908 | variable is unchanged from input to the block and we can simply | |
3909 | re-use the input to NEW_BB from the OLD_BB_OUT edge. */ | |
3910 | else | |
3911 | { | |
3912 | location_t nloc | |
3913 | = gimple_phi_arg_location (nphi, old_bb_out->dest_idx); | |
3914 | FOR_EACH_EDGE (e, ei, old_bb->preds) | |
60d535d2 | 3915 | redirect_edge_var_map_add (e, nresult, nop, nloc); |
e38def9c | 3916 | } |
3917 | } | |
3918 | ||
3919 | /* Second, verify that all PHIs from OLD_BB have been handled. If not, | |
3920 | we don't know what values from the other edges into NEW_BB to use. */ | |
3921 | for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi)) | |
3922 | { | |
3923 | gimple ophi = gsi_stmt (ogsi); | |
3924 | tree oresult = gimple_phi_result (ophi); | |
3925 | if (!bitmap_bit_p (ophi_handled, SSA_NAME_VERSION (oresult))) | |
3926 | goto fail; | |
3927 | } | |
3928 | ||
3929 | /* At this point we know that the merge will succeed. Remove the PHI | |
3930 | nodes for the virtuals that we want to rename. */ | |
3931 | if (!bitmap_empty_p (rename_virts)) | |
3932 | { | |
3933 | for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); ) | |
3934 | { | |
3935 | gimple nphi = gsi_stmt (ngsi); | |
3936 | tree nresult = gimple_phi_result (nphi); | |
3937 | if (bitmap_bit_p (rename_virts, SSA_NAME_VERSION (nresult))) | |
3d1eacdb | 3938 | { |
e38def9c | 3939 | mark_virtual_phi_result_for_renaming (nphi); |
3940 | remove_phi_node (&ngsi, true); | |
3d1eacdb | 3941 | } |
3942 | else | |
e38def9c | 3943 | gsi_next (&ngsi); |
3bd82487 | 3944 | } |
e38def9c | 3945 | } |
3bd82487 | 3946 | |
e38def9c | 3947 | /* Finally, move the edges and update the PHIs. */ |
3948 | for (ei = ei_start (old_bb->preds); (e = ei_safe_edge (ei)); ) | |
3949 | if (e->flags & EDGE_EH) | |
3950 | { | |
3a37f7bd | 3951 | /* ??? CFG manipluation routines do not try to update loop |
3952 | form on edge redirection. Do so manually here for now. */ | |
3953 | /* If we redirect a loop entry or latch edge that will either create | |
3954 | a multiple entry loop or rotate the loop. If the loops merge | |
3955 | we may have created a loop with multiple latches. | |
3956 | All of this isn't easily fixed thus cancel the affected loop | |
3957 | and mark the other loop as possibly having multiple latches. */ | |
3958 | if (current_loops | |
3959 | && e->dest == e->dest->loop_father->header) | |
3960 | { | |
3961 | e->dest->loop_father->header = NULL; | |
3962 | e->dest->loop_father->latch = NULL; | |
3963 | new_bb->loop_father->latch = NULL; | |
3964 | loops_state_set (LOOPS_NEED_FIXUP|LOOPS_MAY_HAVE_MULTIPLE_LATCHES); | |
3965 | } | |
c57e3b9d | 3966 | redirect_eh_edge_1 (e, new_bb, change_region); |
e38def9c | 3967 | redirect_edge_succ (e, new_bb); |
3968 | flush_pending_stmts (e); | |
3969 | } | |
3970 | else | |
3971 | ei_next (&ei); | |
3bd82487 | 3972 | |
e38def9c | 3973 | BITMAP_FREE (ophi_handled); |
3974 | BITMAP_FREE (rename_virts); | |
3975 | return true; | |
3976 | ||
3977 | fail: | |
3978 | FOR_EACH_EDGE (e, ei, old_bb->preds) | |
3979 | redirect_edge_var_map_clear (e); | |
3980 | BITMAP_FREE (ophi_handled); | |
3981 | BITMAP_FREE (rename_virts); | |
3982 | return false; | |
3983 | } | |
3984 | ||
3985 | /* A subroutine of cleanup_empty_eh. Move a landing pad LP from its | |
3986 | old region to NEW_REGION at BB. */ | |
3987 | ||
3988 | static void | |
3989 | cleanup_empty_eh_move_lp (basic_block bb, edge e_out, | |
3990 | eh_landing_pad lp, eh_region new_region) | |
3991 | { | |
3992 | gimple_stmt_iterator gsi; | |
3993 | eh_landing_pad *pp; | |
3994 | ||
3995 | for (pp = &lp->region->landing_pads; *pp != lp; pp = &(*pp)->next_lp) | |
3996 | continue; | |
3997 | *pp = lp->next_lp; | |
3998 | ||
3999 | lp->region = new_region; | |
4000 | lp->next_lp = new_region->landing_pads; | |
4001 | new_region->landing_pads = lp; | |
4002 | ||
4003 | /* Delete the RESX that was matched within the empty handler block. */ | |
4004 | gsi = gsi_last_bb (bb); | |
bc8a8451 | 4005 | unlink_stmt_vdef (gsi_stmt (gsi)); |
e38def9c | 4006 | gsi_remove (&gsi, true); |
4007 | ||
4008 | /* Clean up E_OUT for the fallthru. */ | |
4009 | e_out->flags = (e_out->flags & ~EDGE_EH) | EDGE_FALLTHRU; | |
4010 | e_out->probability = REG_BR_PROB_BASE; | |
4011 | } | |
4012 | ||
4013 | /* A subroutine of cleanup_empty_eh. Handle more complex cases of | |
48e1416a | 4014 | unsplitting than unsplit_eh was prepared to handle, e.g. when |
e38def9c | 4015 | multiple incoming edges and phis are involved. */ |
4016 | ||
4017 | static bool | |
c57e3b9d | 4018 | cleanup_empty_eh_unsplit (basic_block bb, edge e_out, eh_landing_pad lp) |
e38def9c | 4019 | { |
4020 | gimple_stmt_iterator gsi; | |
e38def9c | 4021 | tree lab; |
4022 | ||
4023 | /* We really ought not have totally lost everything following | |
4024 | a landing pad label. Given that BB is empty, there had better | |
4025 | be a successor. */ | |
4026 | gcc_assert (e_out != NULL); | |
4027 | ||
c57e3b9d | 4028 | /* The destination block must not already have a landing pad |
4029 | for a different region. */ | |
e38def9c | 4030 | lab = NULL; |
4031 | for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi)) | |
4032 | { | |
4033 | gimple stmt = gsi_stmt (gsi); | |
c57e3b9d | 4034 | int lp_nr; |
4035 | ||
e38def9c | 4036 | if (gimple_code (stmt) != GIMPLE_LABEL) |
4037 | break; | |
4038 | lab = gimple_label_label (stmt); | |
c57e3b9d | 4039 | lp_nr = EH_LANDING_PAD_NR (lab); |
4040 | if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region) | |
4041 | return false; | |
e38def9c | 4042 | } |
e38def9c | 4043 | |
4044 | /* Attempt to move the PHIs into the successor block. */ | |
c57e3b9d | 4045 | if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, false)) |
e38def9c | 4046 | { |
4047 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
4048 | fprintf (dump_file, | |
c57e3b9d | 4049 | "Unsplit EH landing pad %d to block %i " |
4050 | "(via cleanup_empty_eh).\n", | |
4051 | lp->index, e_out->dest->index); | |
e38def9c | 4052 | return true; |
4053 | } | |
4054 | ||
4055 | return false; | |
4056 | } | |
4057 | ||
a9309f85 | 4058 | /* Return true if edge E_FIRST is part of an empty infinite loop |
4059 | or leads to such a loop through a series of single successor | |
4060 | empty bbs. */ | |
4061 | ||
4062 | static bool | |
4063 | infinite_empty_loop_p (edge e_first) | |
4064 | { | |
4065 | bool inf_loop = false; | |
4066 | edge e; | |
4067 | ||
4068 | if (e_first->dest == e_first->src) | |
4069 | return true; | |
4070 | ||
4071 | e_first->src->aux = (void *) 1; | |
4072 | for (e = e_first; single_succ_p (e->dest); e = single_succ_edge (e->dest)) | |
4073 | { | |
4074 | gimple_stmt_iterator gsi; | |
4075 | if (e->dest->aux) | |
4076 | { | |
4077 | inf_loop = true; | |
4078 | break; | |
4079 | } | |
4080 | e->dest->aux = (void *) 1; | |
4081 | gsi = gsi_after_labels (e->dest); | |
4082 | if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) | |
4083 | gsi_next_nondebug (&gsi); | |
4084 | if (!gsi_end_p (gsi)) | |
4085 | break; | |
4086 | } | |
4087 | e_first->src->aux = NULL; | |
4088 | for (e = e_first; e->dest->aux; e = single_succ_edge (e->dest)) | |
4089 | e->dest->aux = NULL; | |
4090 | ||
4091 | return inf_loop; | |
4092 | } | |
4093 | ||
e38def9c | 4094 | /* Examine the block associated with LP to determine if it's an empty |
4095 | handler for its EH region. If so, attempt to redirect EH edges to | |
4096 | an outer region. Return true the CFG was updated in any way. This | |
4097 | is similar to jump forwarding, just across EH edges. */ | |
4098 | ||
4099 | static bool | |
4100 | cleanup_empty_eh (eh_landing_pad lp) | |
4101 | { | |
4102 | basic_block bb = label_to_block (lp->post_landing_pad); | |
4103 | gimple_stmt_iterator gsi; | |
4104 | gimple resx; | |
4105 | eh_region new_region; | |
4106 | edge_iterator ei; | |
4107 | edge e, e_out; | |
4108 | bool has_non_eh_pred; | |
b74338cf | 4109 | bool ret = false; |
e38def9c | 4110 | int new_lp_nr; |
4111 | ||
4112 | /* There can be zero or one edges out of BB. This is the quickest test. */ | |
4113 | switch (EDGE_COUNT (bb->succs)) | |
4114 | { | |
4115 | case 0: | |
4116 | e_out = NULL; | |
4117 | break; | |
4118 | case 1: | |
4119 | e_out = EDGE_SUCC (bb, 0); | |
4120 | break; | |
4121 | default: | |
4122 | return false; | |
4123 | } | |
b74338cf | 4124 | |
4125 | resx = last_stmt (bb); | |
4126 | if (resx && is_gimple_resx (resx)) | |
4127 | { | |
4128 | if (stmt_can_throw_external (resx)) | |
4129 | optimize_clobbers (bb); | |
4130 | else if (sink_clobbers (bb)) | |
4131 | ret = true; | |
4132 | } | |
4133 | ||
e38def9c | 4134 | gsi = gsi_after_labels (bb); |
4135 | ||
4136 | /* Make sure to skip debug statements. */ | |
4137 | if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) | |
4138 | gsi_next_nondebug (&gsi); | |
4139 | ||
4140 | /* If the block is totally empty, look for more unsplitting cases. */ | |
4141 | if (gsi_end_p (gsi)) | |
e54fce5c | 4142 | { |
4143 | /* For the degenerate case of an infinite loop bail out. */ | |
a9309f85 | 4144 | if (infinite_empty_loop_p (e_out)) |
b74338cf | 4145 | return ret; |
e54fce5c | 4146 | |
b74338cf | 4147 | return ret | cleanup_empty_eh_unsplit (bb, e_out, lp); |
e54fce5c | 4148 | } |
e38def9c | 4149 | |
367113ea | 4150 | /* The block should consist only of a single RESX statement, modulo a |
4151 | preceding call to __builtin_stack_restore if there is no outgoing | |
4152 | edge, since the call can be eliminated in this case. */ | |
e38def9c | 4153 | resx = gsi_stmt (gsi); |
367113ea | 4154 | if (!e_out && gimple_call_builtin_p (resx, BUILT_IN_STACK_RESTORE)) |
4155 | { | |
4156 | gsi_next (&gsi); | |
4157 | resx = gsi_stmt (gsi); | |
4158 | } | |
e38def9c | 4159 | if (!is_gimple_resx (resx)) |
b74338cf | 4160 | return ret; |
e38def9c | 4161 | gcc_assert (gsi_one_before_end_p (gsi)); |
4162 | ||
4163 | /* Determine if there are non-EH edges, or resx edges into the handler. */ | |
4164 | has_non_eh_pred = false; | |
4165 | FOR_EACH_EDGE (e, ei, bb->preds) | |
4166 | if (!(e->flags & EDGE_EH)) | |
4167 | has_non_eh_pred = true; | |
4168 | ||
4169 | /* Find the handler that's outer of the empty handler by looking at | |
4170 | where the RESX instruction was vectored. */ | |
4171 | new_lp_nr = lookup_stmt_eh_lp (resx); | |
4172 | new_region = get_eh_region_from_lp_number (new_lp_nr); | |
4173 | ||
4174 | /* If there's no destination region within the current function, | |
4175 | redirection is trivial via removing the throwing statements from | |
4176 | the EH region, removing the EH edges, and allowing the block | |
4177 | to go unreachable. */ | |
4178 | if (new_region == NULL) | |
4179 | { | |
4180 | gcc_assert (e_out == NULL); | |
4181 | for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); ) | |
4182 | if (e->flags & EDGE_EH) | |
4183 | { | |
4184 | gimple stmt = last_stmt (e->src); | |
4185 | remove_stmt_from_eh_lp (stmt); | |
4186 | remove_edge (e); | |
4187 | } | |
4188 | else | |
4189 | ei_next (&ei); | |
4190 | goto succeed; | |
4191 | } | |
4192 | ||
4193 | /* If the destination region is a MUST_NOT_THROW, allow the runtime | |
4194 | to handle the abort and allow the blocks to go unreachable. */ | |
4195 | if (new_region->type == ERT_MUST_NOT_THROW) | |
4196 | { | |
4197 | for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); ) | |
4198 | if (e->flags & EDGE_EH) | |
4199 | { | |
4200 | gimple stmt = last_stmt (e->src); | |
4201 | remove_stmt_from_eh_lp (stmt); | |
4202 | add_stmt_to_eh_lp (stmt, new_lp_nr); | |
4203 | remove_edge (e); | |
4204 | } | |
4205 | else | |
4206 | ei_next (&ei); | |
4207 | goto succeed; | |
4208 | } | |
4209 | ||
4210 | /* Try to redirect the EH edges and merge the PHIs into the destination | |
4211 | landing pad block. If the merge succeeds, we'll already have redirected | |
4212 | all the EH edges. The handler itself will go unreachable if there were | |
4213 | no normal edges. */ | |
c57e3b9d | 4214 | if (cleanup_empty_eh_merge_phis (e_out->dest, bb, e_out, true)) |
e38def9c | 4215 | goto succeed; |
4216 | ||
4217 | /* Finally, if all input edges are EH edges, then we can (potentially) | |
4218 | reduce the number of transfers from the runtime by moving the landing | |
4219 | pad from the original region to the new region. This is a win when | |
4220 | we remove the last CLEANUP region along a particular exception | |
4221 | propagation path. Since nothing changes except for the region with | |
4222 | which the landing pad is associated, the PHI nodes do not need to be | |
4223 | adjusted at all. */ | |
4224 | if (!has_non_eh_pred) | |
4225 | { | |
4226 | cleanup_empty_eh_move_lp (bb, e_out, lp, new_region); | |
4227 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
4228 | fprintf (dump_file, "Empty EH handler %i moved to EH region %i.\n", | |
4229 | lp->index, new_region->index); | |
4230 | ||
4231 | /* ??? The CFG didn't change, but we may have rendered the | |
4232 | old EH region unreachable. Trigger a cleanup there. */ | |
4c5fcca6 | 4233 | return true; |
4234 | } | |
e38def9c | 4235 | |
b74338cf | 4236 | return ret; |
e38def9c | 4237 | |
4238 | succeed: | |
4239 | if (dump_file && (dump_flags & TDF_DETAILS)) | |
4240 | fprintf (dump_file, "Empty EH handler %i removed.\n", lp->index); | |
4241 | remove_eh_landing_pad (lp); | |
4242 | return true; | |
4c5fcca6 | 4243 | } |
4244 | ||
e38def9c | 4245 | /* Do a post-order traversal of the EH region tree. Examine each |
4246 | post_landing_pad block and see if we can eliminate it as empty. */ | |
4247 | ||
4248 | static bool | |
4249 | cleanup_all_empty_eh (void) | |
4250 | { | |
4251 | bool changed = false; | |
4252 | eh_landing_pad lp; | |
4253 | int i; | |
4254 | ||
4255 | for (i = 1; VEC_iterate (eh_landing_pad, cfun->eh->lp_array, i, lp); ++i) | |
4256 | if (lp) | |
4257 | changed |= cleanup_empty_eh (lp); | |
4258 | ||
4259 | return changed; | |
4260 | } | |
4c5fcca6 | 4261 | |
4262 | /* Perform cleanups and lowering of exception handling | |
4263 | 1) cleanups regions with handlers doing nothing are optimized out | |
4264 | 2) MUST_NOT_THROW regions that became dead because of 1) are optimized out | |
4265 | 3) Info about regions that are containing instructions, and regions | |
4266 | reachable via local EH edges is collected | |
4267 | 4) Eh tree is pruned for regions no longer neccesary. | |
e38def9c | 4268 | |
4269 | TODO: Push MUST_NOT_THROW regions to the root of the EH tree. | |
4270 | Unify those that have the same failure decl and locus. | |
4271 | */ | |
4c5fcca6 | 4272 | |
4273 | static unsigned int | |
15100018 | 4274 | execute_cleanup_eh_1 (void) |
4c5fcca6 | 4275 | { |
e38def9c | 4276 | /* Do this first: unsplit_all_eh and cleanup_all_empty_eh can die |
4277 | looking up unreachable landing pads. */ | |
4278 | remove_unreachable_handlers (); | |
4c5fcca6 | 4279 | |
e38def9c | 4280 | /* Watch out for the region tree vanishing due to all unreachable. */ |
4281 | if (cfun->eh->region_tree && optimize) | |
4c5fcca6 | 4282 | { |
e38def9c | 4283 | bool changed = false; |
4c5fcca6 | 4284 | |
e38def9c | 4285 | changed |= unsplit_all_eh (); |
4286 | changed |= cleanup_all_empty_eh (); | |
4287 | ||
4288 | if (changed) | |
48d5ef93 | 4289 | { |
4290 | free_dominance_info (CDI_DOMINATORS); | |
4291 | free_dominance_info (CDI_POST_DOMINATORS); | |
4c5fcca6 | 4292 | |
e38def9c | 4293 | /* We delayed all basic block deletion, as we may have performed |
4294 | cleanups on EH edges while non-EH edges were still present. */ | |
4295 | delete_unreachable_blocks (); | |
4c5fcca6 | 4296 | |
e38def9c | 4297 | /* We manipulated the landing pads. Remove any region that no |
4298 | longer has a landing pad. */ | |
4299 | remove_unreachable_handlers_no_lp (); | |
4300 | ||
4301 | return TODO_cleanup_cfg | TODO_update_ssa_only_virtuals; | |
4302 | } | |
4c5fcca6 | 4303 | } |
4304 | ||
e38def9c | 4305 | return 0; |
4306 | } | |
4307 | ||
15100018 | 4308 | static unsigned int |
4309 | execute_cleanup_eh (void) | |
4310 | { | |
de2ca00d | 4311 | int ret = execute_cleanup_eh_1 (); |
15100018 | 4312 | |
4313 | /* If the function no longer needs an EH personality routine | |
4314 | clear it. This exposes cross-language inlining opportunities | |
4315 | and avoids references to a never defined personality routine. */ | |
4316 | if (DECL_FUNCTION_PERSONALITY (current_function_decl) | |
4317 | && function_needs_eh_personality (cfun) != eh_personality_lang) | |
4318 | DECL_FUNCTION_PERSONALITY (current_function_decl) = NULL_TREE; | |
4319 | ||
4320 | return ret; | |
4321 | } | |
4322 | ||
e38def9c | 4323 | static bool |
4324 | gate_cleanup_eh (void) | |
4325 | { | |
de2ca00d | 4326 | return cfun->eh != NULL && cfun->eh->region_tree != NULL; |
4c5fcca6 | 4327 | } |
4328 | ||
4329 | struct gimple_opt_pass pass_cleanup_eh = { | |
4330 | { | |
4331 | GIMPLE_PASS, | |
4332 | "ehcleanup", /* name */ | |
c7875731 | 4333 | OPTGROUP_NONE, /* optinfo_flags */ |
e38def9c | 4334 | gate_cleanup_eh, /* gate */ |
4335 | execute_cleanup_eh, /* execute */ | |
4c5fcca6 | 4336 | NULL, /* sub */ |
4337 | NULL, /* next */ | |
4338 | 0, /* static_pass_number */ | |
4339 | TV_TREE_EH, /* tv_id */ | |
4340 | PROP_gimple_lcf, /* properties_required */ | |
4341 | 0, /* properties_provided */ | |
4342 | 0, /* properties_destroyed */ | |
4343 | 0, /* todo_flags_start */ | |
771e2890 | 4344 | 0 /* todo_flags_finish */ |
4c5fcca6 | 4345 | } |
4346 | }; | |
e38def9c | 4347 | \f |
4348 | /* Verify that BB containing STMT as the last statement, has precisely the | |
4349 | edge that make_eh_edges would create. */ | |
4350 | ||
4b987fac | 4351 | DEBUG_FUNCTION bool |
e38def9c | 4352 | verify_eh_edges (gimple stmt) |
4353 | { | |
4354 | basic_block bb = gimple_bb (stmt); | |
4355 | eh_landing_pad lp = NULL; | |
4356 | int lp_nr; | |
4357 | edge_iterator ei; | |
4358 | edge e, eh_edge; | |
4359 | ||
4360 | lp_nr = lookup_stmt_eh_lp (stmt); | |
4361 | if (lp_nr > 0) | |
4362 | lp = get_eh_landing_pad_from_number (lp_nr); | |
4363 | ||
4364 | eh_edge = NULL; | |
4365 | FOR_EACH_EDGE (e, ei, bb->succs) | |
4366 | { | |
4367 | if (e->flags & EDGE_EH) | |
4368 | { | |
4369 | if (eh_edge) | |
4370 | { | |
4371 | error ("BB %i has multiple EH edges", bb->index); | |
4372 | return true; | |
4373 | } | |
4374 | else | |
4375 | eh_edge = e; | |
4376 | } | |
4377 | } | |
4378 | ||
4379 | if (lp == NULL) | |
4380 | { | |
4381 | if (eh_edge) | |
4382 | { | |
4383 | error ("BB %i can not throw but has an EH edge", bb->index); | |
4384 | return true; | |
4385 | } | |
4386 | return false; | |
4387 | } | |
4388 | ||
4389 | if (!stmt_could_throw_p (stmt)) | |
4390 | { | |
4391 | error ("BB %i last statement has incorrectly set lp", bb->index); | |
4392 | return true; | |
4393 | } | |
4394 | ||
4395 | if (eh_edge == NULL) | |
4396 | { | |
4397 | error ("BB %i is missing an EH edge", bb->index); | |
4398 | return true; | |
4399 | } | |
4400 | ||
4401 | if (eh_edge->dest != label_to_block (lp->post_landing_pad)) | |
4402 | { | |
4403 | error ("Incorrect EH edge %i->%i", bb->index, eh_edge->dest->index); | |
4404 | return true; | |
4405 | } | |
4406 | ||
4407 | return false; | |
4408 | } | |
4409 | ||
4410 | /* Similarly, but handle GIMPLE_EH_DISPATCH specifically. */ | |
4411 | ||
4b987fac | 4412 | DEBUG_FUNCTION bool |
e38def9c | 4413 | verify_eh_dispatch_edge (gimple stmt) |
4414 | { | |
4415 | eh_region r; | |
4416 | eh_catch c; | |
4417 | basic_block src, dst; | |
4418 | bool want_fallthru = true; | |
4419 | edge_iterator ei; | |
4420 | edge e, fall_edge; | |
4421 | ||
4422 | r = get_eh_region_from_number (gimple_eh_dispatch_region (stmt)); | |
4423 | src = gimple_bb (stmt); | |
4424 | ||
4425 | FOR_EACH_EDGE (e, ei, src->succs) | |
4426 | gcc_assert (e->aux == NULL); | |
4427 | ||
4428 | switch (r->type) | |
4429 | { | |
4430 | case ERT_TRY: | |
4431 | for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) | |
4432 | { | |
4433 | dst = label_to_block (c->label); | |
4434 | e = find_edge (src, dst); | |
4435 | if (e == NULL) | |
4436 | { | |
4437 | error ("BB %i is missing an edge", src->index); | |
4438 | return true; | |
4439 | } | |
4440 | e->aux = (void *)e; | |
4441 | ||
4442 | /* A catch-all handler doesn't have a fallthru. */ | |
4443 | if (c->type_list == NULL) | |
4444 | { | |
4445 | want_fallthru = false; | |
4446 | break; | |
4447 | } | |
4448 | } | |
4449 | break; | |
4450 | ||
4451 | case ERT_ALLOWED_EXCEPTIONS: | |
4452 | dst = label_to_block (r->u.allowed.label); | |
4453 | e = find_edge (src, dst); | |
4454 | if (e == NULL) | |
4455 | { | |
4456 | error ("BB %i is missing an edge", src->index); | |
4457 | return true; | |
4458 | } | |
4459 | e->aux = (void *)e; | |
4460 | break; | |
4461 | ||
4462 | default: | |
4463 | gcc_unreachable (); | |
4464 | } | |
4465 | ||
4466 | fall_edge = NULL; | |
4467 | FOR_EACH_EDGE (e, ei, src->succs) | |
4468 | { | |
4469 | if (e->flags & EDGE_FALLTHRU) | |
4470 | { | |
4471 | if (fall_edge != NULL) | |
4472 | { | |
4473 | error ("BB %i too many fallthru edges", src->index); | |
4474 | return true; | |
4475 | } | |
4476 | fall_edge = e; | |
4477 | } | |
4478 | else if (e->aux) | |
4479 | e->aux = NULL; | |
4480 | else | |
4481 | { | |
4482 | error ("BB %i has incorrect edge", src->index); | |
4483 | return true; | |
4484 | } | |
4485 | } | |
4486 | if ((fall_edge != NULL) ^ want_fallthru) | |
4487 | { | |
4488 | error ("BB %i has incorrect fallthru edge", src->index); | |
4489 | return true; | |
4490 | } | |
4491 | ||
4492 | return false; | |
4493 | } |