/* Tree lowering pass. Lowers GIMPLE into unstructured form.
- Copyright (C) 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003, 2005 Free Software Foundation, Inc.
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
-#include "errors.h"
#include "varray.h"
#include "tree-gimple.h"
#include "tree-inline.h"
static void lower_bind_expr (tree_stmt_iterator *, struct lower_data *);
static void lower_cond_expr (tree_stmt_iterator *, struct lower_data *);
static void lower_return_expr (tree_stmt_iterator *, struct lower_data *);
-static bool expand_var_p (tree);
/* Lowers the body of current_function_decl. */
tree *body_p = &DECL_SAVED_TREE (current_function_decl);
tree bind = *body_p;
tree_stmt_iterator i;
+ tree t, x;
- if (TREE_CODE (bind) != BIND_EXPR)
- abort ();
+ gcc_assert (TREE_CODE (bind) == BIND_EXPR);
+ memset (&data, 0, sizeof (data));
data.block = DECL_INITIAL (current_function_decl);
BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
BLOCK_CHAIN (data.block) = NULL_TREE;
TREE_ASM_WRITTEN (data.block) = 1;
- data.return_statements = NULL_TREE;
-
*body_p = alloc_stmt_list ();
i = tsi_start (*body_p);
tsi_link_after (&i, bind, TSI_NEW_STMT);
lower_bind_expr (&i, &data);
- /* If we lowered any return statements, emit the representative at the
- end of the function. */
- if (data.return_statements)
+ i = tsi_last (*body_p);
+
+ /* If the function falls off the end, we need a null return statement.
+ If we've already got one in the return_statements list, we don't
+ need to do anything special. Otherwise build one by hand. */
+ if (block_may_fallthru (*body_p)
+ && (data.return_statements == NULL
+ || TREE_OPERAND (TREE_VALUE (data.return_statements), 0) != NULL))
{
- tree t, x;
- i = tsi_last (*body_p);
+ x = build1 (RETURN_EXPR, void_type_node, NULL);
+ SET_EXPR_LOCATION (x, cfun->function_end_locus);
+ tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
+ }
- for (t = data.return_statements; t ; t = TREE_CHAIN (t))
- {
- x = build (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
- tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
-
- /* Remove the line number from the representative return statement.
- It now fills in for many such returns. Failure to remove this
- will result in incorrect results for coverage analysis. */
- x = TREE_VALUE (t);
- SET_EXPR_LOCUS (x, NULL);
- tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
- }
+ /* If we lowered any return statements, emit the representative
+ at the end of the function. */
+ for (t = data.return_statements ; t ; t = TREE_CHAIN (t))
+ {
+ x = build1 (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
+ tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
+
+ /* Remove the line number from the representative return statement.
+ It now fills in for many such returns. Failure to remove this
+ will result in incorrect results for coverage analysis. */
+ x = TREE_VALUE (t);
+#ifdef USE_MAPPED_LOCATION
+ SET_EXPR_LOCATION (x, UNKNOWN_LOCATION);
+#else
+ SET_EXPR_LOCUS (x, NULL);
+#endif
+ tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
}
- if (data.block != DECL_INITIAL (current_function_decl))
- abort ();
+ gcc_assert (data.block == DECL_INITIAL (current_function_decl));
BLOCK_SUBBLOCKS (data.block)
= blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
clear_block_marks (data.block);
-
- /* Avoid producing notes for blocks. */
- cfun->dont_emit_block_notes = 1;
- reset_block_changes ();
}
struct tree_opt_pass pass_lower_cf =
0, /* tv_id */
PROP_gimple_any, /* properties_required */
PROP_gimple_lcf, /* properties_provided */
- PROP_gimple_any, /* properties_destroyed */
+ 0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func /* todo_flags_finish */
+ TODO_dump_func, /* todo_flags_finish */
+ 0 /* letter */
};
when they are changed -- if this has to be done, the lowering routine must
do it explicitly. DATA is passed through the recursion. */
-void
+static void
lower_stmt_body (tree expr, struct lower_data *data)
{
tree_stmt_iterator tsi;
lower_stmt (&tsi, data);
}
+
+/* Lower the OpenMP directive statement pointed by TSI. DATA is
+ passed through the recursion. */
+
+static void
+lower_omp_directive (tree_stmt_iterator *tsi, struct lower_data *data)
+{
+ tree clause, stmt;
+
+ stmt = tsi_stmt (*tsi);
+
+ clause = (TREE_CODE (stmt) >= OMP_PARALLEL && TREE_CODE (stmt) <= OMP_SINGLE)
+ ? OMP_CLAUSES (stmt)
+ : NULL_TREE;
+
+ lower_stmt_body (OMP_BODY (stmt), data);
+ tsi_link_before (tsi, stmt, TSI_SAME_STMT);
+ tsi_link_before (tsi, OMP_BODY (stmt), TSI_SAME_STMT);
+ OMP_BODY (stmt) = NULL_TREE;
+ tsi_delink (tsi);
+}
+
+
/* Lowers statement TSI. DATA is passed through the recursion. */
static void
case CALL_EXPR:
case GOTO_EXPR:
case LABEL_EXPR:
- case VA_ARG_EXPR:
case SWITCH_EXPR:
+ case OMP_RETURN_EXPR:
break;
+ case OMP_PARALLEL:
+ case OMP_FOR:
+ case OMP_SECTIONS:
+ case OMP_SECTION:
+ case OMP_SINGLE:
+ case OMP_MASTER:
+ case OMP_ORDERED:
+ case OMP_CRITICAL:
+ lower_omp_directive (tsi, data);
+ return;
+
default:
- print_node_brief (stderr, "", stmt, 0);
- case COMPOUND_EXPR:
- abort ();
+ gcc_unreachable ();
}
tsi_next (tsi);
/* The outermost block of the original function may not be the
outermost statement chain of the gimplified function. So we
may see the outermost block just inside the function. */
- if (new_block != DECL_INITIAL (current_function_decl))
- abort ();
+ gcc_assert (new_block == DECL_INITIAL (current_function_decl));
new_block = NULL;
}
else
{
/* We do not expect to handle duplicate blocks. */
- if (TREE_ASM_WRITTEN (new_block))
- abort ();
+ gcc_assert (!TREE_ASM_WRITTEN (new_block));
TREE_ASM_WRITTEN (new_block) = 1;
/* Block tree may get clobbered by inlining. Normally this would
if (new_block)
{
- if (data->block != new_block)
- abort ();
+ gcc_assert (data->block == new_block);
BLOCK_SUBBLOCKS (new_block)
= blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
tsi_delink (tsi);
}
+/* Try to determine whether a TRY_CATCH expression can fall through.
+ This is a subroutine of block_may_fallthru. */
+
+static bool
+try_catch_may_fallthru (tree stmt)
+{
+ tree_stmt_iterator i;
+
+ /* If the TRY block can fall through, the whole TRY_CATCH can
+ fall through. */
+ if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
+ return true;
+
+ i = tsi_start (TREE_OPERAND (stmt, 1));
+ switch (TREE_CODE (tsi_stmt (i)))
+ {
+ case CATCH_EXPR:
+ /* We expect to see a sequence of CATCH_EXPR trees, each with a
+ catch expression and a body. The whole TRY_CATCH may fall
+ through iff any of the catch bodies falls through. */
+ for (; !tsi_end_p (i); tsi_next (&i))
+ {
+ if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
+ return true;
+ }
+ return false;
+
+ case EH_FILTER_EXPR:
+ /* The exception filter expression only matters if there is an
+ exception. If the exception does not match EH_FILTER_TYPES,
+ we will execute EH_FILTER_FAILURE, and we will fall through
+ if that falls through. If the exception does match
+ EH_FILTER_TYPES, the stack unwinder will continue up the
+ stack, so we will not fall through. We don't know whether we
+ will throw an exception which matches EH_FILTER_TYPES or not,
+ so we just ignore EH_FILTER_TYPES and assume that we might
+ throw an exception which doesn't match. */
+ return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
+
+ default:
+ /* This case represents statements to be executed when an
+ exception occurs. Those statements are implicitly followed
+ by a RESX_EXPR to resume execution after the exception. So
+ in this case the TRY_CATCH never falls through. */
+ return false;
+ }
+}
+
/* Try to determine if we can fall out of the bottom of BLOCK. This guess
need not be 100% accurate; simply be conservative and return true if we
don't know. This is used only to avoid stupidly generating extra code.
case GOTO_EXPR:
case RETURN_EXPR:
case RESX_EXPR:
- case SWITCH_EXPR:
/* Easy cases. If the last statement of the block implies
control transfer, then we can't fall through. */
return false;
+ case SWITCH_EXPR:
+ /* If SWITCH_LABELS is set, this is lowered, and represents a
+ branch to a selected label and hence can not fall through.
+ Otherwise SWITCH_BODY is set, and the switch can fall
+ through. */
+ return SWITCH_LABELS (stmt) == NULL_TREE;
+
case COND_EXPR:
if (block_may_fallthru (COND_EXPR_THEN (stmt)))
return true;
case BIND_EXPR:
return block_may_fallthru (BIND_EXPR_BODY (stmt));
+ case TRY_CATCH_EXPR:
+ return try_catch_may_fallthru (stmt);
+
case TRY_FINALLY_EXPR:
- return block_may_fallthru (TREE_OPERAND (stmt, 1));
+ /* 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 (block_may_fallthru (TREE_OPERAND (stmt, 0))
+ && block_may_fallthru (TREE_OPERAND (stmt, 1)));
case MODIFY_EXPR:
if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
case CALL_EXPR:
/* Functions that do not return do not fall through. */
return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
+
+ case CLEANUP_POINT_EXPR:
+ return block_may_fallthru (TREE_OPERAND (stmt, 0));
default:
return true;
/* Generate a goto statement and remove the return statement. */
found:
- t = build (GOTO_EXPR, void_type_node, label);
+ t = build1 (GOTO_EXPR, void_type_node, label);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
tsi_link_before (tsi, t, TSI_SAME_STMT);
tsi_delink (tsi);
}
\f
-/* Record the variables in VARS. */
+/* Record the variables in VARS into function FN. */
void
-record_vars (tree vars)
+record_vars_into (tree vars, tree fn)
{
+ struct function *saved_cfun = cfun;
+
+ if (fn != current_function_decl)
+ cfun = DECL_STRUCT_FUNCTION (fn);
+
for (; vars; vars = TREE_CHAIN (vars))
{
tree var = vars;
+ /* BIND_EXPRs contains also function/type/constant declarations
+ we don't need to care about. */
+ if (TREE_CODE (var) != VAR_DECL)
+ continue;
+
/* Nothing to do in this case. */
if (DECL_EXTERNAL (var))
continue;
- if (TREE_CODE (var) == FUNCTION_DECL)
- continue;
/* Record the variable. */
cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
cfun->unexpanded_var_list);
}
+
+ if (fn != current_function_decl)
+ cfun = saved_cfun;
}
-/* Check whether to expand a variable VAR. */
-static bool
-expand_var_p (tree var)
-{
- struct var_ann_d *ann;
+/* Record the variables in VARS into current_function_decl. */
- if (TREE_CODE (var) != VAR_DECL)
- return true;
-
- ann = var_ann (var);
-
- /* Remove all unused, unaliased temporaries. Also remove unused, unaliased
- local variables during highly optimizing compilations. */
- ann = var_ann (var);
- if (ann
- && ! ann->may_aliases
- && ! ann->used
- && ! ann->has_hidden_use
- && ! TREE_ADDRESSABLE (var)
- && ! TREE_THIS_VOLATILE (var)
- && (DECL_ARTIFICIAL (var) || optimize >= 2))
- return false;
-
- return true;
+void
+record_vars (tree vars)
+{
+ record_vars_into (vars, current_function_decl);
}
-/* Throw away variables that are unused. */
+
+/* Mark BLOCK used if it has a used variable in it, then recurse over its
+ subblocks. */
static void
-remove_useless_vars (void)
+mark_blocks_with_used_vars (tree block)
{
- tree var, *cell;
+ tree var;
+ tree subblock;
- for (cell = &cfun->unexpanded_var_list; *cell; )
+ if (!TREE_USED (block))
{
- var = TREE_VALUE (*cell);
-
- if (!expand_var_p (var))
+ for (var = BLOCK_VARS (block);
+ var;
+ var = TREE_CHAIN (var))
{
- *cell = TREE_CHAIN (*cell);
- continue;
+ if (TREE_USED (var))
+ {
+ TREE_USED (block) = true;
+ break;
+ }
}
-
- cell = &TREE_CHAIN (*cell);
}
+ for (subblock = BLOCK_SUBBLOCKS (block);
+ subblock;
+ subblock = BLOCK_CHAIN (subblock))
+ mark_blocks_with_used_vars (subblock);
}
-/* Expand variables in the unexpanded_var_list. */
-
-void
-expand_used_vars (void)
-{
- tree cell;
-
- cfun->unexpanded_var_list = nreverse (cfun->unexpanded_var_list);
-
- for (cell = cfun->unexpanded_var_list; cell; cell = TREE_CHAIN (cell))
- expand_var (TREE_VALUE (cell));
-
- cfun->unexpanded_var_list = NULL_TREE;
+/* Mark the used attribute on blocks correctly. */
+
+static void
+mark_used_blocks (void)
+{
+ mark_blocks_with_used_vars (DECL_INITIAL (current_function_decl));
}
-struct tree_opt_pass pass_remove_useless_vars =
+
+struct tree_opt_pass pass_mark_used_blocks =
{
- "vars", /* name */
+ "blocks", /* name */
NULL, /* gate */
- remove_useless_vars, /* execute */
+ mark_used_blocks, /* execute */
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func /* todo_flags_finish */
+ TODO_dump_func, /* todo_flags_finish */
+ 0 /* letter */
};
OSDN Git Service
