/* Exception handling semantics and decomposition for trees.
- Copyright (C) 2003-2014 Free Software Foundation, Inc.
+ Copyright (C) 2003-2015 Free Software Foundation, Inc.
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "hash-table.h"
-#include "tm.h"
+#include "backend.h"
+#include "target.h"
+#include "rtl.h"
#include "tree.h"
-#include "expr.h"
-#include "calls.h"
+#include "gimple.h"
+#include "cfghooks.h"
+#include "tree-pass.h"
+#include "ssa.h"
+#include "expmed.h"
+#include "insn-config.h"
+#include "emit-rtl.h"
+#include "cgraph.h"
+#include "diagnostic-core.h"
+#include "alias.h"
+#include "fold-const.h"
#include "flags.h"
-#include "function.h"
+#include "dojump.h"
+#include "explow.h"
+#include "calls.h"
+#include "varasm.h"
+#include "stmt.h"
+#include "expr.h"
#include "except.h"
-#include "hash-set.h"
-#include "basic-block.h"
-#include "tree-ssa-alias.h"
+#include "cfganal.h"
+#include "cfgcleanup.h"
#include "internal-fn.h"
#include "tree-eh.h"
-#include "gimple-expr.h"
-#include "is-a.h"
-#include "gimple.h"
#include "gimple-iterator.h"
-#include "gimple-ssa.h"
-#include "cgraph.h"
#include "tree-cfg.h"
-#include "tree-phinodes.h"
-#include "ssa-iterators.h"
-#include "stringpool.h"
-#include "tree-ssanames.h"
#include "tree-into-ssa.h"
#include "tree-ssa.h"
#include "tree-inline.h"
-#include "tree-pass.h"
#include "langhooks.h"
-#include "diagnostic-core.h"
-#include "target.h"
#include "cfgloop.h"
#include "gimple-low.h"
/* In some instances a tree and a gimple need to be stored in a same table,
i.e. in hash tables. This is a structure to do this. */
-typedef union {tree *tp; tree t; gimple g;} treemple;
+typedef union {tree *tp; tree t; gimple *g;} treemple;
/* Misc functions used in this file. */
/* Add statement T in function IFUN to landing pad NUM. */
static void
-add_stmt_to_eh_lp_fn (struct function *ifun, gimple t, int num)
+add_stmt_to_eh_lp_fn (struct function *ifun, gimple *t, int num)
{
gcc_assert (num != 0);
if (!get_eh_throw_stmt_table (ifun))
- set_eh_throw_stmt_table (ifun, hash_map<gimple, int>::create_ggc (31));
+ set_eh_throw_stmt_table (ifun, hash_map<gimple *, int>::create_ggc (31));
gcc_assert (!get_eh_throw_stmt_table (ifun)->put (t, num));
}
/* Add statement T in the current function (cfun) to EH landing pad NUM. */
void
-add_stmt_to_eh_lp (gimple t, int num)
+add_stmt_to_eh_lp (gimple *t, int num)
{
add_stmt_to_eh_lp_fn (cfun, t, num);
}
/* Add statement T to the single EH landing pad in REGION. */
static void
-record_stmt_eh_region (eh_region region, gimple t)
+record_stmt_eh_region (eh_region region, gimple *t)
{
if (region == NULL)
return;
/* Remove statement T in function IFUN from its EH landing pad. */
bool
-remove_stmt_from_eh_lp_fn (struct function *ifun, gimple t)
+remove_stmt_from_eh_lp_fn (struct function *ifun, gimple *t)
{
if (!get_eh_throw_stmt_table (ifun))
return false;
EH landing pad. */
bool
-remove_stmt_from_eh_lp (gimple t)
+remove_stmt_from_eh_lp (gimple *t)
{
return remove_stmt_from_eh_lp_fn (cfun, t);
}
statement is not recorded in the region table. */
int
-lookup_stmt_eh_lp_fn (struct function *ifun, gimple t)
+lookup_stmt_eh_lp_fn (struct function *ifun, gimple *t)
{
if (ifun->eh->throw_stmt_table == NULL)
return 0;
/* Likewise, but always use the current function. */
int
-lookup_stmt_eh_lp (gimple t)
+lookup_stmt_eh_lp (gimple *t)
{
/* We can get called from initialized data when -fnon-call-exceptions
is on; prevent crash. */
tree) leaves the TRY block, its necessary to record a tree in
this field. Thus a treemple is used. */
treemple child;
- gimple parent;
+ gtry *parent;
};
/* Hashtable helpers. */
-struct finally_tree_hasher : typed_free_remove <finally_tree_node>
+struct finally_tree_hasher : free_ptr_hash <finally_tree_node>
{
- typedef finally_tree_node value_type;
- typedef finally_tree_node compare_type;
- static inline hashval_t hash (const value_type *);
- static inline bool equal (const value_type *, const compare_type *);
+ static inline hashval_t hash (const finally_tree_node *);
+ static inline bool equal (const finally_tree_node *,
+ const finally_tree_node *);
};
inline hashval_t
-finally_tree_hasher::hash (const value_type *v)
+finally_tree_hasher::hash (const finally_tree_node *v)
{
return (intptr_t)v->child.t >> 4;
}
inline bool
-finally_tree_hasher::equal (const value_type *v, const compare_type *c)
+finally_tree_hasher::equal (const finally_tree_node *v,
+ const finally_tree_node *c)
{
return v->child.t == c->child.t;
}
static hash_table<finally_tree_hasher> *finally_tree;
static void
-record_in_finally_tree (treemple child, gimple parent)
+record_in_finally_tree (treemple child, gtry *parent)
{
struct finally_tree_node *n;
finally_tree_node **slot;
}
static void
-collect_finally_tree (gimple stmt, gimple region);
+collect_finally_tree (gimple *stmt, gtry *region);
/* Go through the gimple sequence. Works with collect_finally_tree to
record all GIMPLE_LABEL and GIMPLE_TRY statements. */
static void
-collect_finally_tree_1 (gimple_seq seq, gimple region)
+collect_finally_tree_1 (gimple_seq seq, gtry *region)
{
gimple_stmt_iterator gsi;
}
static void
-collect_finally_tree (gimple stmt, gimple region)
+collect_finally_tree (gimple *stmt, gtry *region)
{
treemple temp;
switch (gimple_code (stmt))
{
case GIMPLE_LABEL:
- temp.t = gimple_label_label (stmt);
+ temp.t = gimple_label_label (as_a <glabel *> (stmt));
record_in_finally_tree (temp, region);
break;
{
temp.g = stmt;
record_in_finally_tree (temp, region);
- collect_finally_tree_1 (gimple_try_eval (stmt), stmt);
+ collect_finally_tree_1 (gimple_try_eval (stmt),
+ as_a <gtry *> (stmt));
collect_finally_tree_1 (gimple_try_cleanup (stmt), region);
}
else if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
break;
case GIMPLE_CATCH:
- collect_finally_tree_1 (gimple_catch_handler (stmt), region);
+ collect_finally_tree_1 (gimple_catch_handler (
+ as_a <gcatch *> (stmt)),
+ region);
break;
case GIMPLE_EH_FILTER:
break;
case GIMPLE_EH_ELSE:
- collect_finally_tree_1 (gimple_eh_else_n_body (stmt), region);
- collect_finally_tree_1 (gimple_eh_else_e_body (stmt), region);
+ {
+ geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
+ collect_finally_tree_1 (gimple_eh_else_n_body (eh_else_stmt), region);
+ collect_finally_tree_1 (gimple_eh_else_e_body (eh_else_stmt), region);
+ }
break;
default:
would leave the try_finally node that START lives in. */
static bool
-outside_finally_tree (treemple start, gimple target)
+outside_finally_tree (treemple start, gimple *target)
{
struct finally_tree_node n, *p;
indexed by EH region number. */
static bitmap eh_region_may_contain_throw_map;
-/* The GOTO_QUEUE is is an array of GIMPLE_GOTO and GIMPLE_RETURN
+/* The GOTO_QUEUE is an array of GIMPLE_GOTO and GIMPLE_RETURN
statements that are seen to escape this GIMPLE_TRY_FINALLY node.
The idea is to record a gimple statement for everything except for
the conditionals, which get their labels recorded. Since labels are
treemple stmt;
location_t location;
gimple_seq repl_stmt;
- gimple cont_stmt;
+ gimple *cont_stmt;
int index;
/* This is used when index >= 0 to indicate that stmt is a label (as
opposed to a goto stmt). */
try_finally_expr is the original GIMPLE_TRY_FINALLY. We need to retain
this so that outside_finally_tree can reliably reference the tree used
in the collect_finally_tree data structures. */
- gimple try_finally_expr;
- gimple top_p;
+ gtry *try_finally_expr;
+ gtry *top_p;
/* While lowering a top_p usually it is expanded into multiple statements,
thus we need the following field to store them. */
size_t goto_queue_active;
/* Pointer map to help in searching goto_queue when it is large. */
- hash_map<gimple, goto_queue_node *> *goto_queue_map;
+ hash_map<gimple *, goto_queue_node *> *goto_queue_map;
/* The set of unique labels seen as entries in the goto queue. */
vec<tree> dest_array;
bool may_throw;
};
-static gimple_seq lower_eh_must_not_throw (struct leh_state *, gimple);
+static gimple_seq lower_eh_must_not_throw (struct leh_state *, gtry *);
/* Search for STMT in the goto queue. Return the replacement,
or null if the statement isn't in the queue. */
if (!tf->goto_queue_map)
{
- tf->goto_queue_map = new hash_map<gimple, goto_queue_node *>;
+ tf->goto_queue_map = new hash_map<gimple *, goto_queue_node *>;
for (i = 0; i < tf->goto_queue_active; i++)
{
bool existed = tf->goto_queue_map->put (tf->goto_queue[i].stmt.g,
static void replace_goto_queue_stmt_list (gimple_seq *, struct leh_tf_state *);
static void
-replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
+replace_goto_queue_1 (gimple *stmt, struct leh_tf_state *tf,
gimple_stmt_iterator *gsi)
{
gimple_seq seq;
replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt), tf);
break;
case GIMPLE_CATCH:
- replace_goto_queue_stmt_list (gimple_catch_handler_ptr (stmt), tf);
+ replace_goto_queue_stmt_list (gimple_catch_handler_ptr (
+ as_a <gcatch *> (stmt)),
+ tf);
break;
case GIMPLE_EH_FILTER:
replace_goto_queue_stmt_list (gimple_eh_filter_failure_ptr (stmt), tf);
break;
case GIMPLE_EH_ELSE:
- replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (stmt), tf);
- replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (stmt), tf);
+ {
+ geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
+ replace_goto_queue_stmt_list (gimple_eh_else_n_body_ptr (eh_else_stmt),
+ tf);
+ replace_goto_queue_stmt_list (gimple_eh_else_e_body_ptr (eh_else_stmt),
+ tf);
+ }
break;
default:
try_finally node. */
static void
-maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
+maybe_record_in_goto_queue (struct leh_state *state, gimple *stmt)
{
struct leh_tf_state *tf = state->tf;
treemple new_stmt;
switch (gimple_code (stmt))
{
case GIMPLE_COND:
- new_stmt.tp = gimple_op_ptr (stmt, 2);
- record_in_goto_queue_label (tf, new_stmt, gimple_cond_true_label (stmt),
- EXPR_LOCATION (*new_stmt.tp));
- new_stmt.tp = gimple_op_ptr (stmt, 3);
- record_in_goto_queue_label (tf, new_stmt, gimple_cond_false_label (stmt),
- EXPR_LOCATION (*new_stmt.tp));
+ {
+ gcond *cond_stmt = as_a <gcond *> (stmt);
+ new_stmt.tp = gimple_op_ptr (cond_stmt, 2);
+ record_in_goto_queue_label (tf, new_stmt,
+ gimple_cond_true_label (cond_stmt),
+ EXPR_LOCATION (*new_stmt.tp));
+ new_stmt.tp = gimple_op_ptr (cond_stmt, 3);
+ record_in_goto_queue_label (tf, new_stmt,
+ gimple_cond_false_label (cond_stmt),
+ EXPR_LOCATION (*new_stmt.tp));
+ }
break;
case GIMPLE_GOTO:
new_stmt.g = stmt;
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* We do not process GIMPLE_SWITCHes for now. As long as the original source
was in fact structured, and we've not yet done jump threading, then none
of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */
static void
-verify_norecord_switch_expr (struct leh_state *state, gimple switch_expr)
+verify_norecord_switch_expr (struct leh_state *state,
+ gswitch *switch_expr)
{
struct leh_tf_state *tf = state->tf;
size_t i, n;
static void
do_return_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod)
{
- gimple x;
+ gimple *x;
/* In the case of a return, the queue node must be a gimple statement. */
gcc_assert (!q->is_label);
do_goto_redirection (struct goto_queue_node *q, tree finlab, gimple_seq mod,
struct leh_tf_state *tf)
{
- gimple x;
+ ggoto *x;
gcc_assert (q->is_label);
emit_post_landing_pad (gimple_seq *seq, eh_region region)
{
eh_landing_pad lp = region->landing_pads;
- gimple x;
+ glabel *x;
if (lp == NULL)
lp = gen_eh_landing_pad (region);
static void
emit_resx (gimple_seq *seq, eh_region region)
{
- gimple x = gimple_build_resx (region->index);
+ gresx *x = gimple_build_resx (region->index);
gimple_seq_add_stmt (seq, x);
if (region->outer)
record_stmt_eh_region (region->outer, x);
static void
emit_eh_dispatch (gimple_seq *seq, eh_region region)
{
- gimple x = gimple_build_eh_dispatch (region->index);
+ geh_dispatch *x = gimple_build_eh_dispatch (region->index);
gimple_seq_add_stmt (seq, x);
}
/* We want to transform
try { body; } catch { stuff; }
to
- normal_seqence:
+ normal_sequence:
body;
over:
- eh_seqence:
+ eh_sequence:
landing_pad:
stuff;
goto over;
an existing label that should be put at the exit, or NULL. */
static gimple_seq
-frob_into_branch_around (gimple tp, eh_region region, tree over)
+frob_into_branch_around (gtry *tp, eh_region region, tree over)
{
- gimple x;
+ gimple *x;
gimple_seq cleanup, result;
location_t loc = gimple_location (tp);
lower_try_finally_dup_block (gimple_seq seq, struct leh_state *outer_state,
location_t loc)
{
- gimple region = NULL;
+ gtry *region = NULL;
gimple_seq new_seq;
gimple_stmt_iterator gsi;
for (gsi = gsi_start (new_seq); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
- if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION)
+ gimple *stmt = gsi_stmt (gsi);
+ /* We duplicate __builtin_stack_restore at -O0 in the hope of eliminating
+ it on the EH paths. When it is not eliminated, make it transparent in
+ the debug info. */
+ if (gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE))
+ gimple_set_location (stmt, UNKNOWN_LOCATION);
+ else if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION)
{
tree block = gimple_block (stmt);
gimple_set_location (stmt, loc);
/* A subroutine of lower_try_finally. If FINALLY consits of a
GIMPLE_EH_ELSE node, return it. */
-static inline gimple
+static inline geh_else *
get_eh_else (gimple_seq finally)
{
- gimple x = gimple_seq_first_stmt (finally);
+ gimple *x = gimple_seq_first_stmt (finally);
if (gimple_code (x) == GIMPLE_EH_ELSE)
{
gcc_assert (gimple_seq_singleton_p (finally));
- return x;
+ return as_a <geh_else *> (x);
}
return NULL;
}
gimple_stmt_iterator gsi;
bool finally_may_fallthru;
gimple_seq finally;
- gimple x, eh_else;
+ gimple *x;
+ geh_mnt *eh_mnt;
+ gtry *try_stmt;
+ geh_else *eh_else;
/* First check for nothing to do. */
if (lang_hooks.eh_protect_cleanup_actions == NULL)
}
/* Wrap the block with protect_cleanup_actions as the action. */
- x = gimple_build_eh_must_not_throw (protect_cleanup_actions);
- x = gimple_build_try (finally, gimple_seq_alloc_with_stmt (x),
- GIMPLE_TRY_CATCH);
- finally = lower_eh_must_not_throw (outer_state, x);
+ eh_mnt = gimple_build_eh_must_not_throw (protect_cleanup_actions);
+ try_stmt = gimple_build_try (finally, gimple_seq_alloc_with_stmt (eh_mnt),
+ GIMPLE_TRY_CATCH);
+ finally = lower_eh_must_not_throw (outer_state, try_stmt);
/* Drop all of this into the exception sequence. */
emit_post_landing_pad (&eh_seq, tf->region);
struct leh_tf_state *tf)
{
tree lab;
- gimple x, eh_else;
+ gimple *x;
+ geh_else *eh_else;
gimple_seq finally;
struct goto_queue_node *q, *qe;
lower_try_finally_onedest (struct leh_state *state, struct leh_tf_state *tf)
{
struct goto_queue_node *q, *qe;
- gimple x;
+ geh_else *eh_else;
+ glabel *label_stmt;
+ gimple *x;
gimple_seq finally;
gimple_stmt_iterator gsi;
tree finally_label;
/* Since there's only one destination, and the destination edge can only
either be EH or non-EH, that implies that all of our incoming edges
are of the same type. Therefore we can lower EH_ELSE immediately. */
- x = get_eh_else (finally);
- if (x)
+ eh_else = get_eh_else (finally);
+ if (eh_else)
{
if (tf->may_throw)
- finally = gimple_eh_else_e_body (x);
+ finally = gimple_eh_else_e_body (eh_else);
else
- finally = gimple_eh_else_n_body (x);
+ finally = gimple_eh_else_n_body (eh_else);
}
lower_eh_constructs_1 (state, &finally);
for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
if (LOCATION_LOCUS (gimple_location (stmt)) == UNKNOWN_LOCATION)
{
tree block = gimple_block (stmt);
}
finally_label = create_artificial_label (loc);
- x = gimple_build_label (finally_label);
- gimple_seq_add_stmt (&tf->top_p_seq, x);
+ label_stmt = gimple_build_label (finally_label);
+ gimple_seq_add_stmt (&tf->top_p_seq, label_stmt);
gimple_seq_add_seq (&tf->top_p_seq, finally);
gimple_seq finally;
gimple_seq new_stmt;
gimple_seq seq;
- gimple x, eh_else;
+ gimple *x;
+ geh_else *eh_else;
tree tmp;
location_t tf_loc = gimple_location (tf->try_finally_expr);
tree last_case;
vec<tree> case_label_vec;
gimple_seq switch_body = NULL;
- gimple x, eh_else;
+ gimple *x;
+ geh_else *eh_else;
tree tmp;
- gimple switch_stmt;
+ gimple *switch_stmt;
gimple_seq finally;
- hash_map<tree, gimple> *cont_map = NULL;
+ hash_map<tree, gimple *> *cont_map = NULL;
/* The location of the TRY_FINALLY stmt. */
location_t tf_loc = gimple_location (tf->try_finally_expr);
/* The location of the finally block. */
/* We store the cont_stmt in the pointer map, so that we can recover
it in the loop below. */
if (!cont_map)
- cont_map = new hash_map<tree, gimple>;
+ cont_map = new hash_map<tree, gimple *>;
cont_map->put (case_lab, q->cont_stmt);
case_label_vec.quick_push (case_lab);
}
}
for (j = last_case_index; j < last_case_index + nlabels; j++)
{
- gimple cont_stmt;
+ gimple *cont_stmt;
last_case = case_label_vec[j];
decide_copy_try_finally (int ndests, bool may_throw, gimple_seq finally)
{
int f_estimate, sw_estimate;
- gimple eh_else;
+ geh_else *eh_else;
/* If there's an EH_ELSE involved, the exception path is separate
and really doesn't come into play for this computation. */
for (gsi = gsi_start (finally); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
- if (!is_gimple_debug (stmt) && !gimple_clobber_p (stmt))
+ /* Duplicate __builtin_stack_restore in the hope of eliminating it
+ on the EH paths and, consequently, useless cleanups. */
+ gimple *stmt = gsi_stmt (gsi);
+ if (!is_gimple_debug (stmt)
+ && !gimple_clobber_p (stmt)
+ && !gimple_call_builtin_p (stmt, BUILT_IN_STACK_RESTORE))
return false;
}
return true;
}
/* Finally estimate N times, plus N gotos. */
- f_estimate = count_insns_seq (finally, &eni_size_weights);
+ f_estimate = estimate_num_insns_seq (finally, &eni_size_weights);
f_estimate = (f_estimate + 1) * ndests;
/* Switch statement (cost 10), N variable assignments, N gotos. */
arrange for the FINALLY block to be executed on all exits. */
static gimple_seq
-lower_try_finally (struct leh_state *state, gimple tp)
+lower_try_finally (struct leh_state *state, gtry *tp)
{
struct leh_tf_state this_tf;
struct leh_state this_state;
if (this_tf.fallthru_label)
{
/* This must be reached only if ndests == 0. */
- gimple x = gimple_build_label (this_tf.fallthru_label);
+ gimple *x = gimple_build_label (this_tf.fallthru_label);
gimple_seq_add_stmt (&this_tf.top_p_seq, x);
}
exception region trees that records all the magic. */
static gimple_seq
-lower_catch (struct leh_state *state, gimple tp)
+lower_catch (struct leh_state *state, gtry *tp)
{
eh_region try_region = NULL;
struct leh_state this_state = *state;
gimple_stmt_iterator gsi;
tree out_label;
gimple_seq new_seq, cleanup;
- gimple x;
+ gimple *x;
location_t try_catch_loc = gimple_location (tp);
if (flag_exceptions)
this_state.cur_region = state->cur_region;
this_state.ehp_region = try_region;
+ /* Add eh_seq from lowering EH in the cleanup sequence after the cleanup
+ itself, so that e.g. for coverage purposes the nested cleanups don't
+ appear before the cleanup body. See PR64634 for details. */
+ gimple_seq old_eh_seq = eh_seq;
+ eh_seq = NULL;
+
out_label = NULL;
cleanup = gimple_try_cleanup (tp);
for (gsi = gsi_start (cleanup);
gsi_next (&gsi))
{
eh_catch c;
- gimple gcatch;
+ gcatch *catch_stmt;
gimple_seq handler;
- gcatch = gsi_stmt (gsi);
- c = gen_eh_region_catch (try_region, gimple_catch_types (gcatch));
+ catch_stmt = as_a <gcatch *> (gsi_stmt (gsi));
+ c = gen_eh_region_catch (try_region, gimple_catch_types (catch_stmt));
- handler = gimple_catch_handler (gcatch);
+ handler = gimple_catch_handler (catch_stmt);
lower_eh_constructs_1 (&this_state, &handler);
c->label = create_artificial_label (UNKNOWN_LOCATION);
gimple_try_set_cleanup (tp, new_seq);
- return frob_into_branch_around (tp, try_region, out_label);
+ gimple_seq new_eh_seq = eh_seq;
+ eh_seq = old_eh_seq;
+ gimple_seq ret_seq = frob_into_branch_around (tp, try_region, out_label);
+ gimple_seq_add_seq (&eh_seq, new_eh_seq);
+ return ret_seq;
}
/* A subroutine of lower_eh_constructs_1. Lower a GIMPLE_TRY with a
region trees that record all the magic. */
static gimple_seq
-lower_eh_filter (struct leh_state *state, gimple tp)
+lower_eh_filter (struct leh_state *state, gtry *tp)
{
struct leh_state this_state = *state;
eh_region this_region = NULL;
- gimple inner, x;
+ gimple *inner, *x;
gimple_seq new_seq;
inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
plus the exception region trees that record all the magic. */
static gimple_seq
-lower_eh_must_not_throw (struct leh_state *state, gimple tp)
+lower_eh_must_not_throw (struct leh_state *state, gtry *tp)
{
struct leh_state this_state = *state;
if (flag_exceptions)
{
- gimple inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
+ gimple *inner = gimple_seq_first_stmt (gimple_try_cleanup (tp));
eh_region this_region;
this_region = gen_eh_region_must_not_throw (state->cur_region);
this_region->u.must_not_throw.failure_decl
- = gimple_eh_must_not_throw_fndecl (inner);
+ = gimple_eh_must_not_throw_fndecl (
+ as_a <geh_mnt *> (inner));
this_region->u.must_not_throw.failure_loc
= LOCATION_LOCUS (gimple_location (tp));
except that we only execute the cleanup block for exception edges. */
static gimple_seq
-lower_cleanup (struct leh_state *state, gimple tp)
+lower_cleanup (struct leh_state *state, gtry *tp)
{
struct leh_state this_state = *state;
eh_region this_region = NULL;
result = gimple_try_eval (tp);
if (fake_tf.fallthru_label)
{
- gimple x = gimple_build_label (fake_tf.fallthru_label);
+ gimple *x = gimple_build_label (fake_tf.fallthru_label);
gimple_seq_add_stmt (&result, x);
}
}
lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
{
gimple_seq replace;
- gimple x;
- gimple stmt = gsi_stmt (*gsi);
+ gimple *x;
+ gimple *stmt = gsi_stmt (*gsi);
switch (gimple_code (stmt))
{
&& is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
{
tree lhs = gimple_get_lhs (stmt);
- tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
- gimple s = gimple_build_assign (lhs, tmp);
+ tree tmp = create_tmp_var (TREE_TYPE (lhs));
+ gimple *s = gimple_build_assign (lhs, tmp);
gimple_set_location (s, gimple_location (stmt));
gimple_set_block (s, gimple_block (stmt));
gimple_set_lhs (stmt, tmp);
break;
case GIMPLE_SWITCH:
- verify_norecord_switch_expr (state, stmt);
+ verify_norecord_switch_expr (state, as_a <gswitch *> (stmt));
break;
case GIMPLE_TRY:
- if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
- replace = lower_try_finally (state, stmt);
- else
- {
- x = gimple_seq_first_stmt (gimple_try_cleanup (stmt));
- if (!x)
- {
- replace = gimple_try_eval (stmt);
- lower_eh_constructs_1 (state, &replace);
- }
- else
- switch (gimple_code (x))
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ if (gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY)
+ replace = lower_try_finally (state, try_stmt);
+ else
+ {
+ x = gimple_seq_first_stmt (gimple_try_cleanup (try_stmt));
+ if (!x)
{
+ replace = gimple_try_eval (try_stmt);
+ lower_eh_constructs_1 (state, &replace);
+ }
+ else
+ switch (gimple_code (x))
+ {
case GIMPLE_CATCH:
- replace = lower_catch (state, stmt);
- break;
+ replace = lower_catch (state, try_stmt);
+ break;
case GIMPLE_EH_FILTER:
- replace = lower_eh_filter (state, stmt);
- break;
+ replace = lower_eh_filter (state, try_stmt);
+ break;
case GIMPLE_EH_MUST_NOT_THROW:
- replace = lower_eh_must_not_throw (state, stmt);
- break;
+ replace = lower_eh_must_not_throw (state, try_stmt);
+ break;
case GIMPLE_EH_ELSE:
- /* This code is only valid with GIMPLE_TRY_FINALLY. */
- gcc_unreachable ();
+ /* This code is only valid with GIMPLE_TRY_FINALLY. */
+ gcc_unreachable ();
default:
- replace = lower_cleanup (state, stmt);
- break;
- }
- }
+ replace = lower_cleanup (state, try_stmt);
+ break;
+ }
+ }
+ }
/* Remove the old stmt and insert the transformed sequence
instead. */
no fallthru edge; false if there is. */
bool
-make_eh_dispatch_edges (gimple stmt)
+make_eh_dispatch_edges (geh_dispatch *stmt)
{
eh_region r;
eh_catch c;
if there is such a landing pad within the current function. */
void
-make_eh_edges (gimple stmt)
+make_eh_edges (gimple *stmt)
{
basic_block src, dst;
eh_landing_pad lp;
{
eh_landing_pad old_lp, new_lp;
basic_block old_bb;
- gimple throw_stmt;
+ gimple *throw_stmt;
int old_lp_nr, new_lp_nr;
tree old_label, new_label;
edge_iterator ei;
The actual edge update will happen in the caller. */
void
-redirect_eh_dispatch_edge (gimple stmt, edge e, basic_block new_bb)
+redirect_eh_dispatch_edge (geh_dispatch *stmt, edge e, basic_block new_bb)
{
tree new_lab = gimple_block_label (new_bb);
bool any_changed = false;
case UNEQ_EXPR:
return honor_snans;
- case CONVERT_EXPR:
- case FIX_TRUNC_EXPR:
- /* Conversion of floating point might trap. */
- return honor_nans;
-
case NEGATE_EXPR:
case ABS_EXPR:
case CONJ_EXPR:
/* Assume that accesses to weak functions may trap, unless we know
they are certainly defined in current TU or in some other
LTO partition. */
- if (DECL_WEAK (expr) && !DECL_COMDAT (expr))
+ if (DECL_WEAK (expr) && !DECL_COMDAT (expr) && DECL_EXTERNAL (expr))
{
- struct cgraph_node *node;
- if (!DECL_EXTERNAL (expr))
- return false;
- node = cgraph_node::get (expr)->function_symbol ();
- if (node && node->in_other_partition)
- return false;
- return true;
+ cgraph_node *node = cgraph_node::get (expr);
+ if (node)
+ node = node->function_symbol ();
+ return !(node && node->in_other_partition);
}
return false;
/* Assume that accesses to weak vars may trap, unless we know
they are certainly defined in current TU or in some other
LTO partition. */
- if (DECL_WEAK (expr) && !DECL_COMDAT (expr))
+ if (DECL_WEAK (expr) && !DECL_COMDAT (expr) && DECL_EXTERNAL (expr))
{
- varpool_node *node;
- if (!DECL_EXTERNAL (expr))
- return false;
- node = varpool_node::get (expr)->ultimate_alias_target ();
- if (node && node->in_other_partition)
- return false;
- return true;
+ varpool_node *node = varpool_node::get (expr);
+ if (node)
+ node = node->ultimate_alias_target ();
+ return !(node && node->in_other_partition);
}
return false;
an assignment or a conditional) may throw. */
static bool
-stmt_could_throw_1_p (gimple stmt)
+stmt_could_throw_1_p (gimple *stmt)
{
enum tree_code code = gimple_expr_code (stmt);
bool honor_nans = false;
/* Return true if statement STMT could throw an exception. */
bool
-stmt_could_throw_p (gimple stmt)
+stmt_could_throw_p (gimple *stmt)
{
if (!flag_exceptions)
return false;
return true;
case GIMPLE_CALL:
- return !gimple_call_nothrow_p (stmt);
+ return !gimple_call_nothrow_p (as_a <gcall *> (stmt));
case GIMPLE_ASSIGN:
case GIMPLE_COND:
case GIMPLE_ASM:
if (!cfun->can_throw_non_call_exceptions)
return false;
- return gimple_asm_volatile_p (stmt);
+ return gimple_asm_volatile_p (as_a <gasm *> (stmt));
default:
return false;
the current function (CFUN). */
bool
-stmt_can_throw_external (gimple stmt)
+stmt_can_throw_external (gimple *stmt)
{
int lp_nr;
the current function (CFUN). */
bool
-stmt_can_throw_internal (gimple stmt)
+stmt_can_throw_internal (gimple *stmt)
{
int lp_nr;
any change was made. */
bool
-maybe_clean_eh_stmt_fn (struct function *ifun, gimple stmt)
+maybe_clean_eh_stmt_fn (struct function *ifun, gimple *stmt)
{
if (stmt_could_throw_p (stmt))
return false;
/* Likewise, but always use the current function. */
bool
-maybe_clean_eh_stmt (gimple stmt)
+maybe_clean_eh_stmt (gimple *stmt)
{
return maybe_clean_eh_stmt_fn (cfun, stmt);
}
done that my require an EH edge purge. */
bool
-maybe_clean_or_replace_eh_stmt (gimple old_stmt, gimple new_stmt)
+maybe_clean_or_replace_eh_stmt (gimple *old_stmt, gimple *new_stmt)
{
int lp_nr = lookup_stmt_eh_lp (old_stmt);
operand is the return value of duplicate_eh_regions. */
bool
-maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple new_stmt,
- struct function *old_fun, gimple old_stmt,
+maybe_duplicate_eh_stmt_fn (struct function *new_fun, gimple *new_stmt,
+ struct function *old_fun, gimple *old_stmt,
hash_map<void *, void *> *map,
int default_lp_nr)
{
and thus no remapping is required. */
bool
-maybe_duplicate_eh_stmt (gimple new_stmt, gimple old_stmt)
+maybe_duplicate_eh_stmt (gimple *new_stmt, gimple *old_stmt)
{
int lp_nr;
same_handler_p (gimple_seq oneh, gimple_seq twoh)
{
gimple_stmt_iterator gsi;
- gimple ones, twos;
+ gimple *ones, *twos;
unsigned int ai;
gsi = gsi_start (oneh);
temporary used in the initializer for A. */
static void
-optimize_double_finally (gimple one, gimple two)
+optimize_double_finally (gtry *one, gtry *two)
{
- gimple oneh;
+ gimple *oneh;
gimple_stmt_iterator gsi;
gimple_seq cleanup;
refactor_eh_r (gimple_seq seq)
{
gimple_stmt_iterator gsi;
- gimple one, two;
+ gimple *one, *two;
one = NULL;
two = NULL;
two = NULL;
else
two = gsi_stmt (gsi);
- if (one
- && two
- && gimple_code (one) == GIMPLE_TRY
- && gimple_code (two) == GIMPLE_TRY
- && gimple_try_kind (one) == GIMPLE_TRY_FINALLY
- && gimple_try_kind (two) == GIMPLE_TRY_FINALLY)
- optimize_double_finally (one, two);
+ if (one && two)
+ if (gtry *try_one = dyn_cast <gtry *> (one))
+ if (gtry *try_two = dyn_cast <gtry *> (two))
+ if (gimple_try_kind (try_one) == GIMPLE_TRY_FINALLY
+ && gimple_try_kind (try_two) == GIMPLE_TRY_FINALLY)
+ optimize_double_finally (try_one, try_two);
if (one)
switch (gimple_code (one))
{
refactor_eh_r (gimple_try_cleanup (one));
break;
case GIMPLE_CATCH:
- refactor_eh_r (gimple_catch_handler (one));
+ refactor_eh_r (gimple_catch_handler (as_a <gcatch *> (one)));
break;
case GIMPLE_EH_FILTER:
refactor_eh_r (gimple_eh_filter_failure (one));
break;
case GIMPLE_EH_ELSE:
- refactor_eh_r (gimple_eh_else_n_body (one));
- refactor_eh_r (gimple_eh_else_e_body (one));
+ {
+ geh_else *eh_else_stmt = as_a <geh_else *> (one);
+ refactor_eh_r (gimple_eh_else_n_body (eh_else_stmt));
+ refactor_eh_r (gimple_eh_else_e_body (eh_else_stmt));
+ }
break;
default:
break;
/* At the end of gimple optimization, we can lower RESX. */
static bool
-lower_resx (basic_block bb, gimple stmt, hash_map<eh_region, tree> *mnt_map)
+lower_resx (basic_block bb, gresx *stmt,
+ hash_map<eh_region, tree> *mnt_map)
{
int lp_nr;
eh_region src_r, dst_r;
gimple_stmt_iterator gsi;
- gimple x;
+ gimple *x;
tree fn, src_nr;
bool ret = false;
fn = builtin_decl_implicit (BUILT_IN_EH_POINTER);
src_nr = build_int_cst (integer_type_node, src_r->index);
x = gimple_build_call (fn, 1, src_nr);
- var = create_tmp_var (ptr_type_node, NULL);
+ var = create_tmp_var (ptr_type_node);
var = make_ssa_name (var, x);
gimple_call_set_lhs (x, var);
gsi_insert_before (&gsi, x, GSI_SAME_STMT);
FOR_EACH_BB_FN (bb, fun)
{
- gimple last = last_stmt (bb);
+ gimple *last = last_stmt (bb);
if (last && is_gimple_resx (last))
{
- dominance_invalidated |= lower_resx (bb, last, &mnt_map);
+ dominance_invalidated |=
+ lower_resx (bb, as_a <gresx *> (last), &mnt_map);
any_rewritten = true;
}
}
call, and has an incoming EH edge. */
for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
if (is_gimple_debug (stmt))
continue;
if (gimple_clobber_p (stmt))
gsi = gsi_last_bb (bb);
for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
if (!gimple_clobber_p (stmt))
continue;
unlink_stmt_vdef (stmt);
gsi = gsi_last_bb (bb);
for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
if (is_gimple_debug (stmt))
continue;
if (gimple_code (stmt) == GIMPLE_LABEL)
/* See if there is a virtual PHI node to take an updated virtual
operand from. */
- gimple vphi = NULL;
+ gphi *vphi = NULL;
tree vuse = NULL_TREE;
- for (gsi = gsi_start_phis (succbb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gphi_iterator gpi = gsi_start_phis (succbb);
+ !gsi_end_p (gpi); gsi_next (&gpi))
{
- tree res = gimple_phi_result (gsi_stmt (gsi));
+ tree res = gimple_phi_result (gpi.phi ());
if (virtual_operand_p (res))
{
- vphi = gsi_stmt (gsi);
+ vphi = gpi.phi ();
vuse = res;
break;
}
gsi = gsi_last_bb (bb);
for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
tree lhs;
if (is_gimple_debug (stmt))
continue;
/* But adjust virtual operands if we sunk across a PHI node. */
if (vuse)
{
- gimple use_stmt;
+ gimple *use_stmt;
imm_use_iterator iter;
use_operand_p use_p;
FOR_EACH_IMM_USE_STMT (use_stmt, iter, vuse)
we have found some duplicate labels and removed some edges. */
static bool
-lower_eh_dispatch (basic_block src, gimple stmt)
+lower_eh_dispatch (basic_block src, geh_dispatch *stmt)
{
gimple_stmt_iterator gsi;
int region_nr;
eh_region r;
tree filter, fn;
- gimple x;
+ gimple *x;
bool redirected = false;
region_nr = gimple_eh_dispatch_region (stmt);
fn = builtin_decl_implicit (BUILT_IN_EH_FILTER);
x = gimple_build_call (fn, 1, build_int_cst (integer_type_node,
region_nr));
- filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
+ filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)));
filter = make_ssa_name (filter, x);
gimple_call_set_lhs (x, filter);
gsi_insert_before (&gsi, x, GSI_SAME_STMT);
fn = builtin_decl_implicit (BUILT_IN_EH_FILTER);
x = gimple_build_call (fn, 1, build_int_cst (integer_type_node,
region_nr));
- filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
+ filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)));
filter = make_ssa_name (filter, x);
gimple_call_set_lhs (x, filter);
gsi_insert_before (&gsi, x, GSI_SAME_STMT);
FOR_EACH_BB_FN (bb, fun)
{
- gimple last = last_stmt (bb);
+ gimple *last = last_stmt (bb);
if (last == NULL)
continue;
if (gimple_code (last) == GIMPLE_EH_DISPATCH)
{
- redirected |= lower_eh_dispatch (bb, last);
+ redirected |= lower_eh_dispatch (bb,
+ as_a <geh_dispatch *> (last));
flags |= TODO_update_ssa_only_virtuals;
}
else if (gimple_code (last) == GIMPLE_RESX)
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ gimple *stmt = gsi_stmt (gsi);
if (mark_landing_pads)
{
switch (gimple_code (stmt))
{
case GIMPLE_RESX:
- bitmap_set_bit (r_reachable, gimple_resx_region (stmt));
+ bitmap_set_bit (r_reachable,
+ gimple_resx_region (as_a <gresx *> (stmt)));
break;
case GIMPLE_EH_DISPATCH:
- bitmap_set_bit (r_reachable, gimple_eh_dispatch_region (stmt));
+ bitmap_set_bit (r_reachable,
+ gimple_eh_dispatch_region (
+ as_a <geh_dispatch *> (stmt)));
+ break;
+ case GIMPLE_CALL:
+ if (gimple_call_builtin_p (stmt, BUILT_IN_EH_COPY_VALUES))
+ for (int i = 0; i < 2; ++i)
+ {
+ tree rt = gimple_call_arg (stmt, i);
+ HOST_WIDE_INT ri = tree_to_shwi (rt);
+
+ gcc_assert (ri == (int)ri);
+ bitmap_set_bit (r_reachable, ri);
+ }
break;
default:
break;
sbitmap_free (r_reachable);
sbitmap_free (lp_reachable);
-#ifdef ENABLE_CHECKING
- verify_eh_tree (cfun);
-#endif
+ if (flag_checking)
+ verify_eh_tree (cfun);
}
/* Remove unreachable handlers if any landing pads have been removed after
for a different region. */
for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
tree lab;
int lp_nr;
- if (gimple_code (stmt) != GIMPLE_LABEL)
+ if (!label_stmt)
break;
- lab = gimple_label_label (stmt);
+ lab = gimple_label_label (label_stmt);
lp_nr = EH_LANDING_PAD_NR (lab);
if (lp_nr && get_eh_region_from_lp_number (lp_nr) != lp->region)
return false;
that doesn't appear to handle virtuals. Propagate by hand. */
if (!gimple_seq_empty_p (phi_nodes (bb)))
{
- for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
+ for (gphi_iterator gpi = gsi_start_phis (bb); !gsi_end_p (gpi); )
{
- gimple use_stmt, phi = gsi_stmt (gsi);
+ gimple *use_stmt;
+ gphi *phi = gpi.phi ();
tree lhs = gimple_phi_result (phi);
tree rhs = gimple_phi_arg_def (phi, 0);
use_operand_p use_p;
if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs) = 1;
- remove_phi_node (&gsi, true);
+ remove_phi_node (&gpi, true);
}
}
cleanup_empty_eh_merge_phis (basic_block new_bb, basic_block old_bb,
edge old_bb_out, bool change_region)
{
- gimple_stmt_iterator ngsi, ogsi;
+ gphi_iterator ngsi, ogsi;
edge_iterator ei;
edge e;
bitmap ophi_handled;
for the edges we're going to move. */
for (ngsi = gsi_start_phis (new_bb); !gsi_end_p (ngsi); gsi_next (&ngsi))
{
- gimple ophi, nphi = gsi_stmt (ngsi);
+ gphi *ophi, *nphi = ngsi.phi ();
tree nresult, nop;
nresult = gimple_phi_result (nphi);
ophi = NULL;
for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
{
- ophi = gsi_stmt (ogsi);
+ ophi = ogsi.phi ();
if (gimple_phi_result (ophi) == nop)
break;
ophi = NULL;
we don't know what values from the other edges into NEW_BB to use. */
for (ogsi = gsi_start_phis (old_bb); !gsi_end_p (ogsi); gsi_next (&ogsi))
{
- gimple ophi = gsi_stmt (ogsi);
+ gphi *ophi = ogsi.phi ();
tree oresult = gimple_phi_result (ophi);
if (!bitmap_bit_p (ophi_handled, SSA_NAME_VERSION (oresult)))
goto fail;
and mark the other loop as possibly having multiple latches. */
if (e->dest == e->dest->loop_father->header)
{
- e->dest->loop_father->header = NULL;
- e->dest->loop_father->latch = NULL;
+ mark_loop_for_removal (e->dest->loop_father);
new_bb->loop_father->latch = NULL;
- loops_state_set (LOOPS_NEED_FIXUP|LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
+ loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
}
redirect_eh_edge_1 (e, new_bb, change_region);
redirect_edge_succ (e, new_bb);
lab = NULL;
for (gsi = gsi_start_bb (e_out->dest); !gsi_end_p (gsi); gsi_next (&gsi))
{
- gimple stmt = gsi_stmt (gsi);
+ glabel *stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
int lp_nr;
- if (gimple_code (stmt) != GIMPLE_LABEL)
+ if (!stmt)
break;
lab = gimple_label_label (stmt);
lp_nr = EH_LANDING_PAD_NR (lab);
{
basic_block bb = label_to_block (lp->post_landing_pad);
gimple_stmt_iterator gsi;
- gimple resx;
+ gimple *resx;
eh_region new_region;
edge_iterator ei;
edge e, e_out;
for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
if (e->flags & EDGE_EH)
{
- gimple stmt = last_stmt (e->src);
+ gimple *stmt = last_stmt (e->src);
remove_stmt_from_eh_lp (stmt);
remove_edge (e);
}
for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
if (e->flags & EDGE_EH)
{
- gimple stmt = last_stmt (e->src);
+ gimple *stmt = last_stmt (e->src);
remove_stmt_from_eh_lp (stmt);
add_stmt_to_eh_lp (stmt, new_lp_nr);
remove_edge (e);
edge that make_eh_edges would create. */
DEBUG_FUNCTION bool
-verify_eh_edges (gimple stmt)
+verify_eh_edges (gimple *stmt)
{
basic_block bb = gimple_bb (stmt);
eh_landing_pad lp = NULL;
/* Similarly, but handle GIMPLE_EH_DISPATCH specifically. */
DEBUG_FUNCTION bool
-verify_eh_dispatch_edge (gimple stmt)
+verify_eh_dispatch_edge (geh_dispatch *stmt)
{
eh_region r;
eh_catch c;
projects / platform / upstream / gcc.git / blobdiff