Lines Matching refs:finally
287 /* Use the finally tree to determine if a jump from START to TARGET
407 /* True if the finally block can receive an exception edge.
628 finally block nor redirect them if we knew. */
754 } finally {
947 /* A subroutine of lower_try_finally. If FINALLY consits of a
951 get_eh_else (gimple_seq finally)
953 gimple *x = gimple_seq_first_stmt (finally);
956 gcc_assert (gimple_seq_singleton_p (finally));
965 the finally block may not itself throw an exception. We have two choices
966 here. First we can duplicate the finally block and wrap it in a
980 THIS_STATE may be null if this is a try-cleanup, not a try-finally. */
987 gimple_seq finally = gimple_try_cleanup (tf->top_p);
993 if (geh_else *eh_else = get_eh_else (finally))
996 finally = gimple_eh_else_e_body (eh_else);
1004 lower_eh_constructs_1 (outer_state, &finally);
1017 finally = lower_try_finally_dup_block (finally, outer_state,
1027 gimple_stmt_iterator gsi = gsi_start (finally);
1039 gtry *try_stmt = gimple_build_try (finally,
1042 finally = lower_eh_must_not_throw (outer_state, try_stmt);
1047 gimple_seq_add_seq (&eh_seq, finally);
1048 if (gimple_seq_may_fallthru (finally))
1057 no fallthru edge out of the finally block. This means that there is
1068 gimple_seq finally;
1074 finally = gimple_try_cleanup (tf->top_p);
1090 /* Emit the finally block into the stream. Lower EH_ELSE at this time. */
1091 eh_else = get_eh_else (finally);
1094 finally = gimple_eh_else_n_body (eh_else);
1095 lower_eh_constructs_1 (state, &finally);
1096 gimple_seq_add_seq (&tf->top_p_seq, finally);
1100 finally = gimple_eh_else_e_body (eh_else);
1101 lower_eh_constructs_1 (state, &finally);
1104 gimple_seq_add_seq (&eh_seq, finally);
1109 lower_eh_constructs_1 (state, &finally);
1110 gimple_seq_add_seq (&tf->top_p_seq, finally);
1124 exactly one destination of the finally block. Restructure the
1134 gimple_seq finally;
1139 finally = gimple_try_cleanup (tf->top_p);
1145 eh_else = get_eh_else (finally);
1149 finally = gimple_eh_else_e_body (eh_else);
1151 finally = gimple_eh_else_n_body (eh_else);
1154 lower_eh_constructs_1 (state, &finally);
1156 for (gsi = gsi_start (finally
1170 the head of the FINALLY block. Append a RESX at the end. */
1172 gimple_seq_add_seq (&eh_seq, finally);
1181 gimple_seq_add_seq (&tf->top_p_seq, finally);
1189 gimple_seq_add_seq (&tf->top_p_seq, finally);
1219 immediately after the finally block. */
1226 and outgoing from the finally block. Implement this by duplicating the
1227 finally block for every destination. */
1232 gimple_seq finally;
1240 finally = gimple_try_cleanup (tf->top_p);
1243 by considering FINALLY to be the normal return path only. */
1244 eh_else = get_eh_else (finally);
1246 finally = gimple_eh_else_n_body (eh_else);
1253 seq = lower_try_finally_dup_block (finally, state, tf_loc);
1270 seq = lower_try_finally_dup_block (finally, state, tf_loc);
1320 seq = lower_try_finally_dup_block (finally, state, q->location);
1355 and outgoing from the finally block. Implement this by instrumenting
1357 finally block that branches to the appropriate destination. */
1373 gimple_seq finally;
1377 /* The location of the finally block. */
1380 finally = gimple_try_cleanup (tf->top_p);
1381 eh_else = get_eh_else (finally);
1386 /* The location of the finally is either the last stmt in the finally
1388 x = gimple_seq_last_stmt (finally);
1408 /* Begin inserting code for getting to the finally block. Things
1441 finally = gimple_eh_else_e_body (eh_else);
1442 lower_eh_constructs_1 (state, &finally);
1445 gimple_seq_add_seq (&eh_seq, finally);
1449 finally = gimple_eh_else_n_body (eh_else);
1477 lower_eh_constructs_1 (state, &finally);
1478 gimple_seq_add_seq (&tf->top_p_seq, finally);
1565 /* Decide whether or not we are going to duplicate the finally block.
1569 do this is to estimate the size of the finally block, multiply
1574 decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally)
1581 eh_else = get_eh_else (finally);
1585 finally = gimple_eh_else_n_body (eh_else);
1595 for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi))
1608 /* Finally estimate N times, plus N gotos. */
1609 f_estimate = estimate_num_insns_seq (finally, &eni_size_weights);
1653 arrange for the FINALLY block to be executed on all exits. */
1698 /* Determine how many edges (still) reach the finally block. Or rather,
1699 how many destinations are reached by the finally block. Use this to
1700 determine how we process the finally block itself. */
1707 /* If the FINALLY block is not reachable, dike it out. */
1713 /* If the finally block doesn't fall through, then any destination
1935 /* Implement a cleanup expression. This is similar to try-finally,
1959 /* Build enough of a try-finally state so that we can reuse
3191 try { A() } finally { try { ~B() } catch { ~A() } }
3192 try { ... } finally { ~A() }
3195 try { ~B() ... } finally { ~A() }
4477 /* Finally, move the edges and update the PHIs. */
4747 /* Finally, if all input edges are EH edges, then we can (potentially)
Indexes created Sat Feb 28 05:31:39 UTC 2026