gcc/ChangeLog.gimple-classes:
* gimple.h (gimple_try_kind): Strengthen param from const_gimple
to const gtry *.
(gimple_try_catch_is_cleanup): Likewise.
(gimple_try_eval_ptr): Strengthen param from gimple gtry *.
(gimple_try_eval): Likewise.
(gimple_try_cleanup_ptr): Likewise.
(gimple_try_cleanup): Likewise.
* gimple-low.c (lower_stmt): Introduce new local gtry *try_stmt
via a checked cast, using it in place of stmt for typesafety.
(lower_try_catch): Strengthen local "stmt" from gimple to gtry *.
(gimple_stmt_may_fallthru): Within case GIMPLE_TRY, introduce new
local gtry *try_stmt via a checked cast, using it in place of stmt
for typesafety.
* gimple-walk.c (walk_gimple_stmt): Likewise.
* omp-low.c (lower_omp_1): Likewise.
* tree-cfg.c (verify_gimple_in_seq_2): Likewise.
(do_warn_unused_result): Likewise.
* tree-eh.c (collect_finally_tree): Likewise.
(replace_goto_queue_1): Likewise.
(honor_protect_cleanup_actions): Replace check against GIMPLE_TRY
with a dyn_cast <gtry *>, introducing new local "try_stmt", using it
in place of "stmt".
(optimize_double_finally): Strengthen local "oneh" from gimple to
gtry *, via a dyn_cast.
(refactor_eh_r): Within case GIMPLE_TRY, introduce new local
gtry *try_stmt via a checked cast, using it in place of stmt for
typesafety.
* tree-inline.c (remap_gimple_stmt): Likewise.
(estimate_num_insns): Likewise.
---
gcc/ChangeLog.gimple-classes | 32 ++++++++++++++++++
gcc/gimple-low.c | 78 ++++++++++++++++++++++++--------------------
gcc/gimple-walk.c | 21 +++++++-----
gcc/gimple.h | 19 +++++------
gcc/omp-low.c | 7 ++--
gcc/tree-cfg.c | 14 +++++---
gcc/tree-eh.c | 67 +++++++++++++++++++++----------------
gcc/tree-inline.c | 17 +++++++---
8 files changed, 161 insertions(+), 94 deletions(-)
diff --git a/gcc/ChangeLog.gimple-classes b/gcc/ChangeLog.gimple-classes
index 50b87b9..10c3957 100644
--- a/gcc/ChangeLog.gimple-classes
+++ b/gcc/ChangeLog.gimple-classes
@@ -1,5 +1,37 @@
2014-10-28 David Malcolm <dmalc...@redhat.com>
+ * gimple.h (gimple_try_kind): Strengthen param from const_gimple
+ to const gtry *.
+ (gimple_try_catch_is_cleanup): Likewise.
+ (gimple_try_eval_ptr): Strengthen param from gimple gtry *.
+ (gimple_try_eval): Likewise.
+ (gimple_try_cleanup_ptr): Likewise.
+ (gimple_try_cleanup): Likewise.
+ * gimple-low.c (lower_stmt): Introduce new local gtry *try_stmt
+ via a checked cast, using it in place of stmt for typesafety.
+ (lower_try_catch): Strengthen local "stmt" from gimple to gtry *.
+ (gimple_stmt_may_fallthru): Within case GIMPLE_TRY, introduce new
+ local gtry *try_stmt via a checked cast, using it in place of stmt
+ for typesafety.
+ * gimple-walk.c (walk_gimple_stmt): Likewise.
+ * omp-low.c (lower_omp_1): Likewise.
+ * tree-cfg.c (verify_gimple_in_seq_2): Likewise.
+ (do_warn_unused_result): Likewise.
+ * tree-eh.c (collect_finally_tree): Likewise.
+ (replace_goto_queue_1): Likewise.
+ (honor_protect_cleanup_actions): Replace check against GIMPLE_TRY
+ with a dyn_cast <gtry *>, introducing new local "try_stmt", using it
+ in place of "stmt".
+ (optimize_double_finally): Strengthen local "oneh" from gimple to
+ gtry *, via a dyn_cast.
+ (refactor_eh_r): Within case GIMPLE_TRY, introduce new local
+ gtry *try_stmt via a checked cast, using it in place of stmt for
+ typesafety.
+ * tree-inline.c (remap_gimple_stmt): Likewise.
+ (estimate_num_insns): Likewise.
+
+2014-10-28 David Malcolm <dmalc...@redhat.com>
+
* gimple.h (gimple_goto_dest): Strengthen param from const_gimple to
const ggoto *.
* cfgexpand.c (expand_gimple_stmt_1): Add checked cast to ggoto *
diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c
index ab191a0..0aec000 100644
--- a/gcc/gimple-low.c
+++ b/gcc/gimple-low.c
@@ -271,27 +271,30 @@ lower_stmt (gimple_stmt_iterator *gsi, struct lower_data
*data)
return;
case GIMPLE_TRY:
- if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
- lower_try_catch (gsi, data);
- else
- {
- /* It must be a GIMPLE_TRY_FINALLY. */
- bool cannot_fallthru;
- lower_sequence (gimple_try_eval_ptr (stmt), data);
- cannot_fallthru = data->cannot_fallthru;
-
- /* The finally clause is always executed after the try clause,
- so if it does not fall through, then the try-finally will not
- fall through. Otherwise, if the try clause does not fall
- through, then when the finally clause falls through it will
- resume execution wherever the try clause was going. So the
- whole try-finally will only fall through if both the try
- clause and the finally clause fall through. */
- data->cannot_fallthru = false;
- lower_sequence (gimple_try_cleanup_ptr (stmt), data);
- data->cannot_fallthru |= cannot_fallthru;
- gsi_next (gsi);
- }
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ if (gimple_try_kind (try_stmt) == GIMPLE_TRY_CATCH)
+ lower_try_catch (gsi, data);
+ else
+ {
+ /* It must be a GIMPLE_TRY_FINALLY. */
+ bool cannot_fallthru;
+ lower_sequence (gimple_try_eval_ptr (try_stmt), data);
+ cannot_fallthru = data->cannot_fallthru;
+
+ /* The finally clause is always executed after the try clause,
+ so if it does not fall through, then the try-finally will not
+ fall through. Otherwise, if the try clause does not fall
+ through, then when the finally clause falls through it will
+ resume execution wherever the try clause was going. So the
+ whole try-finally will only fall through if both the try
+ clause and the finally clause fall through. */
+ data->cannot_fallthru = false;
+ lower_sequence (gimple_try_cleanup_ptr (try_stmt), data);
+ data->cannot_fallthru |= cannot_fallthru;
+ gsi_next (gsi);
+ }
+ }
return;
case GIMPLE_EH_ELSE:
@@ -444,7 +447,7 @@ static void
lower_try_catch (gimple_stmt_iterator *gsi, struct lower_data *data)
{
bool cannot_fallthru;
- gimple stmt = gsi_stmt (*gsi);
+ gtry *stmt = as_a <gtry *> (gsi_stmt (*gsi));
gimple_stmt_iterator i;
/* We don't handle GIMPLE_TRY_FINALLY. */
@@ -591,20 +594,23 @@ gimple_stmt_may_fallthru (gimple stmt)
gimple_bind_body (as_a <gbind *> (stmt)));
case GIMPLE_TRY:
- if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
- return gimple_try_catch_may_fallthru (as_a <gtry *> (stmt));
-
- /* It must be a GIMPLE_TRY_FINALLY. */
-
- /* The finally clause is always executed after the try clause,
- so if it does not fall through, then the try-finally will not
- fall through. Otherwise, if the try clause does not fall
- through, then when the finally clause falls through it will
- resume execution wherever the try clause was going. So the
- whole try-finally will only fall through if both the try
- clause and the finally clause fall through. */
- return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
- && gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ if (gimple_try_kind (try_stmt) == GIMPLE_TRY_CATCH)
+ return gimple_try_catch_may_fallthru (try_stmt);
+
+ /* It must be a GIMPLE_TRY_FINALLY. */
+
+ /* The finally clause is always executed after the try clause,
+ so if it does not fall through, then the try-finally will not
+ fall through. Otherwise, if the try clause does not fall
+ through, then when the finally clause falls through it will
+ resume execution wherever the try clause was going. So the
+ whole try-finally will only fall through if both the try
+ clause and the finally clause fall through. */
+ return (gimple_seq_may_fallthru (gimple_try_eval (try_stmt))
+ && gimple_seq_may_fallthru (gimple_try_cleanup (try_stmt)));
+ }
case GIMPLE_EH_ELSE:
{
diff --git a/gcc/gimple-walk.c b/gcc/gimple-walk.c
index 4aa2201..1248e75 100644
--- a/gcc/gimple-walk.c
+++ b/gcc/gimple-walk.c
@@ -599,15 +599,20 @@ walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn
callback_stmt,
break;
case GIMPLE_TRY:
- ret = walk_gimple_seq_mod (gimple_try_eval_ptr (stmt), callback_stmt,
callback_op,
- wi);
- if (ret)
- return wi->callback_result;
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ ret = walk_gimple_seq_mod (gimple_try_eval_ptr (try_stmt),
+ callback_stmt, callback_op,
+ wi);
+ if (ret)
+ return wi->callback_result;
- ret = walk_gimple_seq_mod (gimple_try_cleanup_ptr (stmt), callback_stmt,
- callback_op, wi);
- if (ret)
- return wi->callback_result;
+ ret = walk_gimple_seq_mod (gimple_try_cleanup_ptr (try_stmt),
+ callback_stmt,
+ callback_op, wi);
+ if (ret)
+ return wi->callback_result;
+ }
break;
case GIMPLE_OMP_FOR:
diff --git a/gcc/gimple.h b/gcc/gimple.h
index a947126..8e82914 100644
--- a/gcc/gimple.h
+++ b/gcc/gimple.h
@@ -3672,9 +3672,8 @@ gimple_eh_else_set_e_body (geh_else *eh_else_stmt,
gimple_seq seq)
either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
static inline enum gimple_try_flags
-gimple_try_kind (const_gimple gs)
+gimple_try_kind (const gtry *gs)
{
- GIMPLE_CHECK (gs, GIMPLE_TRY);
return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
}
@@ -3694,7 +3693,7 @@ gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind)
/* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
static inline bool
-gimple_try_catch_is_cleanup (const_gimple gs)
+gimple_try_catch_is_cleanup (const gtry *gs)
{
gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
@@ -3702,12 +3701,11 @@ gimple_try_catch_is_cleanup (const_gimple gs)
/* Return a pointer to the sequence of statements used as the
- body for GIMPLE_TRY GS. */
+ body for GIMPLE_TRY TRY_STMT. */
static inline gimple_seq *
-gimple_try_eval_ptr (gimple gs)
+gimple_try_eval_ptr (gtry *try_stmt)
{
- gtry *try_stmt = as_a <gtry *> (gs);
return &try_stmt->eval;
}
@@ -3715,19 +3713,18 @@ gimple_try_eval_ptr (gimple gs)
/* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
static inline gimple_seq
-gimple_try_eval (gimple gs)
+gimple_try_eval (gtry *gs)
{
return *gimple_try_eval_ptr (gs);
}
/* Return a pointer to the sequence of statements used as the cleanup body for
- GIMPLE_TRY GS. */
+ GIMPLE_TRY TRY_STMT. */
static inline gimple_seq *
-gimple_try_cleanup_ptr (gimple gs)
+gimple_try_cleanup_ptr (gtry *try_stmt)
{
- gtry *try_stmt = as_a <gtry *> (gs);
return &try_stmt->cleanup;
}
@@ -3736,7 +3733,7 @@ gimple_try_cleanup_ptr (gimple gs)
GIMPLE_TRY GS. */
static inline gimple_seq
-gimple_try_cleanup (gimple gs)
+gimple_try_cleanup (gtry *gs)
{
return *gimple_try_cleanup_ptr (gs);
}
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index d9ac691..0a5de1a 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -10504,8 +10504,11 @@ lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_context
*ctx)
lower_omp (gimple_eh_filter_failure_ptr (stmt), ctx);
break;
case GIMPLE_TRY:
- lower_omp (gimple_try_eval_ptr (stmt), ctx);
- lower_omp (gimple_try_cleanup_ptr (stmt), ctx);
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ lower_omp (gimple_try_eval_ptr (try_stmt), ctx);
+ lower_omp (gimple_try_cleanup_ptr (try_stmt), ctx);
+ }
break;
case GIMPLE_TRANSACTION:
lower_omp (gimple_transaction_body_ptr (
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 669f23e..ee3432d 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -4680,8 +4680,11 @@ verify_gimple_in_seq_2 (gimple_seq stmts)
break;
case GIMPLE_TRY:
- err |= verify_gimple_in_seq_2 (gimple_try_eval (stmt));
- err |= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt));
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ err |= verify_gimple_in_seq_2 (gimple_try_eval (try_stmt));
+ err |= verify_gimple_in_seq_2 (gimple_try_cleanup (try_stmt));
+ }
break;
case GIMPLE_EH_FILTER:
@@ -8424,8 +8427,11 @@ do_warn_unused_result (gimple_seq seq)
do_warn_unused_result (gimple_bind_body (as_a <gbind *>(g)));
break;
case GIMPLE_TRY:
- do_warn_unused_result (gimple_try_eval (g));
- do_warn_unused_result (gimple_try_cleanup (g));
+ {
+ gtry *try_stmt = as_a <gtry *> (g);
+ do_warn_unused_result (gimple_try_eval (try_stmt));
+ do_warn_unused_result (gimple_try_cleanup (try_stmt));
+ }
break;
case GIMPLE_CATCH:
do_warn_unused_result (gimple_catch_handler (
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index 3d601c0..77fb9a2 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -258,19 +258,22 @@ collect_finally_tree (gimple stmt, gtry *region)
break;
case GIMPLE_TRY:
- if (gimple_try_kind (stmt) == GIMPLE_TRY_FINALLY)
- {
- temp.g = stmt;
- record_in_finally_tree (temp, region);
- 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)
- {
- collect_finally_tree_1 (gimple_try_eval (stmt), region);
- collect_finally_tree_1 (gimple_try_cleanup (stmt), region);
- }
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ if (gimple_try_kind (try_stmt) == GIMPLE_TRY_FINALLY)
+ {
+ temp.g = try_stmt;
+ record_in_finally_tree (temp, region);
+ collect_finally_tree_1 (gimple_try_eval (try_stmt),
+ try_stmt);
+ collect_finally_tree_1 (gimple_try_cleanup (try_stmt), region);
+ }
+ else if (gimple_try_kind (try_stmt) == GIMPLE_TRY_CATCH)
+ {
+ collect_finally_tree_1 (gimple_try_eval (try_stmt), region);
+ collect_finally_tree_1 (gimple_try_cleanup (try_stmt), region);
+ }
+ }
break;
case GIMPLE_CATCH:
@@ -531,8 +534,11 @@ replace_goto_queue_1 (gimple stmt, struct leh_tf_state *tf,
break;
case GIMPLE_TRY:
- replace_goto_queue_stmt_list (gimple_try_eval_ptr (stmt), tf);
- replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (stmt), tf);
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ replace_goto_queue_stmt_list (gimple_try_eval_ptr (try_stmt), tf);
+ replace_goto_queue_stmt_list (gimple_try_cleanup_ptr (try_stmt), tf);
+ }
break;
case GIMPLE_CATCH:
replace_goto_queue_stmt_list (gimple_catch_handler_ptr (
@@ -1042,13 +1048,14 @@ honor_protect_cleanup_actions (struct leh_state
*outer_state,
MUST_NOT_THROW filter. */
gsi = gsi_start (finally);
x = gsi_stmt (gsi);
- if (gimple_code (x) == GIMPLE_TRY
- && gimple_try_kind (x) == GIMPLE_TRY_CATCH
- && gimple_try_catch_is_cleanup (x))
- {
- gsi_insert_seq_before (&gsi, gimple_try_eval (x), GSI_SAME_STMT);
- gsi_remove (&gsi, false);
- }
+ if (gtry *try_stmt = dyn_cast <gtry *> (x))
+ if (gimple_try_kind (try_stmt) == GIMPLE_TRY_CATCH
+ && gimple_try_catch_is_cleanup (try_stmt))
+ {
+ gsi_insert_seq_before (&gsi, gimple_try_eval (try_stmt),
+ GSI_SAME_STMT);
+ gsi_remove (&gsi, false);
+ }
/* Wrap the block with protect_cleanup_actions as the action. */
eh_mnt = gimple_build_eh_must_not_throw (protect_cleanup_actions);
@@ -3036,7 +3043,7 @@ same_handler_p (gimple_seq oneh, gimple_seq twoh)
static void
optimize_double_finally (gtry *one, gtry *two)
{
- gimple oneh;
+ gtry *oneh;
gimple_stmt_iterator gsi;
gimple_seq cleanup;
@@ -3045,9 +3052,10 @@ optimize_double_finally (gtry *one, gtry *two)
if (!gsi_one_before_end_p (gsi))
return;
- oneh = gsi_stmt (gsi);
- if (gimple_code (oneh) != GIMPLE_TRY
- || gimple_try_kind (oneh) != GIMPLE_TRY_CATCH)
+ oneh = dyn_cast <gtry *> (gsi_stmt (gsi));
+ if (!oneh)
+ return;
+ if (gimple_try_kind (oneh) != GIMPLE_TRY_CATCH)
return;
if (same_handler_p (gimple_try_cleanup (oneh), gimple_try_cleanup (two)))
@@ -3091,8 +3099,11 @@ refactor_eh_r (gimple_seq seq)
switch (gimple_code (one))
{
case GIMPLE_TRY:
- refactor_eh_r (gimple_try_eval (one));
- refactor_eh_r (gimple_try_cleanup (one));
+ {
+ gtry *try_one = as_a <gtry *> (one);
+ refactor_eh_r (gimple_try_eval (try_one));
+ refactor_eh_r (gimple_try_cleanup (try_one));
+ }
break;
case GIMPLE_CATCH:
refactor_eh_r (gimple_catch_handler (as_a <gcatch *> (one)));
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index fa08c98..0a076ce 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -1359,9 +1359,12 @@ remap_gimple_stmt (gimple stmt, copy_body_data *id)
break;
case GIMPLE_TRY:
- s1 = remap_gimple_seq (gimple_try_eval (stmt), id);
- s2 = remap_gimple_seq (gimple_try_cleanup (stmt), id);
- copy = gimple_build_try (s1, s2, gimple_try_kind (stmt));
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ s1 = remap_gimple_seq (gimple_try_eval (try_stmt), id);
+ s2 = remap_gimple_seq (gimple_try_cleanup (try_stmt), id);
+ copy = gimple_build_try (s1, s2, gimple_try_kind (try_stmt));
+ }
break;
case GIMPLE_WITH_CLEANUP_EXPR:
@@ -4010,8 +4013,12 @@ estimate_num_insns (gimple stmt, eni_weights *weights)
weights);
case GIMPLE_TRY:
- return (estimate_num_insns_seq (gimple_try_eval (stmt), weights)
- + estimate_num_insns_seq (gimple_try_cleanup (stmt), weights));
+ {
+ gtry *try_stmt = as_a <gtry *> (stmt);
+ return (estimate_num_insns_seq (gimple_try_eval (try_stmt), weights)
+ + estimate_num_insns_seq (gimple_try_cleanup (try_stmt),
+ weights));
+ }
/* OpenMP directives are generally very expensive. */
--
1.7.11.7
