gimple-low.c File Reference

#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "varray.h"
#include "tree-gimple.h"
#include "tree-inline.h"
#include "diagnostic.h"
#include "langhooks.h"
#include "langhooks-def.h"
#include "tree-flow.h"
#include "timevar.h"
#include "except.h"
#include "hashtab.h"
#include "flags.h"
#include "function.h"
#include "expr.h"
#include "toplev.h"
#include "tree-pass.h"

Include dependency graph for gimple-low.c:

Go to the source code of this file.

Data Structures
struct	lower_data
Functions
static void	lower_stmt (tree_stmt_iterator *, struct lower_data *)
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 unsigned int	lower_function_body ()
static void	lower_stmt_body ()
static void	lower_omp_directive ()
static void	lower_stmt ()
static void	lower_bind_expr ()
static bool	try_catch_may_fallthru ()
bool	block_may_fallthru ()
static void	lower_cond_expr ()
static void	lower_return_expr ()
void	record_vars_into ()
void	record_vars ()
static void	mark_blocks_with_used_vars ()
static unsigned int	mark_used_blocks ()
Variables
tree_opt_pass	pass_lower_cf
tree_opt_pass	pass_mark_used_blocks

---

Function Documentation

bool block_may_fallthru (   )

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. If we're wrong, we'll just delete the extra code later. Definition at line 345 of file gimple-low.c. References BIND_EXPR_BODY, call_expr_flags(), COND_EXPR_ELSE, COND_EXPR_THEN, ECF_NORETURN, expr_last(), NULL_TREE, SWITCH_LABELS, TREE_CODE, TREE_OPERAND, and try_catch_may_fallthru(). Referenced by convert_nl_goto_receiver(), frob_into_branch_around(), honor_protect_cleanup_actions(), lower_catch(), lower_cleanup(), lower_cond_expr(), lower_function_body(), lower_try_finally(), shortcut_cond_expr(), and try_catch_may_fallthru(). { tree stmt = expr_last (block); switch (stmt ? TREE_CODE (stmt) : ERROR_MARK) { case GOTO_EXPR: case RETURN_EXPR: case RESX_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; return block_may_fallthru (COND_EXPR_ELSE (stmt)); 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: /* 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) stmt = TREE_OPERAND (stmt, 1); else return true; /* FALLTHRU */ 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; } }

static void lower_bind_expr (   )  [static]

Lowers a bind_expr TSI. DATA is passed through the recursion. Definition at line 240 of file gimple-low.c. References BIND_EXPR_BLOCK, BIND_EXPR_BODY, BIND_EXPR_VARS, lower_data::block, BLOCK_CHAIN, BLOCK_SUBBLOCKS, BLOCK_SUPERCONTEXT, current_function_decl, DECL_INITIAL, lower_stmt_body(), NULL_TREE, record_vars(), TREE_ASM_WRITTEN, tsi_delink(), tsi_link_before(), TSI_SAME_STMT, and tsi_stmt(). { tree old_block = data->block; tree stmt = tsi_stmt (*tsi); tree new_block = BIND_EXPR_BLOCK (stmt); if (new_block) { if (new_block == old_block) { /* 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. */ gcc_assert (new_block == DECL_INITIAL (current_function_decl)); new_block = NULL; } else { /* We do not expect to handle duplicate blocks. */ gcc_assert (!TREE_ASM_WRITTEN (new_block)); TREE_ASM_WRITTEN (new_block) = 1; /* Block tree may get clobbered by inlining. Normally this would be fixed in rest_of_decl_compilation using block notes, but since we are not going to emit them, it is up to us. */ BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block); BLOCK_SUBBLOCKS (old_block) = new_block; BLOCK_SUBBLOCKS (new_block) = NULL_TREE; BLOCK_SUPERCONTEXT (new_block) = old_block; data->block = new_block; } } record_vars (BIND_EXPR_VARS (stmt)); lower_stmt_body (BIND_EXPR_BODY (stmt), data); if (new_block) { gcc_assert (data->block == new_block); BLOCK_SUBBLOCKS (new_block) = blocks_nreverse (BLOCK_SUBBLOCKS (new_block)); data->block = old_block; } /* The BIND_EXPR no longer carries any useful information -- kill it. */ tsi_link_before (tsi, BIND_EXPR_BODY (stmt), TSI_SAME_STMT); tsi_delink (tsi); }

static void lower_bind_expr (  tree_stmt_iterator *  , struct lower_data *  )  [static]

Referenced by lower_function_body(), and lower_stmt().

static void lower_cond_expr (   )  [static]

Lowers a cond_expr TSI. DATA is passed through the recursion. Definition at line 409 of file gimple-low.c. References block_may_fallthru(), build1, build_and_jump(), COND_EXPR_ELSE, COND_EXPR_THEN, expr_only(), LABEL_EXPR_LABEL, lower_stmt_body(), NULL_TREE, simple_goto_p(), TREE_SIDE_EFFECTS, TSI_CONTINUE_LINKING, tsi_delink(), tsi_link_after(), tsi_next(), tsi_stmt(), and void_type_node. { tree stmt = tsi_stmt (*tsi); bool then_is_goto, else_is_goto; tree then_branch, else_branch; tree then_goto, else_goto; then_branch = COND_EXPR_THEN (stmt); else_branch = COND_EXPR_ELSE (stmt); lower_stmt_body (then_branch, data); lower_stmt_body (else_branch, data); then_goto = expr_only (then_branch); then_is_goto = then_goto && simple_goto_p (then_goto); else_goto = expr_only (else_branch); else_is_goto = else_goto && simple_goto_p (else_goto); if (!then_is_goto || !else_is_goto) { tree then_label, else_label, end_label, t; then_label = NULL_TREE; else_label = NULL_TREE; end_label = NULL_TREE; /* Replace the cond_expr with explicit gotos. */ if (!then_is_goto) { t = build1 (LABEL_EXPR, void_type_node, NULL_TREE); if (TREE_SIDE_EFFECTS (then_branch)) then_label = t; else end_label = t; then_goto = build_and_jump (&LABEL_EXPR_LABEL (t)); } if (!else_is_goto) { t = build1 (LABEL_EXPR, void_type_node, NULL_TREE); if (TREE_SIDE_EFFECTS (else_branch)) else_label = t; else { /* Both THEN and ELSE can be no-ops if one or both contained an empty BIND_EXPR that was associated with the toplevel block of an inlined function. In that case remove_useless_stmts can't have cleaned things up for us; kill the whole conditional now. */ if (end_label) { tsi_delink (tsi); return; } else end_label = t; } else_goto = build_and_jump (&LABEL_EXPR_LABEL (t)); } if (then_label) { bool may_fallthru = block_may_fallthru (then_branch); tsi_link_after (tsi, then_label, TSI_CONTINUE_LINKING); tsi_link_after (tsi, then_branch, TSI_CONTINUE_LINKING); if (else_label && may_fallthru) { end_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE); t = build_and_jump (&LABEL_EXPR_LABEL (end_label)); tsi_link_after (tsi, t, TSI_CONTINUE_LINKING); } } if (else_label) { tsi_link_after (tsi, else_label, TSI_CONTINUE_LINKING); tsi_link_after (tsi, else_branch, TSI_CONTINUE_LINKING); } if (end_label) tsi_link_after (tsi, end_label, TSI_CONTINUE_LINKING); } COND_EXPR_THEN (stmt) = then_goto; COND_EXPR_ELSE (stmt) = else_goto; tsi_next (tsi); }

static void lower_cond_expr (  tree_stmt_iterator *  , struct lower_data *  )  [static]

Referenced by lower_stmt().

static unsigned int lower_function_body (   )  [static]

Lowers the body of current_function_decl. Definition at line 62 of file gimple-low.c. References alloc_stmt_list(), BLOCK_CHAIN, block_may_fallthru(), BLOCK_SUBBLOCKS, build1, current_function_decl, DECL_INITIAL, DECL_SAVED_TREE, lower_bind_expr(), NULL_TREE, SET_EXPR_LOCATION, SET_EXPR_LOCUS, TREE_ASM_WRITTEN, TREE_CHAIN, TREE_CODE, TREE_OPERAND, TREE_PURPOSE, TREE_VALUE, TSI_CONTINUE_LINKING, tsi_last(), tsi_link_after(), TSI_NEW_STMT, tsi_start(), and void_type_node. { struct lower_data data; tree *body_p = &DECL_SAVED_TREE (current_function_decl); tree bind = *body_p; tree_stmt_iterator i; tree t, x; 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; *body_p = alloc_stmt_list (); i = tsi_start (*body_p); tsi_link_after (&i, bind, TSI_NEW_STMT); lower_bind_expr (&i, &data); 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)) { x = build1 (RETURN_EXPR, void_type_node, NULL); SET_EXPR_LOCATION (x, cfun->function_end_locus); 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); } gcc_assert (data.block == DECL_INITIAL (current_function_decl)); BLOCK_SUBBLOCKS (data.block) = blocks_nreverse (BLOCK_SUBBLOCKS (data.block)); clear_block_marks (data.block); return 0; }

static void lower_omp_directive (   )  [static]

Lower the OpenMP directive statement pointed by TSI. DATA is passed through the recursion. Definition at line 160 of file gimple-low.c. References lower_stmt_body(), NULL_TREE, OMP_BODY, tsi_delink(), tsi_link_before(), TSI_SAME_STMT, and tsi_stmt(). Referenced by lower_stmt(). { tree stmt; stmt = tsi_stmt (*tsi); 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); }

static void lower_return_expr (   )  [static]

Definition at line 502 of file gimple-low.c. References build1, create_artificial_label(), EXPR_LOCUS, lower_data::return_statements, SET_EXPR_LOCUS, TREE_CHAIN, TREE_CODE, tree_cons, TREE_OPERAND, TREE_PURPOSE, TREE_VALUE, tsi_delink(), tsi_link_before(), TSI_SAME_STMT, tsi_stmt(), and void_type_node. { tree stmt = tsi_stmt (*tsi); tree value, t, label; /* Extract the value being returned. */ value = TREE_OPERAND (stmt, 0); if (value && TREE_CODE (value) == MODIFY_EXPR) value = TREE_OPERAND (value, 1); /* Match this up with an existing return statement that's been created. */ for (t = data->return_statements; t ; t = TREE_CHAIN (t)) { tree tvalue = TREE_OPERAND (TREE_VALUE (t), 0); if (tvalue && TREE_CODE (tvalue) == MODIFY_EXPR) tvalue = TREE_OPERAND (tvalue, 1); if (value == tvalue) { label = TREE_PURPOSE (t); goto found; } } /* Not found. Create a new label and record the return statement. */ label = create_artificial_label (); data->return_statements = tree_cons (label, stmt, data->return_statements); /* Generate a goto statement and remove the return statement. */ found: 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); }

static void lower_return_expr (  tree_stmt_iterator *  , struct lower_data *  )  [static]

Referenced by lower_stmt().

static void lower_stmt (   )  [static]

Lowers statement TSI. DATA is passed through the recursion. Definition at line 177 of file gimple-low.c. References lower_data::block, CATCH_BODY, EH_FILTER_FAILURE, EXPR_HAS_LOCATION, lower_bind_expr(), lower_cond_expr(), lower_omp_directive(), lower_return_expr(), lower_stmt_body(), TREE_BLOCK, TREE_CODE, TREE_OPERAND, tsi_next(), and tsi_stmt(). { tree stmt = tsi_stmt (*tsi); if (EXPR_HAS_LOCATION (stmt) && data) TREE_BLOCK (stmt) = data->block; switch (TREE_CODE (stmt)) { case BIND_EXPR: lower_bind_expr (tsi, data); return; case COND_EXPR: lower_cond_expr (tsi, data); return; case RETURN_EXPR: lower_return_expr (tsi, data); return; case TRY_FINALLY_EXPR: case TRY_CATCH_EXPR: lower_stmt_body (TREE_OPERAND (stmt, 0), data); lower_stmt_body (TREE_OPERAND (stmt, 1), data); break; case CATCH_EXPR: lower_stmt_body (CATCH_BODY (stmt), data); break; case EH_FILTER_EXPR: lower_stmt_body (EH_FILTER_FAILURE (stmt), data); break; case NOP_EXPR: case ASM_EXPR: case MODIFY_EXPR: case CALL_EXPR: case GOTO_EXPR: case LABEL_EXPR: case SWITCH_EXPR: case OMP_FOR: case OMP_SECTIONS: case OMP_SECTION: case OMP_SINGLE: case OMP_MASTER: case OMP_ORDERED: case OMP_CRITICAL: case OMP_RETURN: case OMP_CONTINUE: break; case OMP_PARALLEL: lower_omp_directive (tsi, data); return; default: gcc_unreachable (); } tsi_next (tsi); }

static void lower_stmt (  tree_stmt_iterator *  , struct lower_data *  )  [static]

Referenced by lower_stmt_body().

static void lower_stmt_body (   )  [static]

Lowers the EXPR. Unlike gimplification the statements are not relowered when they are changed -- if this has to be done, the lowering routine must do it explicitly. DATA is passed through the recursion. Definition at line 147 of file gimple-low.c. References lower_stmt(), tsi_end_p(), and tsi_start(). Referenced by lower_bind_expr(), lower_cond_expr(), lower_omp_directive(), and lower_stmt(). { tree_stmt_iterator tsi; for (tsi = tsi_start (expr); !tsi_end_p (tsi); ) lower_stmt (&tsi, data); }

static void mark_blocks_with_used_vars (   )  [static]

Mark BLOCK used if it has a used variable in it, then recurse over its subblocks. Definition at line 585 of file gimple-low.c. References BLOCK_VARS, TREE_CHAIN, and TREE_USED. Referenced by mark_used_blocks(). { tree var; tree subblock; if (!TREE_USED (block)) { for (var = BLOCK_VARS (block); var; var = TREE_CHAIN (var)) { if (TREE_USED (var)) { TREE_USED (block) = true; break; } } } for (subblock = BLOCK_SUBBLOCKS (block); subblock; subblock = BLOCK_CHAIN (subblock)) mark_blocks_with_used_vars (subblock); }

static unsigned int mark_used_blocks (   )  [static]

Mark the used attribute on blocks correctly. Definition at line 612 of file gimple-low.c. References current_function_decl, DECL_INITIAL, and mark_blocks_with_used_vars(). { mark_blocks_with_used_vars (DECL_INITIAL (current_function_decl)); return 0; }

void record_vars (   )

Record the variables in VARS into current_function_decl. Definition at line 575 of file gimple-low.c. References current_function_decl, and record_vars_into(). Referenced by gimple_add_tmp_var(), lower_bind_expr(), and pop_gimplify_context(). { record_vars_into (vars, current_function_decl); }

void record_vars_into (   )

Record the variables in VARS into function FN. Definition at line 542 of file gimple-low.c. References current_function_decl, DECL_EXTERNAL, DECL_STRUCT_FUNCTION, NULL_TREE, TREE_CHAIN, TREE_CODE, and tree_cons. Referenced by record_vars(). { 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; /* Record the variable. */ cfun->unexpanded_var_list = tree_cons (NULL_TREE, var, cfun->unexpanded_var_list); } if (fn != current_function_decl) cfun = saved_cfun; }

static bool try_catch_may_fallthru (   )  [static]

Try to determine whether a TRY_CATCH expression can fall through. This is a subroutine of block_may_fallthru. Definition at line 295 of file gimple-low.c. References block_may_fallthru(), CATCH_BODY, EH_FILTER_FAILURE, TREE_CODE, TREE_OPERAND, tsi_end_p(), tsi_next(), tsi_start(), and tsi_stmt(). Referenced by block_may_fallthru(). { 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; } }

---

Variable Documentation

struct tree_opt_pass pass_lower_cf

Initial value: { "lower", NULL, lower_function_body, NULL, NULL, 0, 0, PROP_gimple_any, PROP_gimple_lcf, 0, 0, TODO_dump_func, 0 } Definition at line 124 of file gimple-low.c.

struct tree_opt_pass pass_mark_used_blocks

Initial value: { "blocks", NULL, mark_used_blocks, NULL, NULL, 0, 0, 0, 0, 0, 0, TODO_dump_func, 0 } Definition at line 619 of file gimple-low.c.

---