#include "system.h"
#include "coretypes.h"
#include "tm.h"
-#include "errors.h"
-#include "ggc.h"
#include "tree.h"
-#include "langhooks.h"
-
-/* These RTL headers are needed for basic-block.h. */
+#include "flags.h"
#include "rtl.h"
#include "tm_p.h"
-#include "hard-reg-set.h"
+#include "ggc.h"
#include "basic-block.h"
-
+#include "output.h"
+#include "errors.h"
+#include "expr.h"
+#include "function.h"
#include "diagnostic.h"
-#include "tree-inline.h"
-#include "tree-flow.h"
-#include "tree-gimple.h"
+#include "timevar.h"
#include "tree-dump.h"
+#include "tree-flow.h"
#include "tree-pass.h"
-#include "timevar.h"
-#include "expr.h"
-#include "flags.h"
+#include "tree-ssa-propagate.h"
+#include "langhooks.h"
/* Possible lattice values. */
VARYING
} latticevalue;
-/* Use the TREE_VISITED bitflag to mark statements and PHI nodes that have
- been deemed VARYING and shouldn't be simulated again. */
-#define DONT_SIMULATE_AGAIN(T) TREE_VISITED (T)
-
/* Main structure for CCP. Contains the lattice value and, if it's a
constant, the constant value. */
typedef struct
tree const_val;
} value;
-/* A bitmap to keep track of executable blocks in the CFG. */
-static sbitmap executable_blocks;
-
-/* Array of control flow edges on the worklist. */
-static GTY(()) varray_type cfg_blocks = NULL;
-
-static unsigned int cfg_blocks_num = 0;
-static int cfg_blocks_tail;
-static int cfg_blocks_head;
-
-static sbitmap bb_in_list;
-
/* This is used to track the current value of each variable. */
static value *value_vector;
-/* Worklist of SSA edges which will need reexamination as their definition
- has changed. SSA edges are def-use edges in the SSA web. For each
- edge, we store the definition statement or PHI node D. The destination
- nodes that need to be visited are accessed using immediate_uses
- (D). */
-static GTY(()) varray_type ssa_edges;
-
-/* Identical to SSA_EDGES. For performance reasons, the list of SSA
- edges is split into two. One contains all SSA edges who need to be
- reexamined because their lattice value changed to varying (this
- worklist), and the other contains all other SSA edges to be
- reexamined (ssa_edges).
-
- Since most values in the program are varying, the ideal situation
- is to move them to that lattice value as quickly as possible.
- Thus, it doesn't make sense to process any other type of lattice
- value until all varying values are propagated fully, which is one
- thing using the varying worklist achieves. In addition, if you
- don't use a separate worklist for varying edges, you end up with
- situations where lattice values move from
- undefined->constant->varying instead of undefined->varying.
-*/
-static GTY(()) varray_type varying_ssa_edges;
-
-
-static void initialize (void);
-static void finalize (void);
-static void visit_phi_node (tree);
-static tree ccp_fold (tree);
-static value cp_lattice_meet (value, value);
-static void visit_stmt (tree);
-static void visit_cond_stmt (tree);
-static void visit_assignment (tree);
-static void add_var_to_ssa_edges_worklist (tree, value);
-static void add_outgoing_control_edges (basic_block);
-static void add_control_edge (edge);
-static void def_to_varying (tree);
-static void set_lattice_value (tree, value);
-static void simulate_block (basic_block);
-static void simulate_stmt (tree);
-static void substitute_and_fold (void);
-static value evaluate_stmt (tree);
-static void dump_lattice_value (FILE *, const char *, value);
-static bool replace_uses_in (tree, bool *);
-static bool replace_vuse_in (tree, bool *);
-static latticevalue likely_value (tree);
-static tree get_rhs (tree);
-static bool set_rhs (tree *, tree);
-static value *get_value (tree);
-static value get_default_value (tree);
-static tree ccp_fold_builtin (tree, tree);
-static bool get_strlen (tree, tree *, bitmap);
-static inline bool cfg_blocks_empty_p (void);
-static void cfg_blocks_add (basic_block);
-static basic_block cfg_blocks_get (void);
-static bool need_imm_uses_for (tree var);
-
-/* Process an SSA edge worklist. WORKLIST is the SSA edge worklist to
- drain. This pops statements off the given WORKLIST and processes
- them until there are no more statements on WORKLIST. */
+
+/* Dump lattice value VAL to file OUTF prefixed by PREFIX. */
static void
-process_ssa_edge_worklist (varray_type *worklist)
+dump_lattice_value (FILE *outf, const char *prefix, value val)
{
- /* Drain the entire worklist. */
- while (VARRAY_ACTIVE_SIZE (*worklist) > 0)
+ switch (val.lattice_val)
{
- /* Pull the statement to simulate off the worklist. */
- tree stmt = VARRAY_TOP_TREE (*worklist);
- stmt_ann_t ann = stmt_ann (stmt);
- VARRAY_POP (*worklist);
-
- /* visit_stmt can "cancel" reevaluation of some statements.
- If it does, then in_ccp_worklist will be zero. */
- if (ann->in_ccp_worklist)
- {
- ann->in_ccp_worklist = 0;
- simulate_stmt (stmt);
- }
- }
+ case UNDEFINED:
+ fprintf (outf, "%sUNDEFINED", prefix);
+ break;
+ case VARYING:
+ fprintf (outf, "%sVARYING", prefix);
+ break;
+ case UNKNOWN_VAL:
+ fprintf (outf, "%sUNKNOWN_VAL", prefix);
+ break;
+ case CONSTANT:
+ fprintf (outf, "%sCONSTANT ", prefix);
+ print_generic_expr (outf, val.const_val, dump_flags);
+ break;
+ default:
+ abort ();
+ }
}
-
-/* Main entry point for SSA Conditional Constant Propagation. FNDECL is
- the declaration for the function to optimize.
-
- On exit, VARS_TO_RENAME will contain the symbols that have been exposed by
- the propagation of ADDR_EXPR expressions into pointer dereferences and need
- to be renamed into SSA.
- PHASE indicates which dump file from the DUMP_FILES array to use when
- dumping debugging information. */
-static void
-tree_ssa_ccp (void)
-{
- initialize ();
+/* Return a default value for variable VAR using the following rules:
- /* Iterate until the worklists are empty. */
- while (!cfg_blocks_empty_p ()
- || VARRAY_ACTIVE_SIZE (ssa_edges) > 0
- || VARRAY_ACTIVE_SIZE (varying_ssa_edges) > 0)
- {
- if (!cfg_blocks_empty_p ())
- {
- /* Pull the next block to simulate off the worklist. */
- basic_block dest_block = cfg_blocks_get ();
- simulate_block (dest_block);
- }
+ 1- Function arguments are considered VARYING.
+
+ 2- Global and static variables that are declared constant are
+ considered CONSTANT.
- /* In order to move things to varying as quickly as
- possible,process the VARYING_SSA_EDGES worklist first. */
- process_ssa_edge_worklist (&varying_ssa_edges);
+ 3- Any other virtually defined variable is considered UNKNOWN_VAL.
- /* Now process the SSA_EDGES worklist. */
- process_ssa_edge_worklist (&ssa_edges);
- }
+ 4- Any other value is considered UNDEFINED. This is useful when
+ considering PHI nodes. PHI arguments that are undefined do not
+ change the constant value of the PHI node, which allows for more
+ constants to be propagated. */
- /* Now perform substitutions based on the known constant values. */
- substitute_and_fold ();
+static value
+get_default_value (tree var)
+{
+ value val;
+ tree sym;
- /* Now cleanup any unreachable code. */
- cleanup_tree_cfg ();
+ if (TREE_CODE (var) == SSA_NAME)
+ sym = SSA_NAME_VAR (var);
+ else
+ {
+#ifdef ENABLE_CHECKING
+ if (!DECL_P (var))
+ abort ();
+#endif
+ sym = var;
+ }
- /* Free allocated memory. */
- finalize ();
+ val.lattice_val = UNDEFINED;
+ val.const_val = NULL_TREE;
- /* Debugging dumps. */
- if (dump_file && (dump_flags & TDF_DETAILS))
+ if (TREE_CODE (sym) == PARM_DECL || TREE_THIS_VOLATILE (sym))
{
- dump_referenced_vars (dump_file);
- fprintf (dump_file, "\n\n");
+ /* Function arguments and volatile variables are considered VARYING. */
+ val.lattice_val = VARYING;
}
-}
+ else if (TREE_STATIC (sym))
+ {
+ /* Globals and static variables are considered UNKNOWN_VAL,
+ unless they are declared 'const'. */
+ if (TREE_READONLY (sym)
+ && DECL_INITIAL (sym)
+ && is_gimple_min_invariant (DECL_INITIAL (sym)))
+ {
+ val.lattice_val = CONSTANT;
+ val.const_val = DECL_INITIAL (sym);
+ }
+ else
+ {
+ val.const_val = NULL_TREE;
+ val.lattice_val = UNKNOWN_VAL;
+ }
+ }
+ else if (!is_gimple_reg (sym))
+ {
+ val.const_val = NULL_TREE;
+ val.lattice_val = UNKNOWN_VAL;
+ }
+ else
+ {
+ enum tree_code code;
+ tree stmt = SSA_NAME_DEF_STMT (var);
-static bool
-gate_ccp (void)
-{
- return flag_tree_ccp != 0;
-}
+ if (!IS_EMPTY_STMT (stmt))
+ {
+ code = TREE_CODE (stmt);
+ if (code != MODIFY_EXPR && code != PHI_NODE)
+ val.lattice_val = VARYING;
+ }
+ }
-struct tree_opt_pass pass_ccp =
-{
- "ccp", /* name */
- gate_ccp, /* gate */
- tree_ssa_ccp, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_TREE_CCP, /* tv_id */
- PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_dump_func | TODO_rename_vars
- | TODO_ggc_collect | TODO_verify_ssa
- | TODO_verify_stmts /* todo_flags_finish */
-};
+ return val;
+}
/* Get the constant value associated with variable VAR. */
}
-/* Simulate the execution of BLOCK. Evaluate the statement associated
- with each variable reference inside the block. */
+/* Set the lattice value for variable VAR to VAL. Return true if VAL
+ is different from VAR's previous value. */
-static void
-simulate_block (basic_block block)
+static bool
+set_lattice_value (tree var, value val)
{
- tree phi;
-
- /* There is nothing to do for the exit block. */
- if (block == EXIT_BLOCK_PTR)
- return;
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\nSimulating block %d\n", block->index);
-
- /* Always simulate PHI nodes, even if we have simulated this block
- before. */
- for (phi = phi_nodes (block); phi; phi = PHI_CHAIN (phi))
- visit_phi_node (phi);
+ value *old = get_value (var);
- /* If this is the first time we've simulated this block, then we
- must simulate each of its statements. */
- if (!TEST_BIT (executable_blocks, block->index))
+#ifdef ENABLE_CHECKING
+ if (val.lattice_val == UNDEFINED)
{
- block_stmt_iterator j;
- unsigned int normal_edge_count;
- edge e, normal_edge;
-
- /* Note that we have simulated this block. */
- SET_BIT (executable_blocks, block->index);
-
- for (j = bsi_start (block); !bsi_end_p (j); bsi_next (&j))
- visit_stmt (bsi_stmt (j));
-
- /* We can not predict when abnormal edges will be executed, so
- once a block is considered executable, we consider any
- outgoing abnormal edges as executable.
-
- At the same time, if this block has only one successor that is
- reached by non-abnormal edges, then add that successor to the
- worklist. */
- normal_edge_count = 0;
- normal_edge = NULL;
- for (e = block->succ; e; e = e->succ_next)
- {
- if (e->flags & EDGE_ABNORMAL)
- {
- add_control_edge (e);
- }
- else
- {
- normal_edge_count++;
- normal_edge = e;
- }
- }
+ /* CONSTANT->UNDEFINED is never a valid state transition. */
+ if (old->lattice_val == CONSTANT)
+ abort ();
+
+ /* UNKNOWN_VAL->UNDEFINED is never a valid state transition. */
+ if (old->lattice_val == UNKNOWN_VAL)
+ abort ();
- if (normal_edge_count == 1)
- add_control_edge (normal_edge);
+ /* VARYING->UNDEFINED is generally not a valid state transition,
+ except for values which are initialized to VARYING. */
+ if (old->lattice_val == VARYING
+ && get_default_value (var).lattice_val != VARYING)
+ abort ();
}
-}
-
-
-/* Follow the def-use edges for statement DEF_STMT and simulate all the
- statements reached by it. */
-
-static void
-simulate_stmt (tree use_stmt)
-{
- basic_block use_bb = bb_for_stmt (use_stmt);
-
- if (dump_file && (dump_flags & TDF_DETAILS))
+ else if (val.lattice_val == CONSTANT)
{
- fprintf (dump_file, "\nSimulating statement (from ssa_edges): ");
- print_generic_stmt (dump_file, use_stmt, dump_flags);
+ /* VARYING -> CONSTANT is an invalid state transition, except
+ for objects which start off in a VARYING state. */
+ if (old->lattice_val == VARYING
+ && get_default_value (var).lattice_val != VARYING)
+ abort ();
}
+#endif
- if (TREE_CODE (use_stmt) == PHI_NODE)
+ /* If the constant for VAR has changed, then this VAR is really varying. */
+ if (old->lattice_val == CONSTANT
+ && val.lattice_val == CONSTANT
+ && !simple_cst_equal (old->const_val, val.const_val))
{
- /* PHI nodes are always visited, regardless of whether or not the
- destination block is executable. */
- visit_phi_node (use_stmt);
+ val.lattice_val = VARYING;
+ val.const_val = NULL_TREE;
}
- else if (TEST_BIT (executable_blocks, use_bb->index))
+
+ if (old->lattice_val != val.lattice_val)
{
- /* Otherwise, visit the statement containing the use reached by
- DEF, only if the destination block is marked executable. */
- visit_stmt (use_stmt);
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ dump_lattice_value (dump_file, "Lattice value changed to ", val);
+ fprintf (dump_file, ". Adding definition to SSA edges.\n");
+ }
+
+ *old = val;
+ return true;
}
+
+ return false;
}
-/* Perform final substitution and folding. After this pass the program
- should still be in SSA form. */
+/* Set the lattice value for the variable VAR to VARYING. */
static void
-substitute_and_fold (void)
+def_to_varying (tree var)
{
- basic_block bb;
+ value val;
+ val.lattice_val = VARYING;
+ val.const_val = NULL_TREE;
+ set_lattice_value (var, val);
+}
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file,
- "\nSubstituing constants and folding statements\n\n");
- /* Substitute constants in every statement of every basic block. */
- FOR_EACH_BB (bb)
- {
- block_stmt_iterator i;
- tree phi;
+/* Return the likely latticevalue for STMT.
- /* Propagate our known constants into PHI nodes. */
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- int i;
+ If STMT has no operands, then return CONSTANT.
- for (i = 0; i < PHI_NUM_ARGS (phi); i++)
- {
- value *new_val;
- use_operand_p orig_p = PHI_ARG_DEF_PTR (phi, i);
- tree orig = USE_FROM_PTR (orig_p);
+ Else if any operands of STMT are undefined, then return UNDEFINED.
- if (! SSA_VAR_P (orig))
- break;
+ Else if any operands of STMT are constants, then return CONSTANT.
- new_val = get_value (orig);
- if (new_val->lattice_val == CONSTANT
- && may_propagate_copy (orig, new_val->const_val))
- SET_USE (orig_p, new_val->const_val);
- }
- }
+ Else return VARYING. */
- for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
- {
- bool replaced_address;
- tree stmt = bsi_stmt (i);
+static latticevalue
+likely_value (tree stmt)
+{
+ vuse_optype vuses;
+ int found_constant = 0;
+ stmt_ann_t ann;
+ tree use;
+ ssa_op_iter iter;
- /* Skip statements that have been folded already. */
- if (stmt_modified_p (stmt) || !is_exec_stmt (stmt))
- continue;
+ /* If the statement makes aliased loads or has volatile operands, it
+ won't fold to a constant value. */
+ ann = stmt_ann (stmt);
+ if (ann->makes_aliased_loads || ann->has_volatile_ops)
+ return VARYING;
- /* Replace the statement with its folded version and mark it
- folded. */
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "Line %d: replaced ", get_lineno (stmt));
- print_generic_stmt (dump_file, stmt, TDF_SLIM);
- }
+ /* A CALL_EXPR is assumed to be varying. This may be overly conservative,
+ in the presence of const and pure calls. */
+ if (get_call_expr_in (stmt) != NULL_TREE)
+ return VARYING;
- if (replace_uses_in (stmt, &replaced_address)
- || replace_vuse_in (stmt, &replaced_address))
- {
- bool changed = fold_stmt (bsi_stmt_ptr (i));
- stmt = bsi_stmt(i);
- /* If we folded a builtin function, we'll likely
- need to rename VDEFs. */
- if (replaced_address || changed)
- {
- mark_new_vars_to_rename (stmt, vars_to_rename);
- if (maybe_clean_eh_stmt (stmt))
- tree_purge_dead_eh_edges (bb);
- }
- else
- modify_stmt (stmt);
- }
+ get_stmt_operands (stmt);
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, " with ");
- print_generic_stmt (dump_file, stmt, TDF_SLIM);
- fprintf (dump_file, "\n");
- }
- }
+ FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
+ {
+ value *val = get_value (use);
+
+ if (val->lattice_val == UNDEFINED)
+ return UNDEFINED;
+
+ if (val->lattice_val == CONSTANT)
+ found_constant = 1;
+ }
+
+ vuses = VUSE_OPS (ann);
+
+ if (NUM_VUSES (vuses))
+ {
+ tree vuse = VUSE_OP (vuses, 0);
+ value *val = get_value (vuse);
+
+ if (val->lattice_val == UNKNOWN_VAL)
+ return UNKNOWN_VAL;
+
+#ifdef ENABLE_CHECKING
+ /* There should be no VUSE operands that are UNDEFINED. */
+ if (val->lattice_val == UNDEFINED)
+ abort ();
+#endif
+
+ if (val->lattice_val == CONSTANT)
+ found_constant = 1;
}
+
+ return ((found_constant || (!USE_OPS (ann) && !vuses)) ? CONSTANT : VARYING);
}
-/* Loop through the PHI_NODE's parameters for BLOCK and compare their
- lattice values to determine PHI_NODE's lattice value. The value of a
- PHI node is determined calling cp_lattice_meet() with all the arguments
- of the PHI node that are incoming via executable edges. */
+/* Function indicating whether we ought to include information for VAR
+ when calculating immediate uses. */
+
+static bool
+need_imm_uses_for (tree var)
+{
+ return get_value (var)->lattice_val != VARYING;
+}
+
+
+/* Initialize local data structures for CCP. */
static void
-visit_phi_node (tree phi)
+ccp_initialize (void)
{
- bool short_circuit = 0;
- value phi_val, *curr_val;
- int i;
+ basic_block bb;
+ sbitmap is_may_def;
- /* If the PHI node has already been deemed to be VARYING, don't simulate
- it again. */
- if (DONT_SIMULATE_AGAIN (phi))
- return;
+ value_vector = (value *) xmalloc (num_ssa_names * sizeof (value));
+ memset (value_vector, 0, num_ssa_names * sizeof (value));
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "\nVisiting PHI node: ");
- print_generic_expr (dump_file, phi, dump_flags);
- }
+ /* Set of SSA_NAMEs that are defined by a V_MAY_DEF. */
+ is_may_def = sbitmap_alloc (num_ssa_names);
+ sbitmap_zero (is_may_def);
- curr_val = get_value (PHI_RESULT (phi));
- switch (curr_val->lattice_val)
+ /* Initialize simulation flags for PHI nodes and statements. */
+ FOR_EACH_BB (bb)
{
- case VARYING:
- if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "\n Shortcircuit. Default of VARYING.");
- short_circuit = 1;
- break;
+ block_stmt_iterator i;
- case CONSTANT:
- phi_val = *curr_val;
- break;
+ /* Mark all V_MAY_DEF operands VARYING. */
+ for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
+ {
+ bool is_varying = false;
+ tree stmt = bsi_stmt (i);
+ ssa_op_iter iter;
+ tree def;
- case UNKNOWN_VAL:
- /* To avoid the default value of UNKNOWN_VAL overriding
- that of its possible constant arguments, temporarily
- set the phi node's default lattice value to be
- UNDEFINED. At the same time, place something other
- than NULL_TREE in phi_val.const_val as a flag to
- check when setting a new state for this phi node to
- ensure that we avoid incorrect state transitions from
- UNKNOWN_VAL to UNDEFINED. */
- phi_val.lattice_val = UNDEFINED;
- phi_val.const_val = phi;
- break;
+ get_stmt_operands (stmt);
- case UNDEFINED:
- case UNINITIALIZED:
- phi_val.lattice_val = UNDEFINED;
- phi_val.const_val = NULL_TREE;
- break;
+ /* Get the default value for each DEF and V_MUST_DEF. */
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter,
+ (SSA_OP_DEF | SSA_OP_VMUSTDEF))
+ {
+ if (get_value (def)->lattice_val == VARYING)
+ is_varying = true;
+ }
- default:
- abort ();
+ /* Mark all V_MAY_DEF operands VARYING. */
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMAYDEF)
+ {
+ get_value (def)->lattice_val = VARYING;
+ SET_BIT (is_may_def, SSA_NAME_VERSION (def));
+ }
+
+ /* Statements other than MODIFY_EXPR, COND_EXPR and
+ SWITCH_EXPR are not interesting for constant propagation.
+ Mark them VARYING. */
+ if (TREE_CODE (stmt) != MODIFY_EXPR
+ && TREE_CODE (stmt) != COND_EXPR
+ && TREE_CODE (stmt) != SWITCH_EXPR)
+ is_varying = true;
+
+ DONT_SIMULATE_AGAIN (stmt) = is_varying;
+ }
}
- /* If the variable is volatile or the variable is never referenced in a
- real operand, then consider the PHI node VARYING. */
- if (short_circuit || TREE_THIS_VOLATILE (SSA_NAME_VAR (PHI_RESULT (phi))))
+ /* Now process PHI nodes. */
+ FOR_EACH_BB (bb)
{
- phi_val.lattice_val = VARYING;
- phi_val.const_val = NULL;
+ tree phi, var;
+ int x;
+
+ for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+ {
+ value *val = get_value (PHI_RESULT (phi));
+
+ for (x = 0; x < PHI_NUM_ARGS (phi); x++)
+ {
+ var = PHI_ARG_DEF (phi, x);
+
+ /* If one argument has a V_MAY_DEF, the result is
+ VARYING. */
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ if (TEST_BIT (is_may_def, SSA_NAME_VERSION (var)))
+ {
+ val->lattice_val = VARYING;
+ SET_BIT (is_may_def, SSA_NAME_VERSION (PHI_RESULT (phi)));
+ break;
+ }
+ }
+ }
+
+ DONT_SIMULATE_AGAIN (phi) = (val->lattice_val == VARYING);
+ }
}
- else
- for (i = 0; i < PHI_NUM_ARGS (phi); i++)
- {
- /* Compute the meet operator over all the PHI arguments. */
- edge e = PHI_ARG_EDGE (phi, i);
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file,
- "\n Argument #%d (%d -> %d %sexecutable)\n",
- i, e->src->index, e->dest->index,
- (e->flags & EDGE_EXECUTABLE) ? "" : "not ");
- }
+ sbitmap_free (is_may_def);
- /* If the incoming edge is executable, Compute the meet operator for
- the existing value of the PHI node and the current PHI argument. */
- if (e->flags & EDGE_EXECUTABLE)
- {
- tree rdef = PHI_ARG_DEF (phi, i);
- value *rdef_val, val;
+ /* Compute immediate uses for variables we care about. */
+ compute_immediate_uses (TDFA_USE_OPS | TDFA_USE_VOPS, need_imm_uses_for);
+}
- if (is_gimple_min_invariant (rdef))
- {
- val.lattice_val = CONSTANT;
- val.const_val = rdef;
- rdef_val = &val;
- }
- else
- rdef_val = get_value (rdef);
- phi_val = cp_lattice_meet (phi_val, *rdef_val);
+/* Replace USE references in statement STMT with their immediate reaching
+ definition. Return true if at least one reference was replaced. If
+ REPLACED_ADDRESSES_P is given, it will be set to true if an address
+ constant was replaced. */
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- fprintf (dump_file, "\t");
- print_generic_expr (dump_file, rdef, dump_flags);
- dump_lattice_value (dump_file, "\tValue: ", *rdef_val);
- fprintf (dump_file, "\n");
- }
+static bool
+replace_uses_in (tree stmt, bool *replaced_addresses_p)
+{
+ bool replaced = false;
+ use_operand_p use;
+ ssa_op_iter iter;
- if (phi_val.lattice_val == VARYING)
- break;
- }
- }
+ if (replaced_addresses_p)
+ *replaced_addresses_p = false;
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- dump_lattice_value (dump_file, "\n PHI node value: ", phi_val);
- fprintf (dump_file, "\n\n");
- }
+ get_stmt_operands (stmt);
- /* Check for an invalid change from UNKNOWN_VAL to UNDEFINED. */
- if (phi_val.lattice_val != UNDEFINED || phi_val.const_val == NULL_TREE)
+ FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE)
{
- set_lattice_value (PHI_RESULT (phi), phi_val);
- if (phi_val.lattice_val == VARYING)
- DONT_SIMULATE_AGAIN (phi) = 1;
+ value *val = get_value (USE_FROM_PTR (use));
+
+ if (val->lattice_val == CONSTANT)
+ {
+ SET_USE (use, val->const_val);
+ replaced = true;
+ if (POINTER_TYPE_P (TREE_TYPE (USE_FROM_PTR (use)))
+ && replaced_addresses_p)
+ *replaced_addresses_p = true;
+ }
}
+
+ return replaced;
}
-/* Compute the meet operator between VAL1 and VAL2:
+/* Replace the VUSE references in statement STMT with its immediate reaching
+ definition. Return true if the reference was replaced. If
+ REPLACED_ADDRESSES_P is given, it will be set to true if an address
+ constant was replaced. */
- any M UNDEFINED = any
- any M VARYING = VARYING
- any M UNKNOWN_VAL = UNKNOWN_VAL
- Ci M Cj = Ci if (i == j)
- Ci M Cj = VARYING if (i != j) */
-static value
-cp_lattice_meet (value val1, value val2)
+static bool
+replace_vuse_in (tree stmt, bool *replaced_addresses_p)
{
- value result;
+ bool replaced = false;
+ vuse_optype vuses;
+ use_operand_p vuse;
+ value *val;
- /* any M UNDEFINED = any. */
- if (val1.lattice_val == UNDEFINED)
- return val2;
- else if (val2.lattice_val == UNDEFINED)
- return val1;
+ if (replaced_addresses_p)
+ *replaced_addresses_p = false;
- /* any M VARYING = VARYING. */
- if (val1.lattice_val == VARYING || val2.lattice_val == VARYING)
- {
- result.lattice_val = VARYING;
- result.const_val = NULL_TREE;
- return result;
- }
+ get_stmt_operands (stmt);
- /* any M UNKNOWN_VAL = UNKNOWN_VAL. */
- if (val1.lattice_val == UNKNOWN_VAL
- || val2.lattice_val == UNKNOWN_VAL)
- {
- result.lattice_val = UNKNOWN_VAL;
- result.const_val = NULL_TREE;
- return result;
- }
+ vuses = STMT_VUSE_OPS (stmt);
- /* Ci M Cj = Ci if (i == j)
- Ci M Cj = VARYING if (i != j) */
- if (simple_cst_equal (val1.const_val, val2.const_val) == 1)
- {
- result.lattice_val = CONSTANT;
- result.const_val = val1.const_val;
- }
- else
+ if (NUM_VUSES (vuses) != 1)
+ return false;
+
+ vuse = VUSE_OP_PTR (vuses, 0);
+ val = get_value (USE_FROM_PTR (vuse));
+
+ if (val->lattice_val == CONSTANT
+ && TREE_CODE (stmt) == MODIFY_EXPR
+ && DECL_P (TREE_OPERAND (stmt, 1))
+ && TREE_OPERAND (stmt, 1) == SSA_NAME_VAR (USE_FROM_PTR (vuse)))
{
- result.lattice_val = VARYING;
- result.const_val = NULL_TREE;
+ TREE_OPERAND (stmt, 1) = val->const_val;
+ replaced = true;
+ if (POINTER_TYPE_P (TREE_TYPE (USE_FROM_PTR (vuse)))
+ && replaced_addresses_p)
+ *replaced_addresses_p = true;
}
- return result;
+ return replaced;
}
-/* Evaluate statement STMT. If the statement produces an output value and
- its evaluation changes the lattice value of its output, do the following:
-
- - If the statement is an assignment, add all the SSA edges starting at
- this definition.
-
- - If the statement is a conditional branch:
- . If the statement evaluates to non-constant, add all edges to
- worklist.
- . If the statement is constant, add the edge executed as the
- result of the branch. */
+/* Perform final substitution and folding. After this pass the program
+ should still be in SSA form. */
static void
-visit_stmt (tree stmt)
+substitute_and_fold (void)
{
- stmt_ann_t ann;
- v_may_def_optype v_may_defs;
- v_must_def_optype v_must_defs;
- tree def;
- ssa_op_iter iter;
-
- /* If the statement has already been deemed to be VARYING, don't simulate
- it again. */
- if (DONT_SIMULATE_AGAIN (stmt))
- return;
+ basic_block bb;
if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file,
+ "\nSubstituing constants and folding statements\n\n");
+
+ /* Substitute constants in every statement of every basic block. */
+ FOR_EACH_BB (bb)
{
- fprintf (dump_file, "\nVisiting statement: ");
- print_generic_stmt (dump_file, stmt, TDF_SLIM);
- fprintf (dump_file, "\n");
- }
+ block_stmt_iterator i;
+ tree phi;
- ann = stmt_ann (stmt);
+ /* Propagate our known constants into PHI nodes. */
+ for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
+ {
+ int i;
- /* If this statement is already in the worklist then "cancel" it. The
- reevaluation implied by the worklist entry will produce the same
- value we generate here and thus reevaluating it again from the
- worklist is pointless. */
- if (ann->in_ccp_worklist)
- ann->in_ccp_worklist = 0;
+ for (i = 0; i < PHI_NUM_ARGS (phi); i++)
+ {
+ value *new_val;
+ use_operand_p orig_p = PHI_ARG_DEF_PTR (phi, i);
+ tree orig = USE_FROM_PTR (orig_p);
- /* Now examine the statement. If the statement is an assignment that
- produces a single output value, evaluate its RHS to see if the lattice
- value of its output has changed. */
- v_must_defs = V_MUST_DEF_OPS (ann);
- v_may_defs = V_MAY_DEF_OPS (ann);
- if (TREE_CODE (stmt) == MODIFY_EXPR
- && NUM_V_MAY_DEFS (v_may_defs) == 0
- && (NUM_V_MUST_DEFS (v_must_defs) == 1
- || TREE_CODE (TREE_OPERAND (stmt, 0)) == SSA_NAME))
- visit_assignment (stmt);
+ if (! SSA_VAR_P (orig))
+ break;
- /* Definitions made by statements other than assignments to SSA_NAMEs
- represent unknown modifications to their outputs. Mark them VARYING. */
- else if (NUM_DEFS (DEF_OPS (ann)) != 0)
- {
- DONT_SIMULATE_AGAIN (stmt) = 1;
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
- {
- def_to_varying (def);
+ new_val = get_value (orig);
+ if (new_val->lattice_val == CONSTANT
+ && may_propagate_copy (orig, new_val->const_val))
+ SET_USE (orig_p, new_val->const_val);
+ }
}
- }
- /* If STMT is a conditional branch, see if we can determine which branch
- will be taken. */
- else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
- visit_cond_stmt (stmt);
+ for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
+ {
+ bool replaced_address;
+ tree stmt = bsi_stmt (i);
- /* Any other kind of statement is not interesting for constant
- propagation and, therefore, not worth simulating. */
- else
- {
- DONT_SIMULATE_AGAIN (stmt) = 1;
+ /* Skip statements that have been folded already. */
+ if (stmt_modified_p (stmt) || !is_exec_stmt (stmt))
+ continue;
- /* If STMT is a computed goto, then mark all the output edges
- executable. */
- if (computed_goto_p (stmt))
- add_outgoing_control_edges (bb_for_stmt (stmt));
- }
+ /* Replace the statement with its folded version and mark it
+ folded. */
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Line %d: replaced ", get_lineno (stmt));
+ print_generic_stmt (dump_file, stmt, TDF_SLIM);
+ }
- /* Mark all V_MAY_DEF operands VARYING. */
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMAYDEF)
- def_to_varying (def);
-
+ if (replace_uses_in (stmt, &replaced_address)
+ || replace_vuse_in (stmt, &replaced_address))
+ {
+ bool changed = fold_stmt (bsi_stmt_ptr (i));
+ stmt = bsi_stmt(i);
+ /* If we folded a builtin function, we'll likely
+ need to rename VDEFs. */
+ if (replaced_address || changed)
+ {
+ mark_new_vars_to_rename (stmt, vars_to_rename);
+ if (maybe_clean_eh_stmt (stmt))
+ tree_purge_dead_eh_edges (bb);
+ }
+ else
+ modify_stmt (stmt);
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, " with ");
+ print_generic_stmt (dump_file, stmt, TDF_SLIM);
+ fprintf (dump_file, "\n");
+ }
+ }
+ }
}
-/* Visit the assignment statement STMT. Set the value of its LHS to the
- value computed by the RHS. */
+/* Free allocated storage. */
static void
-visit_assignment (tree stmt)
+ccp_finalize (void)
{
- value val;
- tree lhs, rhs;
- vuse_optype vuses;
- v_must_def_optype v_must_defs;
+ /* Perform substitutions based on the known constant values. */
+ substitute_and_fold ();
- lhs = TREE_OPERAND (stmt, 0);
- rhs = TREE_OPERAND (stmt, 1);
- vuses = STMT_VUSE_OPS (stmt);
- v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
+ /* Now cleanup any unreachable code. */
+ cleanup_tree_cfg ();
-#if defined ENABLE_CHECKING
- if (NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) > 0
- || (NUM_V_MUST_DEFS (v_must_defs) != 1
- && TREE_CODE (lhs) != SSA_NAME))
- abort ();
-#endif
+ free (value_vector);
+}
- /* We require the SSA version number of the lhs for the value_vector.
- Make sure we have it. */
- if (TREE_CODE (lhs) != SSA_NAME)
- {
- /* If we make it here, then stmt only has one definition:
- a V_MUST_DEF. */
- lhs = V_MUST_DEF_OP (v_must_defs, 0);
- }
- if (TREE_CODE (rhs) == SSA_NAME)
- {
- /* For a simple copy operation, we copy the lattice values. */
- value *nval = get_value (rhs);
- val = *nval;
- }
- else if (DECL_P (rhs)
- && NUM_VUSES (vuses) == 1
- && rhs == SSA_NAME_VAR (VUSE_OP (vuses, 0)))
- {
- /* Same as above, but the rhs is not a gimple register and yet
- has a known VUSE. */
- value *nval = get_value (VUSE_OP (vuses, 0));
- val = *nval;
- }
- else
+
+/* Compute the meet operator between VAL1 and VAL2:
+
+ any M UNDEFINED = any
+ any M VARYING = VARYING
+ any M UNKNOWN_VAL = UNKNOWN_VAL
+ Ci M Cj = Ci if (i == j)
+ Ci M Cj = VARYING if (i != j) */
+static value
+ccp_lattice_meet (value val1, value val2)
+{
+ value result;
+
+ /* any M UNDEFINED = any. */
+ if (val1.lattice_val == UNDEFINED)
+ return val2;
+ else if (val2.lattice_val == UNDEFINED)
+ return val1;
+
+ /* any M VARYING = VARYING. */
+ if (val1.lattice_val == VARYING || val2.lattice_val == VARYING)
{
- /* Evaluate the statement. */
- val = evaluate_stmt (stmt);
+ result.lattice_val = VARYING;
+ result.const_val = NULL_TREE;
+ return result;
}
- /* FIXME: Hack. If this was a definition of a bitfield, we need to widen
- the constant value into the type of the destination variable. This
- should not be necessary if GCC represented bitfields properly. */
- {
- tree lhs = TREE_OPERAND (stmt, 0);
- if (val.lattice_val == CONSTANT
- && TREE_CODE (lhs) == COMPONENT_REF
- && DECL_BIT_FIELD (TREE_OPERAND (lhs, 1)))
- {
- tree w = widen_bitfield (val.const_val, TREE_OPERAND (lhs, 1), lhs);
-
- if (w && is_gimple_min_invariant (w))
- val.const_val = w;
- else
- {
- val.lattice_val = VARYING;
- val.const_val = NULL;
- }
- }
- }
+ /* any M UNKNOWN_VAL = UNKNOWN_VAL. */
+ if (val1.lattice_val == UNKNOWN_VAL
+ || val2.lattice_val == UNKNOWN_VAL)
+ {
+ result.lattice_val = UNKNOWN_VAL;
+ result.const_val = NULL_TREE;
+ return result;
+ }
- /* If LHS is not a gimple register, then it cannot take on an
- UNDEFINED value. */
- if (!is_gimple_reg (SSA_NAME_VAR (lhs))
- && val.lattice_val == UNDEFINED)
- val.lattice_val = UNKNOWN_VAL;
+ /* Ci M Cj = Ci if (i == j)
+ Ci M Cj = VARYING if (i != j) */
+ if (simple_cst_equal (val1.const_val, val2.const_val) == 1)
+ {
+ result.lattice_val = CONSTANT;
+ result.const_val = val1.const_val;
+ }
+ else
+ {
+ result.lattice_val = VARYING;
+ result.const_val = NULL_TREE;
+ }
- /* Set the lattice value of the statement's output. */
- set_lattice_value (lhs, val);
- if (val.lattice_val == VARYING)
- DONT_SIMULATE_AGAIN (stmt) = 1;
+ return result;
}
-/* Visit the conditional statement STMT. If it evaluates to a constant value,
- mark outgoing edges appropriately. */
+/* Loop through the PHI_NODE's parameters for BLOCK and compare their
+ lattice values to determine PHI_NODE's lattice value. The value of a
+ PHI node is determined calling ccp_lattice_meet() with all the arguments
+ of the PHI node that are incoming via executable edges. */
-static void
-visit_cond_stmt (tree stmt)
+static enum ssa_prop_result
+ccp_visit_phi_node (tree phi)
{
- edge e;
- value val;
- basic_block block;
-
- block = bb_for_stmt (stmt);
- val = evaluate_stmt (stmt);
+ value new_val, *old_val;
+ int i;
- /* Find which edge out of the conditional block will be taken and add it
- to the worklist. If no single edge can be determined statically, add
- all outgoing edges from BLOCK. */
- e = find_taken_edge (block, val.const_val);
- if (e)
- add_control_edge (e);
- else
+ if (dump_file && (dump_flags & TDF_DETAILS))
{
- DONT_SIMULATE_AGAIN (stmt) = 1;
- add_outgoing_control_edges (block);
+ fprintf (dump_file, "\nVisiting PHI node: ");
+ print_generic_expr (dump_file, phi, dump_flags);
}
-}
+ old_val = get_value (PHI_RESULT (phi));
+ switch (old_val->lattice_val)
+ {
+ case VARYING:
+ return SSA_PROP_NOT_INTERESTING;
-/* Add all the edges coming out of BB to the control flow worklist. */
+ case CONSTANT:
+ new_val = *old_val;
+ break;
-static void
-add_outgoing_control_edges (basic_block bb)
-{
- edge e;
+ case UNKNOWN_VAL:
+ /* To avoid the default value of UNKNOWN_VAL overriding
+ that of its possible constant arguments, temporarily
+ set the PHI node's default lattice value to be
+ UNDEFINED. If the PHI node's old value was UNKNOWN_VAL and
+ the new value is UNDEFINED, then we prevent the invalid
+ transition by not calling set_lattice_value. */
+ new_val.lattice_val = UNDEFINED;
+ new_val.const_val = NULL_TREE;
+ break;
- for (e = bb->succ; e; e = e->succ_next)
- add_control_edge (e);
-}
+ case UNDEFINED:
+ case UNINITIALIZED:
+ new_val.lattice_val = UNDEFINED;
+ new_val.const_val = NULL_TREE;
+ break;
+ default:
+ abort ();
+ }
-/* Add edge E to the control flow worklist. */
+ for (i = 0; i < PHI_NUM_ARGS (phi); i++)
+ {
+ /* Compute the meet operator over all the PHI arguments. */
+ edge e = PHI_ARG_EDGE (phi, i);
-static void
-add_control_edge (edge e)
-{
- basic_block bb = e->dest;
- if (bb == EXIT_BLOCK_PTR)
- return;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file,
+ "\n Argument #%d (%d -> %d %sexecutable)\n",
+ i, e->src->index, e->dest->index,
+ (e->flags & EDGE_EXECUTABLE) ? "" : "not ");
+ }
+
+ /* If the incoming edge is executable, Compute the meet operator for
+ the existing value of the PHI node and the current PHI argument. */
+ if (e->flags & EDGE_EXECUTABLE)
+ {
+ tree rdef = PHI_ARG_DEF (phi, i);
+ value *rdef_val, val;
- /* If the edge had already been executed, skip it. */
- if (e->flags & EDGE_EXECUTABLE)
- return;
+ if (is_gimple_min_invariant (rdef))
+ {
+ val.lattice_val = CONSTANT;
+ val.const_val = rdef;
+ rdef_val = &val;
+ }
+ else
+ rdef_val = get_value (rdef);
- e->flags |= EDGE_EXECUTABLE;
+ new_val = ccp_lattice_meet (new_val, *rdef_val);
- /* If the block is already in the list, we're done. */
- if (TEST_BIT (bb_in_list, bb->index))
- return;
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "\t");
+ print_generic_expr (dump_file, rdef, dump_flags);
+ dump_lattice_value (dump_file, "\tValue: ", *rdef_val);
+ fprintf (dump_file, "\n");
+ }
- cfg_blocks_add (bb);
+ if (new_val.lattice_val == VARYING)
+ break;
+ }
+ }
if (dump_file && (dump_flags & TDF_DETAILS))
- fprintf (dump_file, "Adding Destination of edge (%d -> %d) to worklist\n\n",
- e->src->index, e->dest->index);
+ {
+ dump_lattice_value (dump_file, "\n PHI node value: ", new_val);
+ fprintf (dump_file, "\n\n");
+ }
+
+ /* Check for an invalid change from UNKNOWN_VAL to UNDEFINED. */
+ if (old_val->lattice_val == UNKNOWN_VAL
+ && new_val.lattice_val == UNDEFINED)
+ return SSA_PROP_NOT_INTERESTING;
+
+ /* Otherwise, make the transition to the new value. */
+ if (set_lattice_value (PHI_RESULT (phi), new_val))
+ {
+ if (new_val.lattice_val == VARYING)
+ return SSA_PROP_VARYING;
+ else
+ return SSA_PROP_INTERESTING;
+ }
+ else
+ return SSA_PROP_NOT_INTERESTING;
}
-/* CCP specific front-end to the non-destructive constant folding routines.
+/* CCP specific front-end to the non-destructive constant folding
+ routines.
Attempt to simplify the RHS of STMT knowing that one or more
operands are constants.
had undefined or virtual operands, then the result of the
statement should be undefined or virtual respectively.
Else the result of the statement is VARYING. */
- val.lattice_val = (likelyvalue == UNDEFINED ? UNDEFINED : VARYING);
- val.lattice_val = (likelyvalue == UNKNOWN_VAL
- ? UNKNOWN_VAL : val.lattice_val);
- val.const_val = NULL_TREE;
- }
-
- return val;
-}
-
-
-/* Debugging dumps. */
-
-static void
-dump_lattice_value (FILE *outf, const char *prefix, value val)
-{
- switch (val.lattice_val)
- {
- case UNDEFINED:
- fprintf (outf, "%sUNDEFINED", prefix);
- break;
- case VARYING:
- fprintf (outf, "%sVARYING", prefix);
- break;
- case UNKNOWN_VAL:
- fprintf (outf, "%sUNKNOWN_VAL", prefix);
- break;
- case CONSTANT:
- fprintf (outf, "%sCONSTANT ", prefix);
- print_generic_expr (outf, val.const_val, dump_flags);
- break;
- default:
- abort ();
- }
-}
-
-/* Given a constant value VAL for bitfield FIELD, and a destination
- variable VAR, return VAL appropriately widened to fit into VAR. If
- FIELD is wider than HOST_WIDE_INT, NULL is returned. */
-
-tree
-widen_bitfield (tree val, tree field, tree var)
-{
- unsigned HOST_WIDE_INT var_size, field_size;
- tree wide_val;
- unsigned HOST_WIDE_INT mask;
- unsigned int i;
-
- /* We can only do this if the size of the type and field and VAL are
- all constants representable in HOST_WIDE_INT. */
- if (!host_integerp (TYPE_SIZE (TREE_TYPE (var)), 1)
- || !host_integerp (DECL_SIZE (field), 1)
- || !host_integerp (val, 0))
- return NULL_TREE;
-
- var_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (var)), 1);
- field_size = tree_low_cst (DECL_SIZE (field), 1);
-
- /* Give up if either the bitfield or the variable are too wide. */
- if (field_size > HOST_BITS_PER_WIDE_INT || var_size > HOST_BITS_PER_WIDE_INT)
- return NULL_TREE;
-
-#if defined ENABLE_CHECKING
- if (var_size < field_size)
- abort ();
-#endif
-
- /* If the sign bit of the value is not set or the field's type is unsigned,
- just mask off the high order bits of the value. */
- if (DECL_UNSIGNED (field)
- || !(tree_low_cst (val, 0) & (((HOST_WIDE_INT)1) << (field_size - 1))))
- {
- /* Zero extension. Build a mask with the lower 'field_size' bits
- set and a BIT_AND_EXPR node to clear the high order bits of
- the value. */
- for (i = 0, mask = 0; i < field_size; i++)
- mask |= ((HOST_WIDE_INT) 1) << i;
-
- wide_val = build (BIT_AND_EXPR, TREE_TYPE (var), val,
- fold_convert (TREE_TYPE (var),
- build_int_cst (NULL_TREE, mask)));
- }
- else
- {
- /* Sign extension. Create a mask with the upper 'field_size'
- bits set and a BIT_IOR_EXPR to set the high order bits of the
- value. */
- for (i = 0, mask = 0; i < (var_size - field_size); i++)
- mask |= ((HOST_WIDE_INT) 1) << (var_size - i - 1);
-
- wide_val = build (BIT_IOR_EXPR, TREE_TYPE (var), val,
- fold_convert (TREE_TYPE (var),
- build_int_cst (NULL_TREE, mask)));
- }
-
- return fold (wide_val);
-}
-
-
-/* Function indicating whether we ought to include information for 'var'
- when calculating immediate uses. */
-
-static bool
-need_imm_uses_for (tree var)
-{
- return get_value (var)->lattice_val != VARYING;
-}
-
-
-/* Initialize local data structures and worklists for CCP. */
-
-static void
-initialize (void)
-{
- edge e;
- basic_block bb;
- sbitmap virtual_var;
- tree def;
- ssa_op_iter iter;
-
- /* Worklists of SSA edges. */
- VARRAY_TREE_INIT (ssa_edges, 20, "ssa_edges");
- VARRAY_TREE_INIT (varying_ssa_edges, 20, "varying_ssa_edges");
-
- executable_blocks = sbitmap_alloc (last_basic_block);
- sbitmap_zero (executable_blocks);
-
- bb_in_list = sbitmap_alloc (last_basic_block);
- sbitmap_zero (bb_in_list);
-
- value_vector = (value *) xmalloc (num_ssa_names * sizeof (value));
- memset (value_vector, 0, num_ssa_names * sizeof (value));
-
- /* 1 if ssa variable is used in a virtual variable context. */
- virtual_var = sbitmap_alloc (num_ssa_names);
- sbitmap_zero (virtual_var);
-
- /* Initialize default values and simulation flags for PHI nodes, statements
- and edges. */
- FOR_EACH_BB (bb)
- {
- block_stmt_iterator i;
- tree stmt;
- int vary;
-
- /* Get the default value for each definition. */
- for (i = bsi_start (bb); !bsi_end_p (i); bsi_next (&i))
- {
- vary = 0;
- stmt = bsi_stmt (i);
- get_stmt_operands (stmt);
-
- /* Get the default value for each DEF and V_MUST_DEF. */
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter,
- (SSA_OP_DEF | SSA_OP_VMUSTDEF))
- {
- if (get_value (def)->lattice_val == VARYING)
- vary = 1;
- }
-
- DONT_SIMULATE_AGAIN (stmt) = vary;
-
- /* Mark all V_MAY_DEF operands VARYING. */
- FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMAYDEF)
- {
- get_value (def)->lattice_val = VARYING;
- SET_BIT (virtual_var, SSA_NAME_VERSION (def));
- }
- }
-
- for (e = bb->succ; e; e = e->succ_next)
- e->flags &= ~EDGE_EXECUTABLE;
- }
-
- /* Now process PHI nodes. */
- FOR_EACH_BB (bb)
- {
- tree phi, var;
- int x;
- for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
- {
- value *val;
- val = get_value (PHI_RESULT (phi));
- if (val->lattice_val != VARYING)
- {
- for (x = 0; x < PHI_NUM_ARGS (phi); x++)
- {
- var = PHI_ARG_DEF (phi, x);
- /* If one argument has a V_MAY_DEF,
- the result is varying. */
- if (TREE_CODE (var) == SSA_NAME)
- {
- if (TEST_BIT (virtual_var, SSA_NAME_VERSION (var)))
- {
- val->lattice_val = VARYING;
- SET_BIT (virtual_var,
- SSA_NAME_VERSION (PHI_RESULT (phi)));
- break;
- }
- }
- }
- }
- DONT_SIMULATE_AGAIN (phi) = ((val->lattice_val == VARYING) ? 1 : 0);
- }
- }
-
- sbitmap_free (virtual_var);
- /* Compute immediate uses for variables we care about. */
- compute_immediate_uses (TDFA_USE_OPS | TDFA_USE_VOPS, need_imm_uses_for);
-
- if (dump_file && (dump_flags & TDF_DETAILS))
- dump_immediate_uses (dump_file);
-
- VARRAY_BB_INIT (cfg_blocks, 20, "cfg_blocks");
-
- /* Seed the algorithm by adding the successors of the entry block to the
- edge worklist. */
- for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
- {
- if (e->dest != EXIT_BLOCK_PTR)
- {
- e->flags |= EDGE_EXECUTABLE;
- cfg_blocks_add (e->dest);
- }
+ val.lattice_val = (likelyvalue == UNDEFINED ? UNDEFINED : VARYING);
+ val.lattice_val = (likelyvalue == UNKNOWN_VAL
+ ? UNKNOWN_VAL : val.lattice_val);
+ val.const_val = NULL_TREE;
}
+
+ return val;
}
-/* Free allocated storage. */
+/* Visit the assignment statement STMT. Set the value of its LHS to the
+ value computed by the RHS and store LHS in *OUTPUT_P. */
-static void
-finalize (void)
+static enum ssa_prop_result
+visit_assignment (tree stmt, tree *output_p)
{
- ssa_edges = NULL;
- varying_ssa_edges = NULL;
- cfg_blocks = NULL;
- free (value_vector);
- sbitmap_free (bb_in_list);
- sbitmap_free (executable_blocks);
- free_df ();
-}
-
-/* Is the block worklist empty. */
+ value val;
+ tree lhs, rhs;
+ vuse_optype vuses;
+ v_must_def_optype v_must_defs;
-static inline bool
-cfg_blocks_empty_p (void)
-{
- return (cfg_blocks_num == 0);
-}
+ lhs = TREE_OPERAND (stmt, 0);
+ rhs = TREE_OPERAND (stmt, 1);
+ vuses = STMT_VUSE_OPS (stmt);
+ v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
-/* Add a basic block to the worklist. */
+#if defined ENABLE_CHECKING
+ if (NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) > 0
+ || (NUM_V_MUST_DEFS (v_must_defs) != 1
+ && TREE_CODE (lhs) != SSA_NAME))
+ abort ();
+#endif
-static void
-cfg_blocks_add (basic_block bb)
-{
- if (bb == ENTRY_BLOCK_PTR || bb == EXIT_BLOCK_PTR)
- return;
+ /* We require the SSA version number of the lhs for the value_vector.
+ Make sure we have it. */
+ if (TREE_CODE (lhs) != SSA_NAME)
+ {
+ /* If we make it here, then stmt only has one definition:
+ a V_MUST_DEF. */
+ lhs = V_MUST_DEF_OP (v_must_defs, 0);
+ }
- if (TEST_BIT (bb_in_list, bb->index))
- return;
+ if (TREE_CODE (rhs) == SSA_NAME)
+ {
+ /* For a simple copy operation, we copy the lattice values. */
+ value *nval = get_value (rhs);
+ val = *nval;
+ }
+ else if (DECL_P (rhs)
+ && NUM_VUSES (vuses) == 1
+ && rhs == SSA_NAME_VAR (VUSE_OP (vuses, 0)))
+ {
+ /* Same as above, but the rhs is not a gimple register and yet
+ has a known VUSE. */
+ value *nval = get_value (VUSE_OP (vuses, 0));
+ val = *nval;
+ }
+ else
+ {
+ /* Evaluate the statement. */
+ val = evaluate_stmt (stmt);
+ }
- if (cfg_blocks_empty_p ())
- {
- cfg_blocks_tail = cfg_blocks_head = 0;
- cfg_blocks_num = 1;
- }
- else
+ /* FIXME: Hack. If this was a definition of a bitfield, we need to widen
+ the constant value into the type of the destination variable. This
+ should not be necessary if GCC represented bitfields properly. */
+ {
+ tree lhs = TREE_OPERAND (stmt, 0);
+ if (val.lattice_val == CONSTANT
+ && TREE_CODE (lhs) == COMPONENT_REF
+ && DECL_BIT_FIELD (TREE_OPERAND (lhs, 1)))
{
- cfg_blocks_num++;
- if (cfg_blocks_num > VARRAY_SIZE (cfg_blocks))
+ tree w = widen_bitfield (val.const_val, TREE_OPERAND (lhs, 1), lhs);
+
+ if (w && is_gimple_min_invariant (w))
+ val.const_val = w;
+ else
{
- /* We have to grow the array now. Adjust to queue to occupy the
- full space of the original array. */
- cfg_blocks_tail = VARRAY_SIZE (cfg_blocks);
- cfg_blocks_head = 0;
- VARRAY_GROW (cfg_blocks, 2 * VARRAY_SIZE (cfg_blocks));
+ val.lattice_val = VARYING;
+ val.const_val = NULL;
}
- else
- cfg_blocks_tail = (cfg_blocks_tail + 1) % VARRAY_SIZE (cfg_blocks);
}
- VARRAY_BB (cfg_blocks, cfg_blocks_tail) = bb;
- SET_BIT (bb_in_list, bb->index);
-}
-
-/* Remove a block from the worklist. */
-
-static basic_block
-cfg_blocks_get (void)
-{
- basic_block bb;
-
- bb = VARRAY_BB (cfg_blocks, cfg_blocks_head);
-
-#ifdef ENABLE_CHECKING
- if (cfg_blocks_empty_p () || !bb)
- abort ();
-#endif
-
- cfg_blocks_head = (cfg_blocks_head + 1) % VARRAY_SIZE (cfg_blocks);
- --cfg_blocks_num;
- RESET_BIT (bb_in_list, bb->index);
-
- return bb;
-}
+ }
-/* We have just defined a new value for VAR. Add all immediate uses
- of VAR to the ssa_edges or varying_ssa_edges worklist. */
-static void
-add_var_to_ssa_edges_worklist (tree var, value val)
-{
- tree stmt = SSA_NAME_DEF_STMT (var);
- dataflow_t df = get_immediate_uses (stmt);
- int num_uses = num_immediate_uses (df);
- int i;
+ /* If LHS is not a gimple register, then it cannot take on an
+ UNDEFINED value. */
+ if (!is_gimple_reg (SSA_NAME_VAR (lhs))
+ && val.lattice_val == UNDEFINED)
+ val.lattice_val = UNKNOWN_VAL;
- for (i = 0; i < num_uses; i++)
+ /* Set the lattice value of the statement's output. */
+ if (set_lattice_value (lhs, val))
{
- tree use = immediate_use (df, i);
-
- if (!DONT_SIMULATE_AGAIN (use))
- {
- stmt_ann_t ann = stmt_ann (use);
- if (ann->in_ccp_worklist == 0)
- {
- ann->in_ccp_worklist = 1;
- if (val.lattice_val == VARYING)
- VARRAY_PUSH_TREE (varying_ssa_edges, use);
- else
- VARRAY_PUSH_TREE (ssa_edges, use);
- }
- }
+ *output_p = lhs;
+ if (val.lattice_val == VARYING)
+ return SSA_PROP_VARYING;
+ else
+ return SSA_PROP_INTERESTING;
}
+ else
+ return SSA_PROP_NOT_INTERESTING;
}
-/* Set the lattice value for the variable VAR to VARYING. */
-static void
-def_to_varying (tree var)
+/* Visit the conditional statement STMT. Return SSA_PROP_INTERESTING
+ if it can determine which edge will be taken. Otherwise, return
+ SSA_PROP_VARYING. */
+
+static enum ssa_prop_result
+visit_cond_stmt (tree stmt, edge *taken_edge_p)
{
value val;
- val.lattice_val = VARYING;
- val.const_val = NULL_TREE;
- set_lattice_value (var, val);
+ basic_block block;
+
+ block = bb_for_stmt (stmt);
+ val = evaluate_stmt (stmt);
+
+ /* Find which edge out of the conditional block will be taken and add it
+ to the worklist. If no single edge can be determined statically,
+ return SSA_PROP_VARYING to feed all the outgoing edges to the
+ propagation engine. */
+ *taken_edge_p = find_taken_edge (block, val.const_val);
+ if (*taken_edge_p)
+ return SSA_PROP_INTERESTING;
+ else
+ return SSA_PROP_VARYING;
}
-/* Set the lattice value for variable VAR to VAL. */
-static void
-set_lattice_value (tree var, value val)
-{
- value *old = get_value (var);
+/* Evaluate statement STMT. If the statement produces an output value and
+ its evaluation changes the lattice value of its output, return
+ SSA_PROP_INTERESTING and set *OUTPUT_P to the SSA_NAME holding the
+ output value.
+
+ If STMT is a conditional branch and we can determine its truth
+ value, set *TAKEN_EDGE_P accordingly. If STMT produces a varying
+ value, return SSA_PROP_VARYING. */
-#ifdef ENABLE_CHECKING
- if (val.lattice_val == UNDEFINED)
- {
- /* CONSTANT->UNDEFINED is never a valid state transition. */
- if (old->lattice_val == CONSTANT)
- abort ();
-
- /* UNKNOWN_VAL->UNDEFINED is never a valid state transition. */
- if (old->lattice_val == UNKNOWN_VAL)
- abort ();
+static enum ssa_prop_result
+ccp_visit_stmt (tree stmt, edge *taken_edge_p, tree *output_p)
+{
+ stmt_ann_t ann;
+ v_may_def_optype v_may_defs;
+ v_must_def_optype v_must_defs;
+ tree def;
+ ssa_op_iter iter;
- /* VARYING->UNDEFINED is generally not a valid state transition,
- except for values which are initialized to VARYING. */
- if (old->lattice_val == VARYING
- && get_default_value (var).lattice_val != VARYING)
- abort ();
- }
- else if (val.lattice_val == CONSTANT)
+ if (dump_file && (dump_flags & TDF_DETAILS))
{
- /* VARYING -> CONSTANT is an invalid state transition, except
- for objects which start off in a VARYING state. */
- if (old->lattice_val == VARYING
- && get_default_value (var).lattice_val != VARYING)
- abort ();
+ fprintf (dump_file, "\nVisiting statement: ");
+ print_generic_stmt (dump_file, stmt, TDF_SLIM);
+ fprintf (dump_file, "\n");
}
-#endif
- /* If the constant for VAR has changed, then this VAR is really varying. */
- if (old->lattice_val == CONSTANT && val.lattice_val == CONSTANT
- && !simple_cst_equal (old->const_val, val.const_val))
+ ann = stmt_ann (stmt);
+
+ v_must_defs = V_MUST_DEF_OPS (ann);
+ v_may_defs = V_MAY_DEF_OPS (ann);
+ if (TREE_CODE (stmt) == MODIFY_EXPR
+ && NUM_V_MAY_DEFS (v_may_defs) == 0
+ && (NUM_V_MUST_DEFS (v_must_defs) == 1
+ || TREE_CODE (TREE_OPERAND (stmt, 0)) == SSA_NAME))
{
- val.lattice_val = VARYING;
- val.const_val = NULL_TREE;
+ /* If the statement is an assignment that produces a single
+ output value, evaluate its RHS to see if the lattice value of
+ its output has changed. */
+ return visit_assignment (stmt, output_p);
}
-
- if (old->lattice_val != val.lattice_val)
+ else if (TREE_CODE (stmt) == COND_EXPR || TREE_CODE (stmt) == SWITCH_EXPR)
{
- if (dump_file && (dump_flags & TDF_DETAILS))
- {
- dump_lattice_value (dump_file,
- "Lattice value changed to ", val);
- fprintf (dump_file, ". Adding definition to SSA edges.\n");
- }
-
- add_var_to_ssa_edges_worklist (var, val);
- *old = val;
+ /* If STMT is a conditional branch, see if we can determine
+ which branch will be taken. */
+ return visit_cond_stmt (stmt, taken_edge_p);
}
-}
-/* Replace USE references in statement STMT with their immediate reaching
- definition. Return true if at least one reference was replaced. If
- REPLACED_ADDRESSES_P is given, it will be set to true if an address
- constant was replaced. */
+ /* Any other kind of statement is not interesting for constant
+ propagation and, therefore, not worth simulating. */
+#if 0
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "No interesting values produced. Marked VARYING.\n");
+#endif
-static bool
-replace_uses_in (tree stmt, bool *replaced_addresses_p)
-{
- bool replaced = false;
- use_operand_p use;
- ssa_op_iter iter;
+ /* Definitions made by statements other than assignments to
+ SSA_NAMEs represent unknown modifications to their outputs.
+ Mark them VARYING. */
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_DEF)
+ def_to_varying (def);
- if (replaced_addresses_p)
- *replaced_addresses_p = false;
+ /* Mark all V_MAY_DEF operands VARYING. */
+ FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_VMAYDEF)
+ def_to_varying (def);
- get_stmt_operands (stmt);
+ return SSA_PROP_VARYING;
+}
- FOR_EACH_SSA_USE_OPERAND (use, stmt, iter, SSA_OP_USE)
- {
- value *val = get_value (USE_FROM_PTR (use));
- if (val->lattice_val == CONSTANT)
- {
- SET_USE (use, val->const_val);
- replaced = true;
- if (POINTER_TYPE_P (TREE_TYPE (USE_FROM_PTR (use)))
- && replaced_addresses_p)
- *replaced_addresses_p = true;
- }
- }
+/* Main entry point for SSA Conditional Constant Propagation.
- return replaced;
+ [ DESCRIBE MAIN ALGORITHM HERE ] */
+
+static void
+execute_ssa_ccp (void)
+{
+ ccp_initialize ();
+ ssa_propagate (ccp_visit_stmt, ccp_visit_phi_node);
+ ccp_finalize ();
}
-/* Replace the VUSE references in statement STMT with its immediate reaching
- definition. Return true if the reference was replaced. If
- REPLACED_ADDRESSES_P is given, it will be set to true if an address
- constant was replaced. */
static bool
-replace_vuse_in (tree stmt, bool *replaced_addresses_p)
+gate_ccp (void)
{
- bool replaced = false;
- vuse_optype vuses;
- use_operand_p vuse;
- value *val;
-
- if (replaced_addresses_p)
- *replaced_addresses_p = false;
-
- get_stmt_operands (stmt);
-
- vuses = STMT_VUSE_OPS (stmt);
-
- if (NUM_VUSES (vuses) != 1)
- return false;
-
- vuse = VUSE_OP_PTR (vuses, 0);
- val = get_value (USE_FROM_PTR (vuse));
-
- if (val->lattice_val == CONSTANT
- && TREE_CODE (stmt) == MODIFY_EXPR
- && DECL_P (TREE_OPERAND (stmt, 1))
- && TREE_OPERAND (stmt, 1) == SSA_NAME_VAR (USE_FROM_PTR (vuse)))
- {
- TREE_OPERAND (stmt, 1) = val->const_val;
- replaced = true;
- if (POINTER_TYPE_P (TREE_TYPE (USE_FROM_PTR (vuse)))
- && replaced_addresses_p)
- *replaced_addresses_p = true;
- }
-
- return replaced;
+ return flag_tree_ccp != 0;
}
-/* Return the likely latticevalue for STMT.
-
- If STMT has no operands, then return CONSTANT.
- Else if any operands of STMT are undefined, then return UNDEFINED.
+struct tree_opt_pass pass_ccp =
+{
+ "ccp", /* name */
+ gate_ccp, /* gate */
+ execute_ssa_ccp, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_TREE_CCP, /* tv_id */
+ PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_dump_func | TODO_rename_vars
+ | TODO_ggc_collect | TODO_verify_ssa
+ | TODO_verify_stmts /* todo_flags_finish */
+};
- Else if any operands of STMT are constants, then return CONSTANT.
- Else return VARYING. */
+/* Given a constant value VAL for bitfield FIELD, and a destination
+ variable VAR, return VAL appropriately widened to fit into VAR. If
+ FIELD is wider than HOST_WIDE_INT, NULL is returned. */
-static latticevalue
-likely_value (tree stmt)
+tree
+widen_bitfield (tree val, tree field, tree var)
{
- vuse_optype vuses;
- int found_constant = 0;
- stmt_ann_t ann;
- tree use;
- ssa_op_iter iter;
+ unsigned HOST_WIDE_INT var_size, field_size;
+ tree wide_val;
+ unsigned HOST_WIDE_INT mask;
+ unsigned int i;
- /* If the statement makes aliased loads or has volatile operands, it
- won't fold to a constant value. */
- ann = stmt_ann (stmt);
- if (ann->makes_aliased_loads || ann->has_volatile_ops)
- return VARYING;
+ /* We can only do this if the size of the type and field and VAL are
+ all constants representable in HOST_WIDE_INT. */
+ if (!host_integerp (TYPE_SIZE (TREE_TYPE (var)), 1)
+ || !host_integerp (DECL_SIZE (field), 1)
+ || !host_integerp (val, 0))
+ return NULL_TREE;
- /* A CALL_EXPR is assumed to be varying. This may be overly conservative,
- in the presence of const and pure calls. */
- if (get_call_expr_in (stmt) != NULL_TREE)
- return VARYING;
+ var_size = tree_low_cst (TYPE_SIZE (TREE_TYPE (var)), 1);
+ field_size = tree_low_cst (DECL_SIZE (field), 1);
- get_stmt_operands (stmt);
+ /* Give up if either the bitfield or the variable are too wide. */
+ if (field_size > HOST_BITS_PER_WIDE_INT || var_size > HOST_BITS_PER_WIDE_INT)
+ return NULL_TREE;
- FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
- {
- value *val = get_value (use);
+#if defined ENABLE_CHECKING
+ if (var_size < field_size)
+ abort ();
+#endif
- if (val->lattice_val == UNDEFINED)
- return UNDEFINED;
+ /* If the sign bit of the value is not set or the field's type is unsigned,
+ just mask off the high order bits of the value. */
+ if (DECL_UNSIGNED (field)
+ || !(tree_low_cst (val, 0) & (((HOST_WIDE_INT)1) << (field_size - 1))))
+ {
+ /* Zero extension. Build a mask with the lower 'field_size' bits
+ set and a BIT_AND_EXPR node to clear the high order bits of
+ the value. */
+ for (i = 0, mask = 0; i < field_size; i++)
+ mask |= ((HOST_WIDE_INT) 1) << i;
- if (val->lattice_val == CONSTANT)
- found_constant = 1;
+ wide_val = build (BIT_AND_EXPR, TREE_TYPE (var), val,
+ fold_convert (TREE_TYPE (var),
+ build_int_cst (NULL_TREE, mask)));
}
-
- vuses = VUSE_OPS (ann);
-
- if (NUM_VUSES (vuses))
+ else
{
- tree vuse = VUSE_OP (vuses, 0);
- value *val = get_value (vuse);
-
- if (val->lattice_val == UNKNOWN_VAL)
- return UNKNOWN_VAL;
-
-#ifdef ENABLE_CHECKING
- /* There should be no VUSE operands that are UNDEFINED. */
- if (val->lattice_val == UNDEFINED)
- abort ();
-#endif
-
- if (val->lattice_val == CONSTANT)
- found_constant = 1;
+ /* Sign extension. Create a mask with the upper 'field_size'
+ bits set and a BIT_IOR_EXPR to set the high order bits of the
+ value. */
+ for (i = 0, mask = 0; i < (var_size - field_size); i++)
+ mask |= ((HOST_WIDE_INT) 1) << (var_size - i - 1);
+
+ wide_val = build (BIT_IOR_EXPR, TREE_TYPE (var), val,
+ fold_convert (TREE_TYPE (var),
+ build_int_cst (NULL_TREE, mask)));
}
- return ((found_constant || (!USE_OPS (ann) && !vuses)) ? CONSTANT : VARYING);
+ return fold (wide_val);
}
+
/* A subroutine of fold_stmt_r. Attempts to fold *(A+O) to A[X].
BASE is an array type. OFFSET is a byte displacement. ORIG_TYPE
is the desired result type. */
/ (TYPE_ALIGN (elt_type) / BITS_PER_UNIT)));
}
+
/* A subroutine of fold_stmt_r. Attempts to fold *(S+O) to S.X.
BASE is a record type. OFFSET is a byte displacement. ORIG_TYPE
is the desired result type. */
orig_type, false);
}
+
/* A subroutine of fold_stmt_r. Attempt to simplify *(BASE+OFFSET).
Return the simplified expression, or NULL if nothing could be done. */
return NULL_TREE;
}
+
/* A subroutine of fold_stmt_r. EXPR is a PLUS_EXPR.
A quaint feature extant in our address arithmetic is that there
return t;
}
+
/* Subroutine of fold_stmt called via walk_tree. We perform several
simplifications of EXPR_P, mostly having to do with pointer arithmetic. */
return NULL_TREE;
}
-/* Fold the statement pointed by STMT_P. In some cases, this function may
- replace the whole statement with a new one. Returns true iff folding
- makes any changes. */
-
-bool
-fold_stmt (tree *stmt_p)
-{
- tree rhs, result, stmt;
- bool changed = false;
-
- stmt = *stmt_p;
-
- /* If we replaced constants and the statement makes pointer dereferences,
- then we may need to fold instances of *&VAR into VAR, etc. */
- if (walk_tree (stmt_p, fold_stmt_r, &changed, NULL))
- {
- *stmt_p
- = build_function_call_expr (implicit_built_in_decls[BUILT_IN_TRAP],
- NULL);
- return true;
- }
-
- rhs = get_rhs (stmt);
- if (!rhs)
- return changed;
- result = NULL_TREE;
-
- if (TREE_CODE (rhs) == CALL_EXPR)
- {
- tree callee;
-
- /* Check for builtins that CCP can handle using information not
- available in the generic fold routines. */
- callee = get_callee_fndecl (rhs);
- if (callee && DECL_BUILT_IN (callee))
- result = ccp_fold_builtin (stmt, rhs);
- else
- {
- /* Check for resolvable OBJ_TYPE_REF. The only sorts we can resolve
- here are when we've propagated the address of a decl into the
- object slot. */
- /* ??? Should perhaps do this in fold proper. However, doing it
- there requires that we create a new CALL_EXPR, and that requires
- copying EH region info to the new node. Easier to just do it
- here where we can just smash the call operand. */
- callee = TREE_OPERAND (rhs, 0);
- if (TREE_CODE (callee) == OBJ_TYPE_REF
- && lang_hooks.fold_obj_type_ref
- && TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
- && DECL_P (TREE_OPERAND (OBJ_TYPE_REF_OBJECT (callee), 0)))
- {
- tree t;
-
- /* ??? Caution: Broken ADDR_EXPR semantics means that
- looking at the type of the operand of the addr_expr
- can yield an array type. See silly exception in
- check_pointer_types_r. */
-
- t = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (callee)));
- t = lang_hooks.fold_obj_type_ref (callee, t);
- if (t)
- {
- TREE_OPERAND (rhs, 0) = t;
- changed = true;
- }
- }
- }
- }
-
- /* If we couldn't fold the RHS, hand over to the generic fold routines. */
- if (result == NULL_TREE)
- result = fold (rhs);
-
- /* Strip away useless type conversions. Both the NON_LVALUE_EXPR that
- may have been added by fold, and "useless" type conversions that might
- now be apparent due to propagation. */
- STRIP_USELESS_TYPE_CONVERSION (result);
-
- if (result != rhs)
- changed |= set_rhs (stmt_p, result);
-
- return changed;
-}
-
-/* Get the main expression from statement STMT. */
-
-static tree
-get_rhs (tree stmt)
-{
- enum tree_code code = TREE_CODE (stmt);
-
- switch (code)
- {
- case RETURN_EXPR:
- stmt = TREE_OPERAND (stmt, 0);
- if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
- return stmt;
- /* FALLTHRU */
-
- case MODIFY_EXPR:
- stmt = TREE_OPERAND (stmt, 1);
- if (TREE_CODE (stmt) == WITH_SIZE_EXPR)
- return TREE_OPERAND (stmt, 0);
- else
- return stmt;
-
- case COND_EXPR:
- return COND_EXPR_COND (stmt);
- case SWITCH_EXPR:
- return SWITCH_COND (stmt);
- case GOTO_EXPR:
- return GOTO_DESTINATION (stmt);
- case LABEL_EXPR:
- return LABEL_EXPR_LABEL (stmt);
-
- default:
- return stmt;
- }
-}
-
-/* Set the main expression of *STMT_P to EXPR. */
+/* Return the string length of ARG in LENGTH. If ARG is an SSA name variable,
+ follow its use-def chains. If LENGTH is not NULL and its value is not
+ equal to the length we determine, or if we are unable to determine the
+ length, return false. VISITED is a bitmap of visited variables. */
static bool
-set_rhs (tree *stmt_p, tree expr)
+get_strlen (tree arg, tree *length, bitmap visited)
{
- tree stmt = *stmt_p, op;
- enum tree_code code = TREE_CODE (expr);
- stmt_ann_t ann;
- tree var;
- ssa_op_iter iter;
-
- /* Verify the constant folded result is valid gimple. */
- if (TREE_CODE_CLASS (code) == '2')
- {
- if (!is_gimple_val (TREE_OPERAND (expr, 0))
- || !is_gimple_val (TREE_OPERAND (expr, 1)))
- return false;
- }
- else if (TREE_CODE_CLASS (code) == '1')
+ tree var, def_stmt, val;
+
+ if (TREE_CODE (arg) != SSA_NAME)
{
- if (!is_gimple_val (TREE_OPERAND (expr, 0)))
+ val = c_strlen (arg, 1);
+ if (!val)
return false;
- }
-
- switch (TREE_CODE (stmt))
- {
- case RETURN_EXPR:
- op = TREE_OPERAND (stmt, 0);
- if (TREE_CODE (op) != MODIFY_EXPR)
- {
- TREE_OPERAND (stmt, 0) = expr;
- break;
- }
- stmt = op;
- /* FALLTHRU */
-
- case MODIFY_EXPR:
- op = TREE_OPERAND (stmt, 1);
- if (TREE_CODE (op) == WITH_SIZE_EXPR)
- stmt = op;
- TREE_OPERAND (stmt, 1) = expr;
- break;
-
- case COND_EXPR:
- COND_EXPR_COND (stmt) = expr;
- break;
- case SWITCH_EXPR:
- SWITCH_COND (stmt) = expr;
- break;
- case GOTO_EXPR:
- GOTO_DESTINATION (stmt) = expr;
- break;
- case LABEL_EXPR:
- LABEL_EXPR_LABEL (stmt) = expr;
- break;
- default:
- /* Replace the whole statement with EXPR. If EXPR has no side
- effects, then replace *STMT_P with an empty statement. */
- ann = stmt_ann (stmt);
- *stmt_p = TREE_SIDE_EFFECTS (expr) ? expr : build_empty_stmt ();
- (*stmt_p)->common.ann = (tree_ann_t) ann;
+ if (*length && simple_cst_equal (val, *length) != 1)
+ return false;
- if (TREE_SIDE_EFFECTS (expr))
- {
- /* Fix all the SSA_NAMEs created by *STMT_P to point to its new
- replacement. */
- FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_DEFS)
- {
- if (TREE_CODE (var) == SSA_NAME)
- SSA_NAME_DEF_STMT (var) = *stmt_p;
- }
- }
- break;
+ *length = val;
+ return true;
}
- return true;
-}
+ /* If we were already here, break the infinite cycle. */
+ if (bitmap_bit_p (visited, SSA_NAME_VERSION (arg)))
+ return true;
+ bitmap_set_bit (visited, SSA_NAME_VERSION (arg));
+
+ var = arg;
+ def_stmt = SSA_NAME_DEF_STMT (var);
+ switch (TREE_CODE (def_stmt))
+ {
+ case MODIFY_EXPR:
+ {
+ tree len, rhs;
+
+ /* The RHS of the statement defining VAR must either have a
+ constant length or come from another SSA_NAME with a constant
+ length. */
+ rhs = TREE_OPERAND (def_stmt, 1);
+ STRIP_NOPS (rhs);
+ if (TREE_CODE (rhs) == SSA_NAME)
+ return get_strlen (rhs, length, visited);
-/* Return a default value for variable VAR using the following rules:
+ /* See if the RHS is a constant length. */
+ len = c_strlen (rhs, 1);
+ if (len)
+ {
+ if (*length && simple_cst_equal (len, *length) != 1)
+ return false;
- 1- Function arguments are considered VARYING.
-
- 2- Global and static variables that are declared constant are
- considered CONSTANT.
+ *length = len;
+ return true;
+ }
- 3- Any other virtually defined variable is considered UNKNOWN_VAL.
+ break;
+ }
- 4- Any other value is considered UNDEFINED. This is useful when
- considering PHI nodes. PHI arguments that are undefined do not
- change the constant value of the PHI node, which allows for more
- constants to be propagated. */
+ case PHI_NODE:
+ {
+ /* All the arguments of the PHI node must have the same constant
+ length. */
+ int i;
-static value
-get_default_value (tree var)
-{
- value val;
- tree sym;
+ for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
+ {
+ tree arg = PHI_ARG_DEF (def_stmt, i);
- if (TREE_CODE (var) == SSA_NAME)
- sym = SSA_NAME_VAR (var);
- else
- {
-#ifdef ENABLE_CHECKING
- if (!DECL_P (var))
- abort ();
-#endif
- sym = var;
- }
+ /* If this PHI has itself as an argument, we cannot
+ determine the string length of this argument. However,
+ if we can find a constant string length for the other
+ PHI args then we can still be sure that this is a
+ constant string length. So be optimistic and just
+ continue with the next argument. */
+ if (arg == PHI_RESULT (def_stmt))
+ continue;
- val.lattice_val = UNDEFINED;
- val.const_val = NULL_TREE;
+ if (!get_strlen (arg, length, visited))
+ return false;
+ }
- if (TREE_CODE (sym) == PARM_DECL || TREE_THIS_VOLATILE (sym))
- {
- /* Function arguments and volatile variables are considered VARYING. */
- val.lattice_val = VARYING;
- }
- else if (TREE_STATIC (sym))
- {
- /* Globals and static variables are considered UNKNOWN_VAL,
- unless they are declared 'const'. */
- if (TREE_READONLY (sym)
- && DECL_INITIAL (sym)
- && is_gimple_min_invariant (DECL_INITIAL (sym)))
- {
- val.lattice_val = CONSTANT;
- val.const_val = DECL_INITIAL (sym);
- }
- else
- {
- val.const_val = NULL_TREE;
- val.lattice_val = UNKNOWN_VAL;
+ return true;
}
- }
- else if (!is_gimple_reg (sym))
- {
- val.const_val = NULL_TREE;
- val.lattice_val = UNKNOWN_VAL;
- }
- else
- {
- enum tree_code code;
- tree stmt = SSA_NAME_DEF_STMT (var);
- if (!IS_EMPTY_STMT (stmt))
- {
- code = TREE_CODE (stmt);
- if (code != MODIFY_EXPR && code != PHI_NODE)
- val.lattice_val = VARYING;
- }
+ default:
+ break;
}
- return val;
+
+ return false;
}
}
-/* Return the string length of ARG in LENGTH. If ARG is an SSA name variable,
- follow its use-def chains. If LENGTH is not NULL and its value is not
- equal to the length we determine, or if we are unable to determine the
- length, return false. VISITED is a bitmap of visited variables. */
+/* Fold the statement pointed by STMT_P. In some cases, this function may
+ replace the whole statement with a new one. Returns true iff folding
+ makes any changes. */
-static bool
-get_strlen (tree arg, tree *length, bitmap visited)
+bool
+fold_stmt (tree *stmt_p)
{
- tree var, def_stmt, val;
-
- if (TREE_CODE (arg) != SSA_NAME)
- {
- val = c_strlen (arg, 1);
- if (!val)
- return false;
+ tree rhs, result, stmt;
+ bool changed = false;
- if (*length && simple_cst_equal (val, *length) != 1)
- return false;
+ stmt = *stmt_p;
- *length = val;
+ /* If we replaced constants and the statement makes pointer dereferences,
+ then we may need to fold instances of *&VAR into VAR, etc. */
+ if (walk_tree (stmt_p, fold_stmt_r, &changed, NULL))
+ {
+ *stmt_p
+ = build_function_call_expr (implicit_built_in_decls[BUILT_IN_TRAP],
+ NULL);
return true;
}
- /* If we were already here, break the infinite cycle. */
- if (bitmap_bit_p (visited, SSA_NAME_VERSION (arg)))
- return true;
- bitmap_set_bit (visited, SSA_NAME_VERSION (arg));
-
- var = arg;
- def_stmt = SSA_NAME_DEF_STMT (var);
+ rhs = get_rhs (stmt);
+ if (!rhs)
+ return changed;
+ result = NULL_TREE;
- switch (TREE_CODE (def_stmt))
+ if (TREE_CODE (rhs) == CALL_EXPR)
{
- case MODIFY_EXPR:
- {
- tree len, rhs;
-
- /* The RHS of the statement defining VAR must either have a
- constant length or come from another SSA_NAME with a constant
- length. */
- rhs = TREE_OPERAND (def_stmt, 1);
- STRIP_NOPS (rhs);
- if (TREE_CODE (rhs) == SSA_NAME)
- return get_strlen (rhs, length, visited);
-
- /* See if the RHS is a constant length. */
- len = c_strlen (rhs, 1);
- if (len)
- {
- if (*length && simple_cst_equal (len, *length) != 1)
- return false;
-
- *length = len;
- return true;
- }
-
- break;
- }
+ tree callee;
- case PHI_NODE:
+ /* Check for builtins that CCP can handle using information not
+ available in the generic fold routines. */
+ callee = get_callee_fndecl (rhs);
+ if (callee && DECL_BUILT_IN (callee))
+ result = ccp_fold_builtin (stmt, rhs);
+ else
{
- /* All the arguments of the PHI node must have the same constant
- length. */
- int i;
-
- for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
+ /* Check for resolvable OBJ_TYPE_REF. The only sorts we can resolve
+ here are when we've propagated the address of a decl into the
+ object slot. */
+ /* ??? Should perhaps do this in fold proper. However, doing it
+ there requires that we create a new CALL_EXPR, and that requires
+ copying EH region info to the new node. Easier to just do it
+ here where we can just smash the call operand. */
+ callee = TREE_OPERAND (rhs, 0);
+ if (TREE_CODE (callee) == OBJ_TYPE_REF
+ && lang_hooks.fold_obj_type_ref
+ && TREE_CODE (OBJ_TYPE_REF_OBJECT (callee)) == ADDR_EXPR
+ && DECL_P (TREE_OPERAND (OBJ_TYPE_REF_OBJECT (callee), 0)))
{
- tree arg = PHI_ARG_DEF (def_stmt, i);
+ tree t;
- /* If this PHI has itself as an argument, we cannot
- determine the string length of this argument. However,
- if we can find a constant string length for the other
- PHI args then we can still be sure that this is a
- constant string length. So be optimistic and just
- continue with the next argument. */
- if (arg == PHI_RESULT (def_stmt))
- continue;
+ /* ??? Caution: Broken ADDR_EXPR semantics means that
+ looking at the type of the operand of the addr_expr
+ can yield an array type. See silly exception in
+ check_pointer_types_r. */
- if (!get_strlen (arg, length, visited))
- return false;
+ t = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (callee)));
+ t = lang_hooks.fold_obj_type_ref (callee, t);
+ if (t)
+ {
+ TREE_OPERAND (rhs, 0) = t;
+ changed = true;
+ }
}
-
- return true;
}
-
- default:
- break;
}
+ /* If we couldn't fold the RHS, hand over to the generic fold routines. */
+ if (result == NULL_TREE)
+ result = fold (rhs);
- return false;
+ /* Strip away useless type conversions. Both the NON_LVALUE_EXPR that
+ may have been added by fold, and "useless" type conversions that might
+ now be apparent due to propagation. */
+ STRIP_USELESS_TYPE_CONVERSION (result);
+
+ if (result != rhs)
+ changed |= set_rhs (stmt_p, result);
+
+ return changed;
}
\f
}
}
+
struct tree_opt_pass pass_fold_builtins =
{
"fab", /* name */
0, /* todo_flags_start */
TODO_dump_func | TODO_verify_ssa /* todo_flags_finish */
};
-
-
-#include "gt-tree-ssa-ccp.h"
--- /dev/null
+/* Generic SSA value propagation engine.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ Contributed by Diego Novillo <dnovillo@redhat.com>
+
+ 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 "flags.h"
+#include "rtl.h"
+#include "tm_p.h"
+#include "ggc.h"
+#include "basic-block.h"
+#include "output.h"
+#include "errors.h"
+#include "expr.h"
+#include "function.h"
+#include "diagnostic.h"
+#include "timevar.h"
+#include "tree-dump.h"
+#include "tree-flow.h"
+#include "tree-pass.h"
+#include "tree-ssa-propagate.h"
+#include "langhooks.h"
+
+
+/* This file implements a generic value propagation engine based on
+ the same propagation used by the SSA-CCP algorithm [1].
+
+ Propagation is performed by simulating the execution of every
+ statement that produces the value being propagated. Simulation
+ proceeds as follows:
+
+ 1- Initially, all edges of the CFG are marked not executable and
+ the CFG worklist seeded with all the statements in the entry
+ basic block (block 0).
+
+ 2- Every statement S is simulated with a call to the call-back
+ function SSA_PROP_VISIT_STMT. This evaluation may produce 3
+ results:
+
+ SSA_PROP_NOT_INTERESTING: Statement S produces nothing of
+ interest and does not affect any of the work lists.
+
+ SSA_PROP_VARYING: The value produced by S cannot be determined
+ at compile time. Further simulation of S is not required.
+ If S is a conditional jump, all the outgoing edges for the
+ block are considered executable and added to the work
+ list.
+
+ SSA_PROP_INTERESTING: S produces a value that can be computed
+ at compile time. Its result can be propagated into the
+ statements that feed from S. Furhtermore, if S is a
+ conditional jump, only the edge known to be taken is added
+ to the work list. Edges that are known not to execute are
+ never simulated.
+
+ 3- PHI nodes are simulated with a call to SSA_PROP_VISIT_PHI. The
+ return value from SSA_PROP_VISIT_PHI has the same semantics as
+ described in #3.
+
+ 4- Three work lists are kept. Statements are only added to these
+ lists if they produce one of SSA_PROP_INTERESTING or
+ SSA_PROP_VARYING.
+
+ CFG_BLOCKS contains the list of blocks to be simulated.
+ Blocks are added to this list if their incoming edges are
+ found executable.
+
+ VARYING_SSA_EDGES contains the list of statements that feed
+ from statements that produce an SSA_PROP_VARYING result.
+ These are simulated first to speed up processing.
+
+ INTERESTING_SSA_EDGES contains the list of statements that
+ feed from statements that produce an SSA_PROP_INTERESTING
+ result.
+
+ 5- Simulation terminates when all three work lists are drained.
+
+ Before calling ssa_propagate, it is important to clear
+ DONT_SIMULATE_AGAIN for all the statements in the program that
+ should be simulated. This initialization allows an implementation
+ to specify which statements should never be simulated.
+
+ It is also important to compute def-use information before calling
+ ssa_propagate.
+
+ References:
+
+ [1] Constant propagation with conditional branches,
+ Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
+
+ [2] Building an Optimizing Compiler,
+ Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
+
+ [3] Advanced Compiler Design and Implementation,
+ Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6 */
+
+/* Function pointers used to parameterize the propagation engine. */
+static ssa_prop_visit_stmt_fn ssa_prop_visit_stmt;
+static ssa_prop_visit_phi_fn ssa_prop_visit_phi;
+
+/* Use the TREE_DEPRECATED bitflag to mark statements that have been
+ added to one of the SSA edges worklists. This flag is used to
+ avoid visiting statements unnecessarily when draining an SSA edge
+ worklist. If while simulating a basic block, we find a statement with
+ STMT_IN_SSA_EDGE_WORKLIST set, we clear it to prevent SSA edge
+ processing from visiting it again. */
+#define STMT_IN_SSA_EDGE_WORKLIST(T) TREE_DEPRECATED (T)
+
+/* A bitmap to keep track of executable blocks in the CFG. */
+static sbitmap executable_blocks;
+
+/* Array of control flow edges on the worklist. */
+static GTY(()) varray_type cfg_blocks = NULL;
+
+static unsigned int cfg_blocks_num = 0;
+static int cfg_blocks_tail;
+static int cfg_blocks_head;
+
+static sbitmap bb_in_list;
+
+/* Worklist of SSA edges which will need reexamination as their
+ definition has changed. SSA edges are def-use edges in the SSA
+ web. For each D-U edge, we store the target statement or PHI node
+ U. */
+static GTY(()) varray_type interesting_ssa_edges;
+
+/* Identical to INTERESTING_SSA_EDGES. For performance reasons, the
+ list of SSA edges is split into two. One contains all SSA edges
+ who need to be reexamined because their lattice value changed to
+ varying (this worklist), and the other contains all other SSA edges
+ to be reexamined (INTERESTING_SSA_EDGES).
+
+ Since most values in the program are VARYING, the ideal situation
+ is to move them to that lattice value as quickly as possible.
+ Thus, it doesn't make sense to process any other type of lattice
+ value until all VARYING values are propagated fully, which is one
+ thing using the VARYING worklist achieves. In addition, if we
+ don't use a separate worklist for VARYING edges, we end up with
+ situations where lattice values move from
+ UNDEFINED->INTERESTING->VARYING instead of UNDEFINED->VARYING. */
+static GTY(()) varray_type varying_ssa_edges;
+
+
+/* Return true if the block worklist empty. */
+
+static inline bool
+cfg_blocks_empty_p (void)
+{
+ return (cfg_blocks_num == 0);
+}
+
+
+/* Add a basic block to the worklist. */
+
+static void
+cfg_blocks_add (basic_block bb)
+{
+ if (bb == ENTRY_BLOCK_PTR || bb == EXIT_BLOCK_PTR)
+ return;
+
+ if (TEST_BIT (bb_in_list, bb->index))
+ return;
+
+ if (cfg_blocks_empty_p ())
+ {
+ cfg_blocks_tail = cfg_blocks_head = 0;
+ cfg_blocks_num = 1;
+ }
+ else
+ {
+ cfg_blocks_num++;
+ if (cfg_blocks_num > VARRAY_SIZE (cfg_blocks))
+ {
+ /* We have to grow the array now. Adjust to queue to occupy the
+ full space of the original array. */
+ cfg_blocks_tail = VARRAY_SIZE (cfg_blocks);
+ cfg_blocks_head = 0;
+ VARRAY_GROW (cfg_blocks, 2 * VARRAY_SIZE (cfg_blocks));
+ }
+ else
+ cfg_blocks_tail = (cfg_blocks_tail + 1) % VARRAY_SIZE (cfg_blocks);
+ }
+
+ VARRAY_BB (cfg_blocks, cfg_blocks_tail) = bb;
+ SET_BIT (bb_in_list, bb->index);
+}
+
+
+/* Remove a block from the worklist. */
+
+static basic_block
+cfg_blocks_get (void)
+{
+ basic_block bb;
+
+ bb = VARRAY_BB (cfg_blocks, cfg_blocks_head);
+
+#ifdef ENABLE_CHECKING
+ if (cfg_blocks_empty_p () || !bb)
+ abort ();
+#endif
+
+ cfg_blocks_head = (cfg_blocks_head + 1) % VARRAY_SIZE (cfg_blocks);
+ --cfg_blocks_num;
+ RESET_BIT (bb_in_list, bb->index);
+
+ return bb;
+}
+
+
+/* We have just defined a new value for VAR. If IS_VARYING is true,
+ add all immediate uses of VAR to VARYING_SSA_EDGES, otherwise add
+ them to INTERESTING_SSA_EDGES. */
+
+static void
+add_ssa_edge (tree var, bool is_varying)
+{
+ tree stmt = SSA_NAME_DEF_STMT (var);
+ dataflow_t df = get_immediate_uses (stmt);
+ int num_uses = num_immediate_uses (df);
+ int i;
+
+ for (i = 0; i < num_uses; i++)
+ {
+ tree use_stmt = immediate_use (df, i);
+
+ if (!DONT_SIMULATE_AGAIN (use_stmt)
+ && !STMT_IN_SSA_EDGE_WORKLIST (use_stmt))
+ {
+ STMT_IN_SSA_EDGE_WORKLIST (use_stmt) = 1;
+ if (is_varying)
+ VARRAY_PUSH_TREE (varying_ssa_edges, use_stmt);
+ else
+ VARRAY_PUSH_TREE (interesting_ssa_edges, use_stmt);
+ }
+ }
+}
+
+
+/* Add edge E to the control flow worklist. */
+
+static void
+add_control_edge (edge e)
+{
+ basic_block bb = e->dest;
+ if (bb == EXIT_BLOCK_PTR)
+ return;
+
+ /* If the edge had already been executed, skip it. */
+ if (e->flags & EDGE_EXECUTABLE)
+ return;
+
+ e->flags |= EDGE_EXECUTABLE;
+
+ /* If the block is already in the list, we're done. */
+ if (TEST_BIT (bb_in_list, bb->index))
+ return;
+
+ cfg_blocks_add (bb);
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Adding Destination of edge (%d -> %d) to worklist\n\n",
+ e->src->index, e->dest->index);
+}
+
+
+/* Simulate the execution of STMT and update the work lists accordingly. */
+
+static void
+simulate_stmt (tree stmt)
+{
+ enum ssa_prop_result val = SSA_PROP_NOT_INTERESTING;
+ edge taken_edge = NULL;
+ tree output_name = NULL_TREE;
+
+ /* Don't bother visiting statements that are already
+ considered varying by the propagator. */
+ if (DONT_SIMULATE_AGAIN (stmt))
+ return;
+
+ if (TREE_CODE (stmt) == PHI_NODE)
+ {
+ val = ssa_prop_visit_phi (stmt);
+ output_name = PHI_RESULT (stmt);
+ }
+ else
+ val = ssa_prop_visit_stmt (stmt, &taken_edge, &output_name);
+
+ if (val == SSA_PROP_VARYING)
+ {
+ DONT_SIMULATE_AGAIN (stmt) = 1;
+
+ /* If the statement produced a new varying value, add the SSA
+ edges coming out of OUTPUT_NAME. */
+ if (output_name)
+ add_ssa_edge (output_name, true);
+
+ /* If STMT transfers control out of its basic block, add
+ all outgoing edges to the work list. */
+ if (stmt_ends_bb_p (stmt))
+ {
+ edge e;
+ basic_block bb = bb_for_stmt (stmt);
+ for (e = bb->succ; e; e = e->succ_next)
+ add_control_edge (e);
+ }
+ }
+ else if (val == SSA_PROP_INTERESTING)
+ {
+ /* If the statement produced new value, add the SSA edges coming
+ out of OUTPUT_NAME. */
+ if (output_name)
+ add_ssa_edge (output_name, false);
+
+ /* If we know which edge is going to be taken out of this block,
+ add it to the CFG work list. */
+ if (taken_edge)
+ add_control_edge (taken_edge);
+ }
+}
+
+/* Process an SSA edge worklist. WORKLIST is the SSA edge worklist to
+ drain. This pops statements off the given WORKLIST and processes
+ them until there are no more statements on WORKLIST. */
+
+static void
+process_ssa_edge_worklist (varray_type *worklist)
+{
+ /* Drain the entire worklist. */
+ while (VARRAY_ACTIVE_SIZE (*worklist) > 0)
+ {
+ basic_block bb;
+
+ /* Pull the statement to simulate off the worklist. */
+ tree stmt = VARRAY_TOP_TREE (*worklist);
+ VARRAY_POP (*worklist);
+
+ /* If this statement was already visited by simulate_block, then
+ we don't need to visit it again here. */
+ if (!STMT_IN_SSA_EDGE_WORKLIST (stmt))
+ continue;
+
+ /* STMT is no longer in a worklist. */
+ STMT_IN_SSA_EDGE_WORKLIST (stmt) = 0;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "\nSimulating statement (from ssa_edges): ");
+ print_generic_stmt (dump_file, stmt, dump_flags);
+ }
+
+ bb = bb_for_stmt (stmt);
+
+ /* PHI nodes are always visited, regardless of whether or not
+ the destination block is executable. Otherwise, visit the
+ statement only if its block is marked executable. */
+ if (TREE_CODE (stmt) == PHI_NODE
+ || TEST_BIT (executable_blocks, bb->index))
+ simulate_stmt (stmt);
+ }
+}
+
+
+/* Simulate the execution of BLOCK. Evaluate the statement associated
+ with each variable reference inside the block. */
+
+static void
+simulate_block (basic_block block)
+{
+ tree phi;
+
+ /* There is nothing to do for the exit block. */
+ if (block == EXIT_BLOCK_PTR)
+ return;
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "\nSimulating block %d\n", block->index);
+
+ /* Always simulate PHI nodes, even if we have simulated this block
+ before. */
+ for (phi = phi_nodes (block); phi; phi = PHI_CHAIN (phi))
+ simulate_stmt (phi);
+
+ /* If this is the first time we've simulated this block, then we
+ must simulate each of its statements. */
+ if (!TEST_BIT (executable_blocks, block->index))
+ {
+ block_stmt_iterator j;
+ unsigned int normal_edge_count;
+ edge e, normal_edge;
+
+ /* Note that we have simulated this block. */
+ SET_BIT (executable_blocks, block->index);
+
+ for (j = bsi_start (block); !bsi_end_p (j); bsi_next (&j))
+ {
+ tree stmt = bsi_stmt (j);
+
+ /* If this statement is already in the worklist then
+ "cancel" it. The reevaluation implied by the worklist
+ entry will produce the same value we generate here and
+ thus reevaluating it again from the worklist is
+ pointless. */
+ if (STMT_IN_SSA_EDGE_WORKLIST (stmt))
+ STMT_IN_SSA_EDGE_WORKLIST (stmt) = 0;
+
+ simulate_stmt (stmt);
+ }
+
+ /* We can not predict when abnormal edges will be executed, so
+ once a block is considered executable, we consider any
+ outgoing abnormal edges as executable.
+
+ At the same time, if this block has only one successor that is
+ reached by non-abnormal edges, then add that successor to the
+ worklist. */
+ normal_edge_count = 0;
+ normal_edge = NULL;
+ for (e = block->succ; e; e = e->succ_next)
+ {
+ if (e->flags & EDGE_ABNORMAL)
+ add_control_edge (e);
+ else
+ {
+ normal_edge_count++;
+ normal_edge = e;
+ }
+ }
+
+ if (normal_edge_count == 1)
+ add_control_edge (normal_edge);
+ }
+}
+
+
+/* Initialize local data structures and work lists. */
+
+static void
+ssa_prop_init (void)
+{
+ edge e;
+ basic_block bb;
+
+ /* Worklists of SSA edges. */
+ VARRAY_TREE_INIT (interesting_ssa_edges, 20, "interesting_ssa_edges");
+ VARRAY_TREE_INIT (varying_ssa_edges, 20, "varying_ssa_edges");
+
+ executable_blocks = sbitmap_alloc (last_basic_block);
+ sbitmap_zero (executable_blocks);
+
+ bb_in_list = sbitmap_alloc (last_basic_block);
+ sbitmap_zero (bb_in_list);
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ dump_immediate_uses (dump_file);
+
+ VARRAY_BB_INIT (cfg_blocks, 20, "cfg_blocks");
+
+ /* Initially assume that every edge in the CFG is not executable. */
+ FOR_EACH_BB (bb)
+ {
+ block_stmt_iterator si;
+
+ for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si))
+ STMT_IN_SSA_EDGE_WORKLIST (bsi_stmt (si)) = 0;
+
+ for (e = bb->succ; e; e = e->succ_next)
+ e->flags &= ~EDGE_EXECUTABLE;
+ }
+
+ /* Seed the algorithm by adding the successors of the entry block to the
+ edge worklist. */
+ for (e = ENTRY_BLOCK_PTR->succ; e; e = e->succ_next)
+ {
+ if (e->dest != EXIT_BLOCK_PTR)
+ {
+ e->flags |= EDGE_EXECUTABLE;
+ cfg_blocks_add (e->dest);
+ }
+ }
+}
+
+
+/* Free allocated storage. */
+
+static void
+ssa_prop_fini (void)
+{
+ interesting_ssa_edges = NULL;
+ varying_ssa_edges = NULL;
+ cfg_blocks = NULL;
+ sbitmap_free (bb_in_list);
+ sbitmap_free (executable_blocks);
+ free_df ();
+}
+
+
+/* Get the main expression from statement STMT. */
+
+tree
+get_rhs (tree stmt)
+{
+ enum tree_code code = TREE_CODE (stmt);
+
+ switch (code)
+ {
+ case RETURN_EXPR:
+ stmt = TREE_OPERAND (stmt, 0);
+ if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
+ return stmt;
+ /* FALLTHRU */
+
+ case MODIFY_EXPR:
+ stmt = TREE_OPERAND (stmt, 1);
+ if (TREE_CODE (stmt) == WITH_SIZE_EXPR)
+ return TREE_OPERAND (stmt, 0);
+ else
+ return stmt;
+
+ case COND_EXPR:
+ return COND_EXPR_COND (stmt);
+ case SWITCH_EXPR:
+ return SWITCH_COND (stmt);
+ case GOTO_EXPR:
+ return GOTO_DESTINATION (stmt);
+ case LABEL_EXPR:
+ return LABEL_EXPR_LABEL (stmt);
+
+ default:
+ return stmt;
+ }
+}
+
+
+/* Set the main expression of *STMT_P to EXPR. If EXPR is not a valid
+ GIMPLE expression no changes are done and the function returns
+ false. */
+
+bool
+set_rhs (tree *stmt_p, tree expr)
+{
+ tree stmt = *stmt_p, op;
+ enum tree_code code = TREE_CODE (expr);
+ stmt_ann_t ann;
+ tree var;
+ ssa_op_iter iter;
+
+ /* Verify the constant folded result is valid gimple. */
+ if (TREE_CODE_CLASS (code) == '2')
+ {
+ if (!is_gimple_val (TREE_OPERAND (expr, 0))
+ || !is_gimple_val (TREE_OPERAND (expr, 1)))
+ return false;
+ }
+ else if (TREE_CODE_CLASS (code) == '1')
+ {
+ if (!is_gimple_val (TREE_OPERAND (expr, 0)))
+ return false;
+ }
+
+ switch (TREE_CODE (stmt))
+ {
+ case RETURN_EXPR:
+ op = TREE_OPERAND (stmt, 0);
+ if (TREE_CODE (op) != MODIFY_EXPR)
+ {
+ TREE_OPERAND (stmt, 0) = expr;
+ break;
+ }
+ stmt = op;
+ /* FALLTHRU */
+
+ case MODIFY_EXPR:
+ op = TREE_OPERAND (stmt, 1);
+ if (TREE_CODE (op) == WITH_SIZE_EXPR)
+ stmt = op;
+ TREE_OPERAND (stmt, 1) = expr;
+ break;
+
+ case COND_EXPR:
+ COND_EXPR_COND (stmt) = expr;
+ break;
+ case SWITCH_EXPR:
+ SWITCH_COND (stmt) = expr;
+ break;
+ case GOTO_EXPR:
+ GOTO_DESTINATION (stmt) = expr;
+ break;
+ case LABEL_EXPR:
+ LABEL_EXPR_LABEL (stmt) = expr;
+ break;
+
+ default:
+ /* Replace the whole statement with EXPR. If EXPR has no side
+ effects, then replace *STMT_P with an empty statement. */
+ ann = stmt_ann (stmt);
+ *stmt_p = TREE_SIDE_EFFECTS (expr) ? expr : build_empty_stmt ();
+ (*stmt_p)->common.ann = (tree_ann_t) ann;
+
+ if (TREE_SIDE_EFFECTS (expr))
+ {
+ /* Fix all the SSA_NAMEs created by *STMT_P to point to its new
+ replacement. */
+ FOR_EACH_SSA_TREE_OPERAND (var, stmt, iter, SSA_OP_ALL_DEFS)
+ {
+ if (TREE_CODE (var) == SSA_NAME)
+ SSA_NAME_DEF_STMT (var) = *stmt_p;
+ }
+ }
+ break;
+ }
+
+ return true;
+}
+
+
+/* Entry point to the propagation engine.
+
+ VISIT_STMT is called for every statement visited.
+ VISIT_PHI is called for every PHI node visited. */
+
+void
+ssa_propagate (ssa_prop_visit_stmt_fn visit_stmt,
+ ssa_prop_visit_phi_fn visit_phi)
+{
+ ssa_prop_visit_stmt = visit_stmt;
+ ssa_prop_visit_phi = visit_phi;
+
+ ssa_prop_init ();
+
+ /* Iterate until the worklists are empty. */
+ while (!cfg_blocks_empty_p ()
+ || VARRAY_ACTIVE_SIZE (interesting_ssa_edges) > 0
+ || VARRAY_ACTIVE_SIZE (varying_ssa_edges) > 0)
+ {
+ if (!cfg_blocks_empty_p ())
+ {
+ /* Pull the next block to simulate off the worklist. */
+ basic_block dest_block = cfg_blocks_get ();
+ simulate_block (dest_block);
+ }
+
+ /* In order to move things to varying as quickly as
+ possible,process the VARYING_SSA_EDGES worklist first. */
+ process_ssa_edge_worklist (&varying_ssa_edges);
+
+ /* Now process the INTERESTING_SSA_EDGES worklist. */
+ process_ssa_edge_worklist (&interesting_ssa_edges);
+ }
+
+ ssa_prop_fini ();
+}
+
+#include "gt-tree-ssa-propagate.h"
projects / gcc.git / commitdiff