2005-04-05 Andrew MacLeod <amacleod@redhat.com> * lambda-code.c (lambda_loopnest_to_gcc_loopnest): Use update_stmt. Use immediate use iterator. (stmt_is_bumper_for_loop): Use immediate use iterator. * predict.c (strip_builtin_expect): Use update_stmt. * tree-cfg.c (update_modified_stmts): New. Call update_stmt_if_modified on all elements of a STATEMENT_LIST. (bsi_insert_before, bsi_insert_after): Call update_modified_stmts. (bsi_remove): Remove imm_use links and mark the stmt as modified. (bsi_replace): Mark stmt as modified and the update it. * tree-complex.c (update_complex_assignment): Call mark_stmt_modified. (expand_complex_libcal): Call update_stmt. (expand_complex_comparison): Call mark_stmt_modified. (expand_complex_operations_1): Call update_stmt_if_modified. (expand_vector_operations_1): Call mark_stmt_modified. * tree-dfa.c (compute_immediate_uses, free_df_for_stmt, free_df, compute_immediate_uses_for_phi, compute_immediate_uses_for_stmt, add_immediate_use, redirect_immediate_use, redirect_immediate_uses, dump_immediate_uses, debug_immediate_uses, dump_immediate_uses_for, debug_immediate_uses_for): Delete. (mark_new_vars_to_rename): Call update_stmt. * tree-dump.c (dump_option_value_in): Add "stmtaddr". * tree-flow-inline.h (modify_stmt): Rename to mark_stmt_modified. Ignore PHI nodes. (unmodify_stmt): Delete. (update_stmt): New. Force an update of a stmt. (update_stmt_if_modified): update a stmt if it is out of date. (get_stmt_operands): Verify stmt is NOT modified. (stmt_modified_p): Update comment. (delink_imm_use): Remove a use node from its immuse list. (link_imm_use_to_list): Link a use node to a specific list. (link_imm_use): Link a node to the correct list. (set_ssa_use_from_ptr): Set a use node to a specific value, and insert it in the correct list, if appropriate. (link_imm_use_stmt): Link a use node, and set the stmt pointer. (relink_imm_use): Link a use node in place of another node in a list. (relink_imm_use_stmt): LInk a node in place of another node, and set the stmt pointer. (end_safe_imm_use_traverse): New. Terminate a safe immuse iterator. (end_safe_imm_use_p): New. Check for the end of a safe immuse iterator. (first_safe_imm_use): New. Initialize a safe immuse iterator. (next_safe_imm_use): New. Proceed to next safe immuse iterator value. (end_readonly_imm_use_p): New. Check for end of a fast immuse iterator. (first_readonly_imm_use): New. Initialize a fast immuse iterator. (next_readonly_imm_use): New. Get the next fast immuse iterator value. (has_zero_uses): New. Return true if there are no uses of a var. (has_single_use): New. Return true if there is only a single use of a variable. (single_imm_use): New. Return the simgle immediate use. (num_imm_uses): New. Return the number of immediate uses. (get_v_must_def_ops): Use is now a pointer. (use_operand_p, get_v_may_def_op_ptr, get_vuse_op_ptr, get_v_must_def_kill_ptr, get_phi_arg_def_ptr): Return the address of the use node. (get_immediate_uses, num_immediate_uses, immediate_use): Delete. (delink_stmt_imm_use): Delink all immuses from a stmt. (phi_arg_index_from_use): New. Return a phi arg index for a use. * tree-flow.h (struct dataflow_d): Delete. (immediate_use_iterator_d): New. Immediate use iterator struct. (FOR_EACH_IMM_USE_FAST): New. Macro for read only immuse iteration. (FOR_EACH_IMM_USE_SAFE): New. Macro for write-safe immuse iteration. (BREAK_FROM_SAFE_IMM_USE): New. Macro for earlyu exit from write-safe iteration. (struct stmt_ann_d): Remove dataflow_t from struct. * tree-if-conv.c (tree_if_conversion). Don't call free_df. (if_convertible_phi_p): Use FAST immuse iterator. (if_convertible_loop_p): Don't call compute_immediate_uses. (replace_phi_with_cond_modify_expr): Call update_stmt. * tree-into-ssa.c (mark_def_sites, ssa_mark_def_sites): Call update_stmt_if_modified. (rewrite_all_into_ssa): Initialize ssa operands. * tree-loop-linear.c (linear_transform_loops): Don't call free_df or compute_immediate_uses. * tree-optimize.c (execute_todo): Call verify_ssa whenever the ssa_property is available. (execute_one_pass): Change parameters passed to execute_todo. * tree-outof-ssa.c (rewrite_trees): Don't call modify_stmt. (remove_ssa_form): Call fini_ssa_operands. (insert_backedge_copies): Delete call to modify_stmt. * tree-phinodes.c (make_phi_node): Initialize use nodes. (release_phi_node): Delink any use nodes before releasing. (resize_phi_node): Relink any use nodes. (remove_phi_arg_num): Delink the use node. (remove_phi_node): Release the ssa_name AFTER releasing the phi node. (remove_all_phi_nodes_for): Release phi node first. * tree-pretty-print.c (dump_generic_node): Print stmt address. * tree-sra.c (mark_all_v_defs): Call update_stmt_if_modified. (scalarize_use, scalarize_copy): Call update_stmt. * tree-ssa-alias.c (compute_may_aliases): Update all modified stmts. (compute_points_to_and_addr_escape): Call mark_stmt_modified. * tree-ssa-cpp.c (need_imm_uses_for): Delete. (ccp_initialize): Remove call to compute_immediate_uses. (substitute_and_fold, execute_fold_all_builtins): Call update_stmt. * tree-ssa-dom.c (tree_ssa_dominator_optimize): Update all modified stmts. (simplify_cond_and_lookup_avail_expr): Call mark_stmt_modified. (simplify_switch_and_lookup_avail_expr): Call mark_stmt_modified. (eliminate_redundant_computations): Call mark_stmt_modified. (cprop_operand): Call mark_stmt_modified. (optimize_stmt): Call update_stmt_if_modified and mark_stmt_modified. * tree-ssa-dse.c (fix_phi_uses, fix_stmt_v_may_defs): Delete. (dse_optimize_stmt): Use new immuse interface. (tree_ssa_dse): Remove calls to compute_immediate_uses and free_df. * tree-ssa-forwprop.c (need_imm_uses_for): Delete. (substitute_single_use_vars): Use new immuse interface. (tree_ssa_forward_propagate_single_use_vars): Remove calls to free_df and compute_immediate_uses. * tree-ssa-loop-im.c (single_reachable_address): Use new immuse interface. (rewrite_mem_refs): Call update_stmt. (determine_lsm): Remove call to compute_imm_uses and free_df. * tree-ssa-loop-ivcanon.c (create_canonical_iv): Call update_stmt. (try_unroll_loop_completely): Call update_stmt. * tree-ssa-loop-ivopts.c (rewrite_address_base): Call update_stmt. (rewrite_use_compare): Call update_stmt. (compute_phi_arg_on_exit): Insert each stmt before trying to process. (rewrite_use) : Call update_stmt. * tree-ssa-loop-manip.c (verify_loop_closed_ssa): Add arg to call. * tree-ssa-loop-unswitch.c (tree_unswitch_single_loop): Call update_stmt. * tree-ssa-operands.c (NULL_USE_OPERAND_P): Remove declaration. (allocate_use_optype, allocate_vuse_optype): Adjust allocation size. (free_uses, free_vuses, free_v_may_defs, free_v_must_defs): Delink use nodes. (initialize_vuse_operand): New. Initialize a vuse operand. (initialize_v_may_def_operand): New. Initialize a maydef operand. (initialize_v_must_def_operand): New. Initialize a mustdef operand. (finalize_ssa_defs): Use stmt parameter. (correct_use_link): Ensure a use node is in the correct list, and has the correct stmt pointer. (finalize_ssa_uses, finalize_ssa_v_may_defs, finalize_ssa_vuses, finalize_ssa_v_must_defs): Also initialize use nodes. (finalize_ssa_stmt_operands): Pass extra stmt operands. (build_ssa_operands): Seperate parsing from final operand construction. (parse_ssa_operands): New. Parse entry point for operand building. (swap_tree_operands): New. Swap 2 tree operands. (update_stmt_operands): Ranamed from get_stmt_operands. Always builds operands. (get_expr_operands): Call swap_tree_operands when needed. (copy_virtual_operands): Use initialize routines for virtual use ops. (create_ssa_artficial_load_stmt): Add extra stmt parameter. (verify_abort): New. Issue imm_use error. (verify_imm_links): New Verify imm_use links for a var. (dump_immediate_uses_for): New. Dump imm_uses for a var to file. (dump_immediate_uses): New. Dump imm_uses for all vars to file. (debug_immediate_uses): New. Dump imm_uses for all vars to stderr. (debug_immediate_uses_for): New. Dump imm_uses for a var to stderr. * tree-ssa-operands.h (struct use_operand_ptr): Delete. (NULL_USE_OPERAND_P) Define. (use_optype_d, v_def_use_operand_type, vuse_optype_d): Add immediate use node. (struct vuse_operand_type): New struct. (SET_USE): Call set_ssa_use_from_ptr. (USE_STMT): Define. (PHI_ARG_INDEX_FROM_USE): Define. * tree-ssa-phiopt.c (replace_phi_edge_with_variable): Set the phi argument via SET_USE, not PHI_ARG_DEF_TREE. * tree-ssa-pre.c (eliminate): Call update_stmt. * tree-ssa-propagate.c (cfg_blocks_get): Use imm_use iterators. Don't call free_df. * tree-ssa-sink.c (all_immediate_uses_same_place): Use imm_use iterator. (nearest_common_dominator_of_uses): Use imm_use iterator. (statement_sink_location): Use imm_use iterator and interface. (execute_sink_code): Don't call compute_immediate_uses or free-df. * tree-ssa-threadupdate.c (create_edge_and_update_destination_phis): Use PHI_ARG_DEF, not PHI_ARG_DEF_TREE. * tree-ssa.c (verify_use, verify_phi_args): Verify some imm_use info. (verify_ssa): Ensure no stmt is marked modify after optimization pass if new parameter is true. (init_tree_ssa): Don't initialize operand cache here. (delete_tree_ssa): Don't destroy operand cache here. (propagate_into_addr): Pass in a use pointer, return true if anything was changed. (replace_immediate_uses): Use imm_use iterator, call update_stmt. (check_phi_redundancy): Use imm_use iterator. (kill_redundant_phi_nodes): Don't call compute_immediate_uses or free_df. * tree-ssanames.c (make_ssa_name): Initialize imm_use node. (release_ssa_name): Delink node and all elements in its imm_use list. * tree-tailcall.c (adjust_return_value): Call update_stmt. * tree-vect-analyze.c (vect_stmt_relevant_p): Use imm_use iterator. * tree-vectorizer.c (need_imm_uses_for): Delete. (vectorize_loops): Dont call compute_immediate_uses or free_df. * tree.h (struct ssa_imm_use_d): Define. (SSA_NAME_IMM_USE_NODE): Define. (struct tree_ssa_name): Add imm_use node. (PHI_DF): Delete. (PHI_ARG_IMM_USE_NODE): Define. (struct phi_arg_d): Add imm_use node. (struct tree_phi_node): Remove struct dataflow_d element. (TDF_STMTADDR): Define. From-SVN: r97648
289 lines
7.1 KiB
C
289 lines
7.1 KiB
C
/* Loop unswitching.
|
|
Copyright (C) 2004, 2005 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License as published by the
|
|
Free Software Foundation; either version 2, or (at your option) any
|
|
later version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
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. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "tm.h"
|
|
#include "tree.h"
|
|
#include "rtl.h"
|
|
#include "tm_p.h"
|
|
#include "hard-reg-set.h"
|
|
#include "basic-block.h"
|
|
#include "output.h"
|
|
#include "diagnostic.h"
|
|
#include "tree-flow.h"
|
|
#include "tree-dump.h"
|
|
#include "timevar.h"
|
|
#include "cfgloop.h"
|
|
#include "domwalk.h"
|
|
#include "params.h"
|
|
#include "tree-pass.h"
|
|
|
|
/* This file implements the loop unswitching, i.e. transformation of loops like
|
|
|
|
while (A)
|
|
{
|
|
if (inv)
|
|
B;
|
|
|
|
X;
|
|
|
|
if (!inv)
|
|
C;
|
|
}
|
|
|
|
where inv is the loop invariant, into
|
|
|
|
if (inv)
|
|
{
|
|
while (A)
|
|
{
|
|
B;
|
|
X;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (A)
|
|
{
|
|
X;
|
|
C;
|
|
}
|
|
}
|
|
|
|
Inv is considered invariant iff the values it compares are both invariant;
|
|
tree-ssa-loop-im.c ensures that all the suitable conditions are in this
|
|
shape. */
|
|
|
|
static struct loop *tree_unswitch_loop (struct loops *, struct loop *, basic_block,
|
|
tree);
|
|
static bool tree_unswitch_single_loop (struct loops *, struct loop *, int);
|
|
static tree tree_may_unswitch_on (basic_block, struct loop *);
|
|
|
|
/* Main entry point. Perform loop unswitching on all suitable LOOPS. */
|
|
|
|
void
|
|
tree_ssa_unswitch_loops (struct loops *loops)
|
|
{
|
|
int i, num;
|
|
struct loop *loop;
|
|
bool changed = false;
|
|
|
|
/* Go through inner loops (only original ones). */
|
|
num = loops->num;
|
|
|
|
for (i = 1; i < num; i++)
|
|
{
|
|
/* Removed loop? */
|
|
loop = loops->parray[i];
|
|
if (!loop)
|
|
continue;
|
|
|
|
if (loop->inner)
|
|
continue;
|
|
|
|
changed |= tree_unswitch_single_loop (loops, loop, 0);
|
|
#ifdef ENABLE_CHECKING
|
|
verify_dominators (CDI_DOMINATORS);
|
|
verify_loop_structure (loops);
|
|
#endif
|
|
}
|
|
|
|
if (changed)
|
|
cleanup_tree_cfg_loop ();
|
|
}
|
|
|
|
/* Checks whether we can unswitch LOOP on condition at end of BB -- one of its
|
|
basic blocks (for what it means see comments below). */
|
|
|
|
static tree
|
|
tree_may_unswitch_on (basic_block bb, struct loop *loop)
|
|
{
|
|
tree stmt, def, cond;
|
|
basic_block def_bb;
|
|
use_optype uses;
|
|
unsigned i;
|
|
|
|
/* BB must end in a simple conditional jump. */
|
|
stmt = last_stmt (bb);
|
|
if (!stmt || TREE_CODE (stmt) != COND_EXPR)
|
|
return NULL_TREE;
|
|
|
|
/* Condition must be invariant. */
|
|
get_stmt_operands (stmt);
|
|
uses = STMT_USE_OPS (stmt);
|
|
for (i = 0; i < NUM_USES (uses); i++)
|
|
{
|
|
def = SSA_NAME_DEF_STMT (USE_OP (uses, i));
|
|
def_bb = bb_for_stmt (def);
|
|
if (def_bb
|
|
&& flow_bb_inside_loop_p (loop, def_bb))
|
|
return NULL_TREE;
|
|
}
|
|
|
|
cond = COND_EXPR_COND (stmt);
|
|
/* To keep the things simple, we do not directly remove the conditions,
|
|
but just replace tests with 0/1. Prevent the infinite loop where we
|
|
would unswitch again on such a condition. */
|
|
if (integer_zerop (cond) || integer_nonzerop (cond))
|
|
return NULL_TREE;
|
|
|
|
return cond;
|
|
}
|
|
|
|
/* Simplifies COND using checks in front of the entry of the LOOP. Just very
|
|
simplish (sufficient to prevent us from duplicating loop in unswitching
|
|
unnecessarily). */
|
|
|
|
static tree
|
|
simplify_using_entry_checks (struct loop *loop, tree cond)
|
|
{
|
|
edge e = loop_preheader_edge (loop);
|
|
tree stmt;
|
|
|
|
while (1)
|
|
{
|
|
stmt = last_stmt (e->src);
|
|
if (stmt
|
|
&& TREE_CODE (stmt) == COND_EXPR
|
|
&& operand_equal_p (COND_EXPR_COND (stmt), cond, 0))
|
|
return (e->flags & EDGE_TRUE_VALUE
|
|
? boolean_true_node
|
|
: boolean_false_node);
|
|
|
|
if (!single_pred_p (e->src))
|
|
return cond;
|
|
|
|
e = single_pred_edge (e->src);
|
|
if (e->src == ENTRY_BLOCK_PTR)
|
|
return cond;
|
|
}
|
|
}
|
|
|
|
/* Unswitch single LOOP. NUM is number of unswitchings done; we do not allow
|
|
it to grow too much, it is too easy to create example on that the code would
|
|
grow exponentially. */
|
|
|
|
static bool
|
|
tree_unswitch_single_loop (struct loops *loops, struct loop *loop, int num)
|
|
{
|
|
basic_block *bbs;
|
|
struct loop *nloop;
|
|
unsigned i;
|
|
tree cond = NULL_TREE, stmt;
|
|
bool changed = false;
|
|
|
|
/* Do not unswitch too much. */
|
|
if (num > PARAM_VALUE (PARAM_MAX_UNSWITCH_LEVEL))
|
|
{
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
fprintf (dump_file, ";; Not unswitching anymore, hit max level\n");
|
|
return false;
|
|
}
|
|
|
|
/* Only unswitch innermost loops. */
|
|
if (loop->inner)
|
|
{
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
fprintf (dump_file, ";; Not unswitching, not innermost loop\n");
|
|
return false;
|
|
}
|
|
|
|
/* The loop should not be too large, to limit code growth. */
|
|
if (tree_num_loop_insns (loop)
|
|
> (unsigned) PARAM_VALUE (PARAM_MAX_UNSWITCH_INSNS))
|
|
{
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
fprintf (dump_file, ";; Not unswitching, loop too big\n");
|
|
return false;
|
|
}
|
|
|
|
i = 0;
|
|
bbs = get_loop_body (loop);
|
|
|
|
while (1)
|
|
{
|
|
/* Find a bb to unswitch on. */
|
|
for (; i < loop->num_nodes; i++)
|
|
if ((cond = tree_may_unswitch_on (bbs[i], loop)))
|
|
break;
|
|
|
|
if (i == loop->num_nodes)
|
|
{
|
|
free (bbs);
|
|
return changed;
|
|
}
|
|
|
|
cond = simplify_using_entry_checks (loop, cond);
|
|
stmt = last_stmt (bbs[i]);
|
|
if (integer_nonzerop (cond))
|
|
{
|
|
/* Remove false path. */
|
|
COND_EXPR_COND (stmt) = boolean_true_node;
|
|
changed = true;
|
|
}
|
|
else if (integer_zerop (cond))
|
|
{
|
|
/* Remove true path. */
|
|
COND_EXPR_COND (stmt) = boolean_false_node;
|
|
changed = true;
|
|
}
|
|
else
|
|
break;
|
|
|
|
update_stmt (stmt);
|
|
i++;
|
|
}
|
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
fprintf (dump_file, ";; Unswitching loop\n");
|
|
|
|
/* Unswitch the loop on this condition. */
|
|
nloop = tree_unswitch_loop (loops, loop, bbs[i], cond);
|
|
if (!nloop)
|
|
return changed;
|
|
|
|
/* Invoke itself on modified loops. */
|
|
tree_unswitch_single_loop (loops, nloop, num + 1);
|
|
tree_unswitch_single_loop (loops, loop, num + 1);
|
|
return true;
|
|
}
|
|
|
|
/* Unswitch a LOOP w.r. to given basic block UNSWITCH_ON. We only support
|
|
unswitching of innermost loops. COND is the condition determining which
|
|
loop is entered -- the new loop is entered if COND is true. Returns NULL
|
|
if impossible, new loop otherwise. */
|
|
|
|
static struct loop *
|
|
tree_unswitch_loop (struct loops *loops, struct loop *loop,
|
|
basic_block unswitch_on, tree cond)
|
|
{
|
|
basic_block condition_bb;
|
|
|
|
/* Some sanity checking. */
|
|
gcc_assert (flow_bb_inside_loop_p (loop, unswitch_on));
|
|
gcc_assert (EDGE_COUNT (unswitch_on->succs) == 2);
|
|
gcc_assert (loop->inner == NULL);
|
|
|
|
return loop_version (loops, loop, unshare_expr (cond),
|
|
&condition_bb);
|
|
}
|