tree-eh.c File Reference

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "tm_p.h"
#include "flags.h"
#include "function.h"
#include "except.h"
#include "tree-flow.h"
#include "tree-dump.h"
#include "tree-inline.h"
#include "tree-iterator.h"
#include "tree-pass.h"
#include "timevar.h"
#include "langhooks.h"
#include "ggc.h"
#include "toplev.h"

Include dependency graph for tree-eh.c:

Go to the source code of this file.

Data Structures
struct	finally_tree_node
struct	leh_state
struct	leh_tf_state
struct	leh_tf_state::goto_queue_node
Defines
#define	verify_norecord_switch_expr(state, switch_expr)
Functions
void	using_eh_for_cleanups ()
static int	struct_ptr_eq ()
static hashval_t	struct_ptr_hash ()
static void	record_stmt_eh_region ()
void	add_stmt_to_eh_region_fn ()
void	add_stmt_to_eh_region ()
bool	remove_stmt_from_eh_region_fn ()
bool	remove_stmt_from_eh_region ()
int	lookup_stmt_eh_region_fn ()
int	lookup_stmt_eh_region ()
static void	record_in_finally_tree ()
static void	collect_finally_tree ()
static bool	outside_finally_tree ()
static void	lower_eh_filter (struct leh_state *, tree *)
static void	lower_eh_constructs_1 (struct leh_state *, tree *)
static int	goto_queue_cmp ()
static tree	find_goto_replacement ()
static void	replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf, tree_stmt_iterator *tsi)
static void	replace_goto_queue_stmt_list (tree, struct leh_tf_state *)
static void	replace_goto_queue_1 ()
static void	replace_goto_queue_stmt_list ()
static void	replace_goto_queue ()
static void	maybe_record_in_goto_queue ()
static void	do_return_redirection (struct goto_queue_node *q, tree finlab, tree mod, tree *return_value_p)
static void	do_goto_redirection ()
static void	frob_into_branch_around ()
static tree	lower_try_finally_dup_block ()
static tree	lower_try_finally_fallthru_label ()
static void	honor_protect_cleanup_actions (struct leh_state *outer_state, struct leh_state *this_state, struct leh_tf_state *tf)
static void	lower_try_finally_nofallthru ()
static void	lower_try_finally_onedest ()
static void	lower_try_finally_copy ()
static void	lower_try_finally_switch ()
static bool	decide_copy_try_finally ()
static void	lower_try_finally ()
static void	lower_catch ()
static void	lower_eh_filter ()
static void	lower_cleanup ()
static void	lower_eh_constructs_1 ()
static unsigned int	lower_eh_constructs ()
static void	make_eh_edge ()
void	make_eh_edges ()
static void	mark_eh_edge ()
bool	verify_eh_edges ()
bool	tree_could_trap_p ()
bool	tree_could_throw_p ()
bool	tree_can_throw_internal ()
bool	tree_can_throw_external ()
bool	maybe_clean_or_replace_eh_stmt ()
Variables
static int	using_eh_for_cleanups_p = 0
static htab_t	finally_tree
tree_opt_pass	pass_lower_eh
static bool	mark_eh_edge_found_error

---

Define Documentation

#define verify_norecord_switch_expr (  state, switch_expr   )

Definition at line 578 of file tree-eh.c. Referenced by lower_eh_constructs_1().

---

Function Documentation

void add_stmt_to_eh_region (   )

Definition at line 124 of file tree-eh.c. References add_stmt_to_eh_region_fn(). Referenced by bsi_replace(), copy_bb(), maybe_clean_or_replace_eh_stmt(), and record_stmt_eh_region(). { add_stmt_to_eh_region_fn (cfun, t, num); }

void add_stmt_to_eh_region_fn (   )

Definition at line 95 of file tree-eh.c. References get_call_expr_in(), struct_ptr_eq(), struct_ptr_hash(), and TREE_CODE. Referenced by add_stmt_to_eh_region(), and move_block_to_fn(). { struct throw_stmt_node *n; void **slot; gcc_assert (num >= 0); gcc_assert (TREE_CODE (t) != RESX_EXPR); n = GGC_NEW (struct throw_stmt_node); n->stmt = t; n->region_nr = num; if (!get_eh_throw_stmt_table (ifun)) set_eh_throw_stmt_table (ifun, htab_create_ggc (31, struct_ptr_hash, struct_ptr_eq, ggc_free)); slot = htab_find_slot (get_eh_throw_stmt_table (ifun), n, INSERT); gcc_assert (!*slot); *slot = n; /* ??? For the benefit of calls.c, converting all this to rtl, we need to record the call expression, not just the outer modify statement. */ if (TREE_CODE (t) == MODIFY_EXPR && (t = get_call_expr_in (t))) add_stmt_to_eh_region_fn (ifun, t, num); }

static void collect_finally_tree (   )  [static]

Definition at line 216 of file tree-eh.c. References CATCH_BODY, EH_FILTER_FAILURE, LABEL_EXPR_LABEL, record_in_finally_tree(), TREE_CODE, TREE_OPERAND, tsi_end_p(), tsi_next(), tsi_start(), and tsi_stmt(). Referenced by lower_eh_constructs(), and lower_try_finally_dup_block(). { tailrecurse: switch (TREE_CODE (t)) { case LABEL_EXPR: record_in_finally_tree (LABEL_EXPR_LABEL (t), region); break; case TRY_FINALLY_EXPR: record_in_finally_tree (t, region); collect_finally_tree (TREE_OPERAND (t, 0), t); t = TREE_OPERAND (t, 1); goto tailrecurse; case TRY_CATCH_EXPR: collect_finally_tree (TREE_OPERAND (t, 0), region); t = TREE_OPERAND (t, 1); goto tailrecurse; case CATCH_EXPR: t = CATCH_BODY (t); goto tailrecurse; case EH_FILTER_EXPR: t = EH_FILTER_FAILURE (t); goto tailrecurse; case STATEMENT_LIST: { tree_stmt_iterator i; for (i = tsi_start (t); !tsi_end_p (i); tsi_next (&i)) collect_finally_tree (tsi_stmt (i), region); } break; default: /* A type, a decl, or some kind of statement that we're not interested in. Don't walk them. */ break; } }

static bool decide_copy_try_finally (   )  [static]

Decide whether or not we are going to duplicate the finally block. There are several considerations. First, if this is Java, then the finally block contains code written by the user. It has line numbers associated with it, so duplicating the block means it's difficult to set a breakpoint. Since controlling code generation via -g is verboten, we simply never duplicate code without optimization. Second, we'd like to prevent egregious code growth. One way to do this is to estimate the size of the finally block, multiply that by the number of copies we'd need to make, and compare against the estimate of the size of the switch machinery we'd have to add. Definition at line 1315 of file tree-eh.c. References estimate_num_insns(). Referenced by lower_try_finally(). { int f_estimate, sw_estimate; if (!optimize) return false; /* Finally estimate N times, plus N gotos. */ f_estimate = estimate_num_insns (finally); f_estimate = (f_estimate + 1) * ndests; /* Switch statement (cost 10), N variable assignments, N gotos. */ sw_estimate = 10 + 2 * ndests; /* Optimize for size clearly wants our best guess. */ if (optimize_size) return f_estimate < sw_estimate; /* ??? These numbers are completely made up so far. */ if (optimize > 1) return f_estimate < 100 || f_estimate < sw_estimate * 2; else return f_estimate < 40 || f_estimate * 2 < sw_estimate * 3; }

static void do_goto_redirection (   )  [static]

Similar, but easier, for GOTO_EXPR. Definition at line 679 of file tree-eh.c. References append_to_statement_list(), build1, and void_type_node. Referenced by lower_try_finally_copy(), lower_try_finally_nofallthru(), and lower_try_finally_onedest(). { tree x; q->cont_stmt = q->stmt; if (mod) append_to_statement_list (mod, &q->repl_stmt); x = build1 (GOTO_EXPR, void_type_node, finlab); append_to_statement_list (x, &q->repl_stmt); }

static void do_return_redirection (  struct goto_queue_node *  q, tree  finlab, tree  mod, tree *  return_value_p )  [static]

Redirect a RETURN_EXPR pointed to by STMT_P to FINLAB. Place in CONT_P whatever is needed to finish the return. If MOD is non-null, insert it before the new branch. RETURN_VALUE_P is a cache containing a temporary variable to be used in manipulating the value returned from the function. Definition at line 587 of file tree-eh.c. References aggregate_value_p(), append_to_statement_list(), build1, build2, create_tmp_var, current_function_decl, TREE_CODE, TREE_OPERAND, TREE_TYPE, and void_type_node. Referenced by lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), and lower_try_finally_switch(). { tree ret_expr = TREE_OPERAND (q->stmt, 0); tree x; if (ret_expr) { /* The nasty part about redirecting the return value is that the return value itself is to be computed before the FINALLY block is executed. e.g. int x; int foo (void) { x = 0; try { return x; } finally { x++; } } should return 0, not 1. Arrange for this to happen by copying computed the return value into a local temporary. This also allows us to redirect multiple return statements through the same destination block; whether this is a net win or not really depends, I guess, but it does make generation of the switch in lower_try_finally_switch easier. */ switch (TREE_CODE (ret_expr)) { case RESULT_DECL: if (!*return_value_p) *return_value_p = ret_expr; else gcc_assert (*return_value_p == ret_expr); q->cont_stmt = q->stmt; break; case MODIFY_EXPR: { tree result = TREE_OPERAND (ret_expr, 0); tree new, old = TREE_OPERAND (ret_expr, 1); if (!*return_value_p) { if (aggregate_value_p (TREE_TYPE (result), TREE_TYPE (current_function_decl))) /* If this function returns in memory, copy the argument into the return slot now. Otherwise, we might need to worry about magic return semantics, so we need to use a temporary to hold the value until we're actually ready to return. */ new = result; else new = create_tmp_var (TREE_TYPE (old), "rettmp"); *return_value_p = new; } else new = *return_value_p; x = build2 (MODIFY_EXPR, TREE_TYPE (new), new, old); append_to_statement_list (x, &q->repl_stmt); if (new == result) x = result; else x = build2 (MODIFY_EXPR, TREE_TYPE (result), result, new); q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x); } default: gcc_unreachable (); } } else { /* If we don't return a value, all return statements are the same. */ q->cont_stmt = q->stmt; } if (mod) append_to_statement_list (mod, &q->repl_stmt); x = build1 (GOTO_EXPR, void_type_node, finlab); append_to_statement_list (x, &q->repl_stmt); }

static tree find_goto_replacement (   )  [static]

Search for STMT in the goto queue. Return the replacement, or null if the statement isn't in the queue. Definition at line 369 of file tree-eh.c. References leh_tf_state::goto_queue, leh_tf_state::goto_queue_active, and goto_queue_cmp(). Referenced by replace_goto_queue_1(), and replace_goto_queue_cond_clause(). { struct goto_queue_node tmp, *ret; tmp.stmt = stmt; ret = (struct goto_queue_node *) bsearch (&tmp, tf->goto_queue, tf->goto_queue_active, sizeof (struct goto_queue_node), goto_queue_cmp); return (ret ? ret->repl_stmt : NULL); }

static void frob_into_branch_around (   )  [static]

We want to transform try { body; } catch { stuff; } to body; goto over; lab: stuff; over: T is a TRY_FINALLY or TRY_CATCH node. LAB is the label that should be placed before the second operand, or NULL. OVER is an existing label that should be put at the exit, or NULL. Definition at line 701 of file tree-eh.c. References append_to_statement_list(), block_may_fallthru(), build1, create_artificial_label(), TREE_OPERAND, and void_type_node. Referenced by lower_cleanup(), and lower_eh_filter(). { tree x, op1; op1 = TREE_OPERAND (*tp, 1); *tp = TREE_OPERAND (*tp, 0); if (block_may_fallthru (*tp)) { if (!over) over = create_artificial_label (); x = build1 (GOTO_EXPR, void_type_node, over); append_to_statement_list (x, tp); } if (lab) { x = build1 (LABEL_EXPR, void_type_node, lab); append_to_statement_list (x, tp); } append_to_statement_list (op1, tp); if (over) { x = build1 (LABEL_EXPR, void_type_node, over); append_to_statement_list (x, tp); } }

static int goto_queue_cmp (   )  [static]

Comparison function for qsort/bsearch. We're interested in searching goto queue elements for source statements. Definition at line 358 of file tree-eh.c. Referenced by find_goto_replacement(), and lower_try_finally(). { tree a = ((const struct goto_queue_node *)x)->stmt; tree b = ((const struct goto_queue_node *)y)->stmt; return (a == b ? 0 : a < b ? -1 : 1); }

static void honor_protect_cleanup_actions (  struct leh_state *  outer_state, struct leh_state *  this_state, struct leh_tf_state *  tf )  [static]

A subroutine of lower_try_finally. If lang_protect_cleanup_actions returns non-null, then the language requires that the exception path out of a try_finally be treated specially. To wit: the code within the finally block may not itself throw an exception. We have two choices here. First we can duplicate the finally block and wrap it in a must_not_throw region. Second, we can generate code like try { finally_block; } catch { if (fintmp == eh_edge) protect_cleanup_actions; } where "fintmp" is the temporary used in the switch statement generation alternative considered below. For the nonce, we always choose the first option. THIS_STATE may be null if this is a try-cleanup, not a try-finally. Definition at line 787 of file tree-eh.c. References append_to_statement_list(), block_may_fallthru(), build0, build1, build2, build_resx(), create_tmp_var, EH_FILTER_FAILURE, EH_FILTER_MUST_NOT_THROW, integer_type_node, lower_eh_constructs_1(), lower_eh_filter(), lower_try_finally_dup_block(), lower_try_finally_fallthru_label(), maybe_record_in_goto_queue(), ptr_type_node, leh_tf_state::region, leh_tf_state::top_p, TREE_OPERAND, TSI_CONTINUE_LINKING, tsi_last(), tsi_link_after(), tsi_link_before(), tsi_start(), and void_type_node. Referenced by lower_cleanup(), and lower_try_finally(). { tree protect_cleanup_actions, finally, x; tree_stmt_iterator i; bool finally_may_fallthru; /* First check for nothing to do. */ if (lang_protect_cleanup_actions) protect_cleanup_actions = lang_protect_cleanup_actions (); else protect_cleanup_actions = NULL; finally = TREE_OPERAND (*tf->top_p, 1); /* If the EH case of the finally block can fall through, this may be a structure of the form try { try { throw ...; } cleanup { try { throw ...; } catch (...) { } } } catch (...) { yyy; } E.g. with an inline destructor with an embedded try block. In this case we must save the runtime EH data around the nested exception. This complication means that any time the previous runtime data might be used (via fallthru from the finally) we handle the eh case here, whether or not protect_cleanup_actions is active. */ finally_may_fallthru = block_may_fallthru (finally); if (!finally_may_fallthru && !protect_cleanup_actions) return; /* Duplicate the FINALLY block. Only need to do this for try-finally, and not for cleanups. */ if (this_state) finally = lower_try_finally_dup_block (finally, outer_state); /* Resume execution after the exception. Adding this now lets lower_eh_filter not add unnecessary gotos, as it is clear that we never fallthru from this copy of the finally block. */ if (finally_may_fallthru) { tree save_eptr, save_filt; save_eptr = create_tmp_var (ptr_type_node, "save_eptr"); save_filt = create_tmp_var (integer_type_node, "save_filt"); i = tsi_start (finally); x = build0 (EXC_PTR_EXPR, ptr_type_node); x = build2 (MODIFY_EXPR, void_type_node, save_eptr, x); tsi_link_before (&i, x, TSI_CONTINUE_LINKING); x = build0 (FILTER_EXPR, integer_type_node); x = build2 (MODIFY_EXPR, void_type_node, save_filt, x); tsi_link_before (&i, x, TSI_CONTINUE_LINKING); i = tsi_last (finally); x = build0 (EXC_PTR_EXPR, ptr_type_node); x = build2 (MODIFY_EXPR, void_type_node, x, save_eptr); tsi_link_after (&i, x, TSI_CONTINUE_LINKING); x = build0 (FILTER_EXPR, integer_type_node); x = build2 (MODIFY_EXPR, void_type_node, x, save_filt); tsi_link_after (&i, x, TSI_CONTINUE_LINKING); x = build_resx (get_eh_region_number (tf->region)); tsi_link_after (&i, x, TSI_CONTINUE_LINKING); } /* Wrap the block with protect_cleanup_actions as the action. */ if (protect_cleanup_actions) { x = build2 (EH_FILTER_EXPR, void_type_node, NULL, NULL); append_to_statement_list (protect_cleanup_actions, &EH_FILTER_FAILURE (x)); EH_FILTER_MUST_NOT_THROW (x) = 1; finally = build2 (TRY_CATCH_EXPR, void_type_node, finally, x); lower_eh_filter (outer_state, &finally); } else lower_eh_constructs_1 (outer_state, &finally); /* Hook this up to the end of the existing try block. If we previously fell through the end, we'll have to branch around. This means adding a new goto, and adding it to the queue. */ i = tsi_last (TREE_OPERAND (*tf->top_p, 0)); if (tf->may_fallthru) { x = lower_try_finally_fallthru_label (tf); x = build1 (GOTO_EXPR, void_type_node, x); tsi_link_after (&i, x, TSI_CONTINUE_LINKING); if (this_state) maybe_record_in_goto_queue (this_state, x); tf->may_fallthru = false; } x = build1 (LABEL_EXPR, void_type_node, tf->eh_label); tsi_link_after (&i, x, TSI_CONTINUE_LINKING); tsi_link_after (&i, finally, TSI_CONTINUE_LINKING); /* Having now been handled, EH isn't to be considered with the rest of the outgoing edges. */ tf->may_throw = false; }

int lookup_stmt_eh_region (   )

Definition at line 178 of file tree-eh.c. References lookup_stmt_eh_region_fn(). Referenced by bsi_replace(), execute_fixup_cfg(), expand_call_inline(), make_eh_edges(), maybe_clean_or_replace_eh_stmt(), move_block_to_fn(), tree_can_throw_external(), tree_can_throw_internal(), verify_eh_edges(), and verify_stmt(). { /* We can get called from initialized data when -fnon-call-exceptions is on; prevent crash. */ if (!cfun) return -1; return lookup_stmt_eh_region_fn (cfun, t); }

int lookup_stmt_eh_region_fn (   )

Definition at line 163 of file tree-eh.c. Referenced by copy_bb(), find_outermost_region_in_block(), and lookup_stmt_eh_region(). { struct throw_stmt_node *p, n; if (!get_eh_throw_stmt_table (ifun)) return -2; n.stmt = t; p = (struct throw_stmt_node *) htab_find (get_eh_throw_stmt_table (ifun), &n); return (p ? p->region_nr : -1); }

static void lower_catch (   )  [static]

A subroutine of lower_eh_constructs_1. Lower a TRY_CATCH_EXPR with a list of CATCH_EXPR nodes to a sequence of labels and blocks, plus the exception region trees that record all the magic. Definition at line 1434 of file tree-eh.c. References append_to_statement_list(), block_may_fallthru(), build1, CATCH_BODY, CATCH_TYPES, create_artificial_label(), leh_state::cur_region, lower_eh_constructs_1(), leh_state::prev_try, leh_state::tf, TREE_OPERAND, tsi_delink(), tsi_end_p(), tsi_link_before(), TSI_SAME_STMT, tsi_start(), tsi_stmt(), and void_type_node. Referenced by lower_eh_constructs_1(). { struct eh_region *try_region; struct leh_state this_state; tree_stmt_iterator i; tree out_label; try_region = gen_eh_region_try (state->cur_region); this_state.cur_region = try_region; this_state.prev_try = try_region; this_state.tf = state->tf; lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0)); if (!get_eh_region_may_contain_throw (try_region)) { *tp = TREE_OPERAND (*tp, 0); return; } out_label = NULL; for (i = tsi_start (TREE_OPERAND (*tp, 1)); !tsi_end_p (i); ) { struct eh_region *catch_region; tree catch, x, eh_label; catch = tsi_stmt (i); catch_region = gen_eh_region_catch (try_region, CATCH_TYPES (catch)); this_state.cur_region = catch_region; this_state.prev_try = state->prev_try; lower_eh_constructs_1 (&this_state, &CATCH_BODY (catch)); eh_label = create_artificial_label (); set_eh_region_tree_label (catch_region, eh_label); x = build1 (LABEL_EXPR, void_type_node, eh_label); tsi_link_before (&i, x, TSI_SAME_STMT); if (block_may_fallthru (CATCH_BODY (catch))) { if (!out_label) out_label = create_artificial_label (); x = build1 (GOTO_EXPR, void_type_node, out_label); append_to_statement_list (x, &CATCH_BODY (catch)); } tsi_link_before (&i, CATCH_BODY (catch), TSI_SAME_STMT); tsi_delink (&i); } frob_into_branch_around (tp, NULL, out_label); }

static void lower_cleanup (   )  [static]

Implement a cleanup expression. This is similar to try-finally, except that we only execute the cleanup block for exception edges. Definition at line 1530 of file tree-eh.c. References append_to_statement_list(), block_may_fallthru(), build1, create_artificial_label(), leh_state::cur_region, frob_into_branch_around(), honor_protect_cleanup_actions(), lower_eh_constructs_1(), leh_state::prev_try, TREE_OPERAND, and void_type_node. Referenced by lower_eh_constructs_1(). { struct leh_state this_state; struct eh_region *this_region; struct leh_tf_state fake_tf; /* If not using eh, then exception-only cleanups are no-ops. */ if (!flag_exceptions) { *tp = TREE_OPERAND (*tp, 0); lower_eh_constructs_1 (state, tp); return; } this_region = gen_eh_region_cleanup (state->cur_region, state->prev_try); this_state = *state; this_state.cur_region = this_region; lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0)); if (!get_eh_region_may_contain_throw (this_region)) { *tp = TREE_OPERAND (*tp, 0); return; } /* Build enough of a try-finally state so that we can reuse honor_protect_cleanup_actions. */ memset (&fake_tf, 0, sizeof (fake_tf)); fake_tf.top_p = tp; fake_tf.outer = state; fake_tf.region = this_region; fake_tf.may_fallthru = block_may_fallthru (TREE_OPERAND (*tp, 0)); fake_tf.may_throw = true; fake_tf.eh_label = create_artificial_label (); set_eh_region_tree_label (this_region, fake_tf.eh_label); honor_protect_cleanup_actions (state, NULL, &fake_tf); if (fake_tf.may_throw) { /* In this case honor_protect_cleanup_actions had nothing to do, and we should process this normally. */ lower_eh_constructs_1 (state, &TREE_OPERAND (*tp, 1)); frob_into_branch_around (tp, fake_tf.eh_label, fake_tf.fallthru_label); } else { /* In this case honor_protect_cleanup_actions did nearly all of the work. All we have left is to append the fallthru_label. */ *tp = TREE_OPERAND (*tp, 0); if (fake_tf.fallthru_label) { tree x = build1 (LABEL_EXPR, void_type_node, fake_tf.fallthru_label); append_to_statement_list (x, tp); } } }

static unsigned int lower_eh_constructs (   )  [static]

Definition at line 1675 of file tree-eh.c. References collect_finally_tree(), current_function_decl, DECL_SAVED_TREE, finally_tree, lower_eh_constructs_1(), struct_ptr_eq(), and struct_ptr_hash(). { struct leh_state null_state; tree *tp = &DECL_SAVED_TREE (current_function_decl); finally_tree = htab_create (31, struct_ptr_hash, struct_ptr_eq, free); collect_finally_tree (*tp, NULL); memset (&null_state, 0, sizeof (null_state)); lower_eh_constructs_1 (&null_state, tp); htab_delete (finally_tree); collect_eh_region_array (); return 0; }

static void lower_eh_constructs_1 (   )  [static]

Main loop for lowering eh constructs. Definition at line 1594 of file tree-eh.c. References COND_EXPR_ELSE, COND_EXPR_THEN, lower_catch(), lower_cleanup(), lower_eh_constructs_1(), lower_eh_filter(), lower_try_finally(), maybe_record_in_goto_queue(), record_stmt_eh_region(), TREE_CODE, tree_could_throw_p(), TREE_OPERAND, tsi_delink(), tsi_end_p(), tsi_link_before(), tsi_next(), TSI_SAME_STMT, tsi_start(), tsi_stmt(), tsi_stmt_ptr(), and verify_norecord_switch_expr. { tree_stmt_iterator i; tree t = *tp; switch (TREE_CODE (t)) { case COND_EXPR: lower_eh_constructs_1 (state, &COND_EXPR_THEN (t)); lower_eh_constructs_1 (state, &COND_EXPR_ELSE (t)); break; case CALL_EXPR: /* Look for things that can throw exceptions, and record them. */ if (state->cur_region && tree_could_throw_p (t)) { record_stmt_eh_region (state->cur_region, t); note_eh_region_may_contain_throw (state->cur_region); } break; case MODIFY_EXPR: /* Look for things that can throw exceptions, and record them. */ if (state->cur_region && tree_could_throw_p (t)) { record_stmt_eh_region (state->cur_region, t); note_eh_region_may_contain_throw (state->cur_region); } break; case GOTO_EXPR: case RETURN_EXPR: maybe_record_in_goto_queue (state, t); break; case SWITCH_EXPR: verify_norecord_switch_expr (state, t); break; case TRY_FINALLY_EXPR: lower_try_finally (state, tp); break; case TRY_CATCH_EXPR: i = tsi_start (TREE_OPERAND (t, 1)); switch (TREE_CODE (tsi_stmt (i))) { case CATCH_EXPR: lower_catch (state, tp); break; case EH_FILTER_EXPR: lower_eh_filter (state, tp); break; default: lower_cleanup (state, tp); break; } break; case STATEMENT_LIST: for (i = tsi_start (t); !tsi_end_p (i); ) { lower_eh_constructs_1 (state, tsi_stmt_ptr (i)); t = tsi_stmt (i); if (TREE_CODE (t) == STATEMENT_LIST) { tsi_link_before (&i, t, TSI_SAME_STMT); tsi_delink (&i); } else tsi_next (&i); } break; default: /* A type, a decl, or some kind of statement that we're not interested in. Don't walk them. */ break; } }

static void lower_eh_constructs_1 (  struct leh_state *  , tree *  )  [static]

Referenced by honor_protect_cleanup_actions(), lower_catch(), lower_cleanup(), lower_eh_constructs(), lower_eh_constructs_1(), lower_eh_filter(), lower_try_finally(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), and lower_try_finally_switch().

static void lower_eh_filter (   )  [static]

A subroutine of lower_eh_constructs_1. Lower a TRY_CATCH_EXPR with a EH_FILTER_EXPR to a sequence of labels and blocks, plus the exception region trees that record all the magic. Definition at line 1494 of file tree-eh.c. References create_artificial_label(), leh_state::cur_region, EH_FILTER_FAILURE, EH_FILTER_MUST_NOT_THROW, EH_FILTER_TYPES, expr_first(), frob_into_branch_around(), lower_eh_constructs_1(), and TREE_OPERAND. { struct leh_state this_state; struct eh_region *this_region; tree inner = expr_first (TREE_OPERAND (*tp, 1)); tree eh_label; if (EH_FILTER_MUST_NOT_THROW (inner)) this_region = gen_eh_region_must_not_throw (state->cur_region); else this_region = gen_eh_region_allowed (state->cur_region, EH_FILTER_TYPES (inner)); this_state = *state; this_state.cur_region = this_region; lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0)); if (!get_eh_region_may_contain_throw (this_region)) { *tp = TREE_OPERAND (*tp, 0); return; } lower_eh_constructs_1 (state, &EH_FILTER_FAILURE (inner)); TREE_OPERAND (*tp, 1) = EH_FILTER_FAILURE (inner); eh_label = create_artificial_label (); set_eh_region_tree_label (this_region, eh_label); frob_into_branch_around (tp, eh_label, NULL); }

static void lower_eh_filter (  struct leh_state *  , tree *  )  [static]

Referenced by honor_protect_cleanup_actions(), and lower_eh_constructs_1().

static void lower_try_finally (   )  [static]

A subroutine of lower_eh_constructs_1. Lower a TRY_FINALLY_EXPR nodes to a sequence of labels and blocks, plus the exception region trees that record all the magic. This is complicated by the need to arrange for the FINALLY block to be executed on all exits. Definition at line 1346 of file tree-eh.c. References append_to_statement_list(), block_may_fallthru(), build1, create_artificial_label(), leh_state::cur_region, decide_copy_try_finally(), goto_queue_cmp(), honor_protect_cleanup_actions(), lower_eh_constructs_1(), lower_try_finally_copy(), lower_try_finally_nofallthru(), lower_try_finally_onedest(), lower_try_finally_switch(), leh_state::prev_try, leh_state::tf, TREE_OPERAND, using_eh_for_cleanups_p, and void_type_node. Referenced by lower_eh_constructs_1(). { struct leh_tf_state this_tf; struct leh_state this_state; int ndests; /* Process the try block. */ memset (&this_tf, 0, sizeof (this_tf)); this_tf.try_finally_expr = *tp; this_tf.top_p = tp; this_tf.outer = state; if (using_eh_for_cleanups_p) this_tf.region = gen_eh_region_cleanup (state->cur_region, state->prev_try); else this_tf.region = NULL; this_state.cur_region = this_tf.region; this_state.prev_try = state->prev_try; this_state.tf = &this_tf; lower_eh_constructs_1 (&this_state, &TREE_OPERAND (*tp, 0)); /* Determine if the try block is escaped through the bottom. */ this_tf.may_fallthru = block_may_fallthru (TREE_OPERAND (*tp, 0)); /* Determine if any exceptions are possible within the try block. */ if (using_eh_for_cleanups_p) this_tf.may_throw = get_eh_region_may_contain_throw (this_tf.region); if (this_tf.may_throw) { this_tf.eh_label = create_artificial_label (); set_eh_region_tree_label (this_tf.region, this_tf.eh_label); honor_protect_cleanup_actions (state, &this_state, &this_tf); } /* Sort the goto queue for efficient searching later. */ if (this_tf.goto_queue_active > 1) qsort (this_tf.goto_queue, this_tf.goto_queue_active, sizeof (struct goto_queue_node), goto_queue_cmp); /* Determine how many edges (still) reach the finally block. Or rather, how many destinations are reached by the finally block. Use this to determine how we process the finally block itself. */ ndests = VEC_length (tree, this_tf.dest_array); ndests += this_tf.may_fallthru; ndests += this_tf.may_return; ndests += this_tf.may_throw; /* If the FINALLY block is not reachable, dike it out. */ if (ndests == 0) *tp = TREE_OPERAND (*tp, 0); /* If the finally block doesn't fall through, then any destination we might try to impose there isn't reached either. There may be some minor amount of cleanup and redirection still needed. */ else if (!block_may_fallthru (TREE_OPERAND (*tp, 1))) lower_try_finally_nofallthru (state, &this_tf); /* We can easily special-case redirection to a single destination. */ else if (ndests == 1) lower_try_finally_onedest (state, &this_tf); else if (decide_copy_try_finally (ndests, TREE_OPERAND (*tp, 1))) lower_try_finally_copy (state, &this_tf); else lower_try_finally_switch (state, &this_tf); /* If someone requested we add a label at the end of the transformed block, do so. */ if (this_tf.fallthru_label) { tree x = build1 (LABEL_EXPR, void_type_node, this_tf.fallthru_label); append_to_statement_list (x, tp); } VEC_free (tree, heap, this_tf.dest_array); if (this_tf.goto_queue) free (this_tf.goto_queue); }