/* Miscellaneous SSA utility functions.
- Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
- Free Software Foundation, Inc.
+ Copyright (C) 2001-2015 Free Software Foundation, Inc.
This file is part of GCC.
#include "system.h"
#include "coretypes.h"
#include "tm.h"
+#include "input.h"
+#include "alias.h"
+#include "symtab.h"
#include "tree.h"
+#include "fold-const.h"
+#include "stor-layout.h"
#include "flags.h"
#include "tm_p.h"
#include "target.h"
-#include "ggc.h"
#include "langhooks.h"
-#include "basic-block.h"
-#include "output.h"
+#include "predict.h"
+#include "hard-reg-set.h"
+#include "input.h"
#include "function.h"
-#include "tree-pretty-print.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "basic-block.h"
#include "gimple-pretty-print.h"
-#include "bitmap.h"
-#include "pointer-set.h"
-#include "tree-flow.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-fold.h"
+#include "gimple-expr.h"
+#include "is-a.h"
#include "gimple.h"
+#include "gimplify.h"
+#include "gimple-iterator.h"
+#include "gimple-walk.h"
+#include "gimple-ssa.h"
+#include "tree-phinodes.h"
+#include "ssa-iterators.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "tree-ssa-loop-manip.h"
+#include "tree-into-ssa.h"
+#include "tree-ssa.h"
#include "tree-inline.h"
-#include "timevar.h"
-#include "hashtab.h"
-#include "tree-dump.h"
#include "tree-pass.h"
#include "diagnostic-core.h"
+#include "cfgloop.h"
+#include "cfgexpand.h"
/* Pointer map of variable mappings, keyed by edge. */
-static struct pointer_map_t *edge_var_maps;
+static hash_map<edge, auto_vec<edge_var_map> > *edge_var_maps;
/* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
void
redirect_edge_var_map_add (edge e, tree result, tree def, source_location locus)
{
- void **slot;
- edge_var_map_vector old_head, head;
edge_var_map new_node;
if (edge_var_maps == NULL)
- edge_var_maps = pointer_map_create ();
+ edge_var_maps = new hash_map<edge, auto_vec<edge_var_map> >;
- slot = pointer_map_insert (edge_var_maps, e);
- old_head = head = (edge_var_map_vector) *slot;
- if (!head)
- {
- head = VEC_alloc (edge_var_map, heap, 5);
- *slot = head;
- }
+ auto_vec<edge_var_map> &slot = edge_var_maps->get_or_insert (e);
new_node.def = def;
new_node.result = result;
new_node.locus = locus;
- VEC_safe_push (edge_var_map, heap, head, &new_node);
- if (old_head != head)
- {
- /* The push did some reallocation. Update the pointer map. */
- *slot = head;
- }
+ slot.safe_push (new_node);
}
void
redirect_edge_var_map_clear (edge e)
{
- void **slot;
- edge_var_map_vector head;
-
if (!edge_var_maps)
return;
- slot = pointer_map_contains (edge_var_maps, e);
+ auto_vec<edge_var_map> *head = edge_var_maps->get (e);
- if (slot)
- {
- head = (edge_var_map_vector) *slot;
- VEC_free (edge_var_map, heap, head);
- *slot = NULL;
- }
+ if (head)
+ head->release ();
}
/* Duplicate the redirected var mappings in OLDE in NEWE.
- Since we can't remove a mapping, let's just duplicate it. This assumes a
- pointer_map can have multiple edges mapping to the same var_map (many to
- one mapping), since we don't remove the previous mappings. */
+ This assumes a hash_map can have multiple edges mapping to the same
+ var_map (many to one mapping), since we don't remove the previous mappings.
+ */
void
redirect_edge_var_map_dup (edge newe, edge olde)
{
- void **new_slot, **old_slot;
- edge_var_map_vector head;
-
if (!edge_var_maps)
return;
- new_slot = pointer_map_insert (edge_var_maps, newe);
- old_slot = pointer_map_contains (edge_var_maps, olde);
- if (!old_slot)
+ auto_vec<edge_var_map> *new_head = &edge_var_maps->get_or_insert (newe);
+ auto_vec<edge_var_map> *old_head = edge_var_maps->get (olde);
+ if (!old_head)
return;
- head = (edge_var_map_vector) *old_slot;
- if (head)
- *new_slot = VEC_copy (edge_var_map, heap, head);
- else
- *new_slot = VEC_alloc (edge_var_map, heap, 5);
+ new_head->safe_splice (*old_head);
}
/* Return the variable mappings for a given edge. If there is none, return
NULL. */
-edge_var_map_vector
+vec<edge_var_map> *
redirect_edge_var_map_vector (edge e)
{
- void **slot;
-
/* Hey, what kind of idiot would... you'd be surprised. */
if (!edge_var_maps)
return NULL;
- slot = pointer_map_contains (edge_var_maps, e);
+ auto_vec<edge_var_map> *slot = edge_var_maps->get (e);
if (!slot)
return NULL;
- return (edge_var_map_vector) *slot;
-}
-
-/* Used by redirect_edge_var_map_destroy to free all memory. */
-
-static bool
-free_var_map_entry (const void *key ATTRIBUTE_UNUSED,
- void **value,
- void *data ATTRIBUTE_UNUSED)
-{
- edge_var_map_vector head = (edge_var_map_vector) *value;
- VEC_free (edge_var_map, heap, head);
- return true;
+ return slot;
}
/* Clear the edge variable mappings. */
void
redirect_edge_var_map_destroy (void)
{
- if (edge_var_maps)
- {
- pointer_map_traverse (edge_var_maps, free_var_map_entry, NULL);
- pointer_map_destroy (edge_var_maps);
- edge_var_maps = NULL;
- }
+ delete edge_var_maps;
+ edge_var_maps = NULL;
}
edge
ssa_redirect_edge (edge e, basic_block dest)
{
- gimple_stmt_iterator gsi;
- gimple phi;
+ gphi_iterator gsi;
+ gphi *phi;
redirect_edge_var_map_clear (e);
tree def;
source_location locus ;
- phi = gsi_stmt (gsi);
+ phi = gsi.phi ();
def = gimple_phi_arg_def (phi, e->dest_idx);
locus = gimple_phi_arg_location (phi, e->dest_idx);
void
flush_pending_stmts (edge e)
{
- gimple phi;
- edge_var_map_vector v;
+ gphi *phi;
edge_var_map *vm;
int i;
- gimple_stmt_iterator gsi;
+ gphi_iterator gsi;
- v = redirect_edge_var_map_vector (e);
+ vec<edge_var_map> *v = redirect_edge_var_map_vector (e);
if (!v)
return;
for (gsi = gsi_start_phis (e->dest), i = 0;
- !gsi_end_p (gsi) && VEC_iterate (edge_var_map, v, i, vm);
+ !gsi_end_p (gsi) && v->iterate (i, &vm);
gsi_next (&gsi), i++)
{
tree def;
- phi = gsi_stmt (gsi);
+ phi = gsi.phi ();
def = redirect_edge_var_map_def (vm);
add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm));
}
redirect_edge_var_map_clear (e);
}
+/* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
+ GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
+ expression with a different value.
+
+ This will update any annotations (say debug bind stmts) referring
+ to the original LHS, so that they use the RHS instead. This is
+ done even if NLHS and LHS are the same, for it is understood that
+ the RHS will be modified afterwards, and NLHS will not be assigned
+ an equivalent value.
+
+ Adjusting any non-annotation uses of the LHS, if needed, is a
+ responsibility of the caller.
+
+ The effect of this call should be pretty much the same as that of
+ inserting a copy of STMT before STMT, and then removing the
+ original stmt, at which time gsi_remove() would have update
+ annotations, but using this function saves all the inserting,
+ copying and removing. */
+
+void
+gimple_replace_ssa_lhs (gimple stmt, tree nlhs)
+{
+ if (MAY_HAVE_DEBUG_STMTS)
+ {
+ tree lhs = gimple_get_lhs (stmt);
+
+ gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
+
+ insert_debug_temp_for_var_def (NULL, lhs);
+ }
+
+ gimple_set_lhs (stmt, nlhs);
+}
+
+
/* Given a tree for an expression for which we might want to emit
locations or values in debug information (generally a variable, but
we might deal with other kinds of trees in the future), return the
if (!MAY_HAVE_DEBUG_STMTS)
return NULL_TREE;
- if (TREE_CODE (var) != VAR_DECL
+ if (TREE_CODE (var) == SSA_NAME)
+ {
+ var = SSA_NAME_VAR (var);
+ if (var == NULL_TREE)
+ return NULL_TREE;
+ }
+
+ if ((TREE_CODE (var) != VAR_DECL
+ || VAR_DECL_IS_VIRTUAL_OPERAND (var))
&& TREE_CODE (var) != PARM_DECL)
return NULL_TREE;
if (DECL_IGNORED_P (var))
return NULL_TREE;
- if (!is_gimple_reg (var))
+ /* var-tracking only tracks registers. */
+ if (!is_gimple_reg_type (TREE_TYPE (var)))
return NULL_TREE;
return var;
we'll have to drop debug information. */
if (gimple_code (def_stmt) == GIMPLE_PHI)
{
- value = degenerate_phi_result (def_stmt);
+ value = degenerate_phi_result (as_a <gphi *> (def_stmt));
if (value && walk_tree (&value, find_released_ssa_name, NULL, NULL))
value = NULL;
+ /* error_mark_node is what fixup_noreturn_call changes PHI arguments
+ to. */
+ else if (value == error_mark_node)
+ value = NULL;
}
else if (is_gimple_assign (def_stmt))
{
&& (!gimple_assign_single_p (def_stmt)
|| is_gimple_min_invariant (value)))
|| is_gimple_reg (value))
- value = unshare_expr (value);
+ ;
else
{
- gimple def_temp;
+ gdebug *def_temp;
tree vexpr = make_node (DEBUG_EXPR_DECL);
def_temp = gimple_build_debug_bind (vexpr,
that was unshared when we found it had a single debug
use, or a DEBUG_EXPR_DECL, that can be safely
shared. */
- SET_USE (use_p, value);
+ SET_USE (use_p, unshare_expr (value));
/* If we didn't replace uses with a debug decl fold the
resulting expression. Otherwise we end up with invalid IL. */
if (TREE_CODE (value) != DEBUG_EXPR_DECL)
- fold_stmt_inplace (stmt);
+ {
+ gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
+ fold_stmt_inplace (&gsi);
+ }
}
else
gimple_debug_bind_reset_value (stmt);
}
}
+/* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
+
+void
+reset_debug_uses (gimple stmt)
+{
+ ssa_op_iter op_iter;
+ def_operand_p def_p;
+ imm_use_iterator imm_iter;
+ gimple use_stmt;
+
+ if (!MAY_HAVE_DEBUG_STMTS)
+ return;
+
+ FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF)
+ {
+ tree var = DEF_FROM_PTR (def_p);
+
+ if (TREE_CODE (var) != SSA_NAME)
+ continue;
+
+ FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, var)
+ {
+ if (!gimple_debug_bind_p (use_stmt))
+ continue;
+
+ gimple_debug_bind_reset_value (use_stmt);
+ update_stmt (use_stmt);
+ }
+ }
+}
+
/* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
dominated stmts before their dominators, so that release_ssa_defs
stands a chance of propagating DEFs into debug bind stmts. */
return true;
}
- if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
+ if (SSA_NAME_IN_FREE_LIST (ssa_name))
{
- error ("type mismatch between an SSA_NAME and its symbol");
+ error ("found an SSA_NAME that had been released into the free pool");
return true;
}
- if (SSA_NAME_IN_FREE_LIST (ssa_name))
+ if (SSA_NAME_VAR (ssa_name) != NULL_TREE
+ && TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
{
- error ("found an SSA_NAME that had been released into the free pool");
+ error ("type mismatch between an SSA_NAME and its symbol");
return true;
}
- if (is_virtual && is_gimple_reg (ssa_name))
+ if (is_virtual && !virtual_operand_p (ssa_name))
{
error ("found a virtual definition for a GIMPLE register");
return true;
return true;
}
- if (!is_virtual && !is_gimple_reg (ssa_name))
+ if (!is_virtual && virtual_operand_p (ssa_name))
{
error ("found a real definition for a non-register");
return true;
if (verify_ssa_name (ssa_name, is_virtual))
goto err;
- if (TREE_CODE (SSA_NAME_VAR (ssa_name)) == RESULT_DECL
+ if (SSA_NAME_VAR (ssa_name)
+ && TREE_CODE (SSA_NAME_VAR (ssa_name)) == RESULT_DECL
&& DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name)))
{
error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
definition of SSA_NAME. */
static bool
-verify_phi_args (gimple phi, basic_block bb, basic_block *definition_block)
+verify_phi_args (gphi *phi, basic_block bb, basic_block *definition_block)
{
edge e;
bool err = false;
if (TREE_CODE (op) == SSA_NAME)
{
- err = verify_ssa_name (op, !is_gimple_reg (gimple_phi_result (phi)));
+ err = verify_ssa_name (op, virtual_operand_p (gimple_phi_result (phi)));
err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
}
TODO: verify the variable annotations. */
DEBUG_FUNCTION void
-verify_ssa (bool check_modified_stmt)
+verify_ssa (bool check_modified_stmt, bool check_ssa_operands)
{
size_t i;
basic_block bb;
gcc_assert (!need_ssa_update_p (cfun));
- verify_gimple_in_cfg (cfun);
-
timevar_push (TV_TREE_SSA_VERIFY);
/* Keep track of SSA names present in the IL. */
gimple stmt;
TREE_VISITED (name) = 0;
+ verify_ssa_name (name, virtual_operand_p (name));
+
stmt = SSA_NAME_DEF_STMT (name);
if (!gimple_nop_p (stmt))
{
basic_block bb = gimple_bb (stmt);
- verify_def (bb, definition_block,
- name, stmt, !is_gimple_reg (name));
-
+ if (verify_def (bb, definition_block,
+ name, stmt, virtual_operand_p (name)))
+ goto err;
}
}
}
/* Now verify all the uses and make sure they agree with the definitions
found in the previous pass. */
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
{
edge e;
- gimple phi;
edge_iterator ei;
- gimple_stmt_iterator gsi;
/* Make sure that all edges have a clear 'aux' field. */
FOR_EACH_EDGE (e, ei, bb->preds)
}
/* Verify the arguments for every PHI node in the block. */
- for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- phi = gsi_stmt (gsi);
+ gphi *phi = gsi.phi ();
if (verify_phi_args (phi, bb, definition_block))
goto err;
}
/* Now verify all the uses and vuses in every statement of the block. */
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
use_operand_p use_p;
- bool has_err;
- int count;
- unsigned i;
if (check_modified_stmt && gimple_modified_p (stmt))
{
goto err;
}
- if (is_gimple_assign (stmt)
- && TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
- {
- tree lhs, base_address;
-
- lhs = gimple_assign_lhs (stmt);
- base_address = get_base_address (lhs);
-
- if (base_address
- && SSA_VAR_P (base_address)
- && !gimple_vdef (stmt)
- && optimize > 0)
- {
- error ("statement makes a memory store, but has no VDEFS");
- print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
- goto err;
- }
- }
- else if (gimple_debug_bind_p (stmt)
- && !gimple_debug_bind_has_value_p (stmt))
- continue;
-
- /* Verify the single virtual operand and its constraints. */
- has_err = false;
- if (gimple_vdef (stmt))
+ if (check_ssa_operands && verify_ssa_operands (cfun, stmt))
{
- if (gimple_vdef_op (stmt) == NULL_DEF_OPERAND_P)
- {
- error ("statement has VDEF operand not in defs list");
- has_err = true;
- }
- if (!gimple_vuse (stmt))
- {
- error ("statement has VDEF but no VUSE operand");
- has_err = true;
- }
- else if (SSA_NAME_VAR (gimple_vdef (stmt))
- != SSA_NAME_VAR (gimple_vuse (stmt)))
- {
- error ("VDEF and VUSE do not use the same symbol");
- has_err = true;
- }
- has_err |= verify_ssa_name (gimple_vdef (stmt), true);
- }
- if (gimple_vuse (stmt))
- {
- if (gimple_vuse_op (stmt) == NULL_USE_OPERAND_P)
- {
- error ("statement has VUSE operand not in uses list");
- has_err = true;
- }
- has_err |= verify_ssa_name (gimple_vuse (stmt), true);
- }
- if (has_err)
- {
- error ("in statement");
- print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
+ print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
goto err;
}
- count = 0;
- FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF)
- {
- if (verify_ssa_name (op, false))
- {
- error ("in statement");
- print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
- goto err;
- }
- count++;
- }
-
- for (i = 0; i < gimple_num_ops (stmt); i++)
- {
- op = gimple_op (stmt, i);
- if (op && TREE_CODE (op) == SSA_NAME && --count < 0)
- {
- error ("number of operands and imm-links don%'t agree"
- " in statement");
- print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
- goto err;
- }
- }
+ if (gimple_debug_bind_p (stmt)
+ && !gimple_debug_bind_has_value_p (stmt))
+ continue;
FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
{
internal_error ("verify_ssa failed");
}
-/* Return true if the uid in both int tree maps are equal. */
-int
-int_tree_map_eq (const void *va, const void *vb)
-{
- const struct int_tree_map *a = (const struct int_tree_map *) va;
- const struct int_tree_map *b = (const struct int_tree_map *) vb;
- return (a->uid == b->uid);
-}
-
-/* Hash a UID in a int_tree_map. */
+/* Initialize global DFA and SSA structures. */
-unsigned int
-int_tree_map_hash (const void *item)
+void
+init_tree_ssa (struct function *fn)
{
- return ((const struct int_tree_map *)item)->uid;
+ fn->gimple_df = ggc_cleared_alloc<gimple_df> ();
+ fn->gimple_df->default_defs = hash_table<ssa_name_hasher>::create_ggc (20);
+ pt_solution_reset (&fn->gimple_df->escaped);
+ init_ssanames (fn, 0);
}
-/* Return true if the DECL_UID in both trees are equal. */
+/* Do the actions required to initialize internal data structures used
+ in tree-ssa optimization passes. */
-int
-uid_decl_map_eq (const void *va, const void *vb)
+static unsigned int
+execute_init_datastructures (void)
{
- const_tree a = (const_tree) va;
- const_tree b = (const_tree) vb;
- return (a->decl_minimal.uid == b->decl_minimal.uid);
+ /* Allocate hash tables, arrays and other structures. */
+ gcc_assert (!cfun->gimple_df);
+ init_tree_ssa (cfun);
+ return 0;
}
-/* Hash a tree in a uid_decl_map. */
+namespace {
-unsigned int
-uid_decl_map_hash (const void *item)
+const pass_data pass_data_init_datastructures =
{
- return ((const_tree)item)->decl_minimal.uid;
-}
-
-/* Return true if the DECL_UID in both trees are equal. */
+ GIMPLE_PASS, /* type */
+ "*init_datastructures", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ TV_NONE, /* tv_id */
+ PROP_cfg, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0, /* todo_flags_finish */
+};
-static int
-uid_ssaname_map_eq (const void *va, const void *vb)
+class pass_init_datastructures : public gimple_opt_pass
{
- const_tree a = (const_tree) va;
- const_tree b = (const_tree) vb;
- return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid);
-}
+public:
+ pass_init_datastructures (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_init_datastructures, ctxt)
+ {}
-/* Hash a tree in a uid_decl_map. */
+ /* opt_pass methods: */
+ virtual bool gate (function *fun)
+ {
+ /* Do nothing for funcions that was produced already in SSA form. */
+ return !(fun->curr_properties & PROP_ssa);
+ }
-static unsigned int
-uid_ssaname_map_hash (const void *item)
-{
- return ((const_tree)item)->ssa_name.var->decl_minimal.uid;
-}
+ virtual unsigned int execute (function *)
+ {
+ return execute_init_datastructures ();
+ }
+}; // class pass_init_datastructures
-/* Initialize global DFA and SSA structures. */
+} // anon namespace
-void
-init_tree_ssa (struct function *fn)
+gimple_opt_pass *
+make_pass_init_datastructures (gcc::context *ctxt)
{
- fn->gimple_df = ggc_alloc_cleared_gimple_df ();
- fn->gimple_df->referenced_vars = htab_create_ggc (20, uid_decl_map_hash,
- uid_decl_map_eq, NULL);
- fn->gimple_df->default_defs = htab_create_ggc (20, uid_ssaname_map_hash,
- uid_ssaname_map_eq, NULL);
- pt_solution_reset (&fn->gimple_df->escaped);
- init_ssanames (fn, 0);
- init_phinodes ();
+ return new pass_init_datastructures (ctxt);
}
-
/* Deallocate memory associated with SSA data structures for FNDECL. */
void
delete_tree_ssa (void)
{
- referenced_var_iterator rvi;
- tree var;
-
- /* Remove annotations from every referenced local variable. */
- FOR_EACH_REFERENCED_VAR (cfun, var, rvi)
- {
- if (is_global_var (var))
- continue;
- if (var_ann (var))
- {
- ggc_free (var_ann (var));
- *DECL_VAR_ANN_PTR (var) = NULL;
- }
- }
- htab_delete (gimple_referenced_vars (cfun));
- cfun->gimple_df->referenced_vars = NULL;
-
fini_ssanames ();
- fini_phinodes ();
/* We no longer maintain the SSA operand cache at this point. */
- if (ssa_operands_active ())
- fini_ssa_operands ();
-
- delete_alias_heapvars ();
+ if (ssa_operands_active (cfun))
+ fini_ssa_operands (cfun);
- htab_delete (cfun->gimple_df->default_defs);
+ cfun->gimple_df->default_defs->empty ();
cfun->gimple_df->default_defs = NULL;
pt_solution_reset (&cfun->gimple_df->escaped);
if (cfun->gimple_df->decls_to_pointers != NULL)
- pointer_map_destroy (cfun->gimple_df->decls_to_pointers);
+ delete cfun->gimple_df->decls_to_pointers;
cfun->gimple_df->decls_to_pointers = NULL;
cfun->gimple_df->modified_noreturn_calls = NULL;
cfun->gimple_df = NULL;
redirect_edge_var_map_destroy ();
}
-/* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
- useless type conversion, otherwise return false.
-
- This function implicitly defines the middle-end type system. With
- the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
- holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
- the following invariants shall be fulfilled:
-
- 1) useless_type_conversion_p is transitive.
- If a < b and b < c then a < c.
-
- 2) useless_type_conversion_p is not symmetric.
- From a < b does not follow a > b.
-
- 3) Types define the available set of operations applicable to values.
- A type conversion is useless if the operations for the target type
- is a subset of the operations for the source type. For example
- casts to void* are useless, casts from void* are not (void* can't
- be dereferenced or offsetted, but copied, hence its set of operations
- is a strict subset of that of all other data pointer types). Casts
- to const T* are useless (can't be written to), casts from const T*
- to T* are not. */
-
-bool
-useless_type_conversion_p (tree outer_type, tree inner_type)
-{
- /* Do the following before stripping toplevel qualifiers. */
- if (POINTER_TYPE_P (inner_type)
- && POINTER_TYPE_P (outer_type))
- {
- /* Do not lose casts between pointers to different address spaces. */
- if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
- != TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))
- return false;
-
- /* Do not lose casts to restrict qualified pointers. */
- if ((TYPE_RESTRICT (outer_type)
- != TYPE_RESTRICT (inner_type))
- && TYPE_RESTRICT (outer_type))
- return false;
-
- /* If the outer type is (void *) or a pointer to an incomplete
- record type or a pointer to an unprototyped function,
- then the conversion is not necessary. */
- if (VOID_TYPE_P (TREE_TYPE (outer_type))
- || ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
- || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
- && (TREE_CODE (TREE_TYPE (outer_type))
- == TREE_CODE (TREE_TYPE (inner_type)))
- && !prototype_p (TREE_TYPE (outer_type))
- && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type)),
- TREE_TYPE (TREE_TYPE (inner_type)))))
- return true;
- }
-
- /* From now on qualifiers on value types do not matter. */
- inner_type = TYPE_MAIN_VARIANT (inner_type);
- outer_type = TYPE_MAIN_VARIANT (outer_type);
-
- if (inner_type == outer_type)
- return true;
-
- /* If we know the canonical types, compare them. */
- if (TYPE_CANONICAL (inner_type)
- && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type))
- return true;
-
- /* Changes in machine mode are never useless conversions unless we
- deal with aggregate types in which case we defer to later checks. */
- if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type)
- && !AGGREGATE_TYPE_P (inner_type))
- return false;
-
- /* If both the inner and outer types are integral types, then the
- conversion is not necessary if they have the same mode and
- signedness and precision, and both or neither are boolean. */
- if (INTEGRAL_TYPE_P (inner_type)
- && INTEGRAL_TYPE_P (outer_type))
- {
- /* Preserve changes in signedness or precision. */
- if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
- || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
- return false;
-
- /* We don't need to preserve changes in the types minimum or
- maximum value in general as these do not generate code
- unless the types precisions are different. */
- return true;
- }
-
- /* Scalar floating point types with the same mode are compatible. */
- else if (SCALAR_FLOAT_TYPE_P (inner_type)
- && SCALAR_FLOAT_TYPE_P (outer_type))
- return true;
-
- /* Fixed point types with the same mode are compatible. */
- else if (FIXED_POINT_TYPE_P (inner_type)
- && FIXED_POINT_TYPE_P (outer_type))
- return true;
-
- /* We need to take special care recursing to pointed-to types. */
- else if (POINTER_TYPE_P (inner_type)
- && POINTER_TYPE_P (outer_type))
- {
- /* Do not lose casts to function pointer types. */
- if ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
- || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
- && !useless_type_conversion_p (TREE_TYPE (outer_type),
- TREE_TYPE (inner_type)))
- return false;
-
- /* We do not care for const qualification of the pointed-to types
- as const qualification has no semantic value to the middle-end. */
-
- /* Otherwise pointers/references are equivalent. */
- return true;
- }
-
- /* Recurse for complex types. */
- else if (TREE_CODE (inner_type) == COMPLEX_TYPE
- && TREE_CODE (outer_type) == COMPLEX_TYPE)
- return useless_type_conversion_p (TREE_TYPE (outer_type),
- TREE_TYPE (inner_type));
-
- /* Recurse for vector types with the same number of subparts. */
- else if (TREE_CODE (inner_type) == VECTOR_TYPE
- && TREE_CODE (outer_type) == VECTOR_TYPE
- && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
- return useless_type_conversion_p (TREE_TYPE (outer_type),
- TREE_TYPE (inner_type));
-
- else if (TREE_CODE (inner_type) == ARRAY_TYPE
- && TREE_CODE (outer_type) == ARRAY_TYPE)
- {
- /* Preserve string attributes. */
- if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type))
- return false;
-
- /* Conversions from array types with unknown extent to
- array types with known extent are not useless. */
- if (!TYPE_DOMAIN (inner_type)
- && TYPE_DOMAIN (outer_type))
- return false;
-
- /* Nor are conversions from array types with non-constant size to
- array types with constant size or to different size. */
- if (TYPE_SIZE (outer_type)
- && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST
- && (!TYPE_SIZE (inner_type)
- || TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST
- || !tree_int_cst_equal (TYPE_SIZE (outer_type),
- TYPE_SIZE (inner_type))))
- return false;
-
- /* Check conversions between arrays with partially known extents.
- If the array min/max values are constant they have to match.
- Otherwise allow conversions to unknown and variable extents.
- In particular this declares conversions that may change the
- mode to BLKmode as useless. */
- if (TYPE_DOMAIN (inner_type)
- && TYPE_DOMAIN (outer_type)
- && TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type))
- {
- tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type));
- tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type));
- tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type));
- tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type));
-
- /* After gimplification a variable min/max value carries no
- additional information compared to a NULL value. All that
- matters has been lowered to be part of the IL. */
- if (inner_min && TREE_CODE (inner_min) != INTEGER_CST)
- inner_min = NULL_TREE;
- if (outer_min && TREE_CODE (outer_min) != INTEGER_CST)
- outer_min = NULL_TREE;
- if (inner_max && TREE_CODE (inner_max) != INTEGER_CST)
- inner_max = NULL_TREE;
- if (outer_max && TREE_CODE (outer_max) != INTEGER_CST)
- outer_max = NULL_TREE;
-
- /* Conversions NULL / variable <- cst are useless, but not
- the other way around. */
- if (outer_min
- && (!inner_min
- || !tree_int_cst_equal (inner_min, outer_min)))
- return false;
- if (outer_max
- && (!inner_max
- || !tree_int_cst_equal (inner_max, outer_max)))
- return false;
- }
-
- /* Recurse on the element check. */
- return useless_type_conversion_p (TREE_TYPE (outer_type),
- TREE_TYPE (inner_type));
- }
-
- else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
- || TREE_CODE (inner_type) == METHOD_TYPE)
- && TREE_CODE (inner_type) == TREE_CODE (outer_type))
- {
- tree outer_parm, inner_parm;
-
- /* If the return types are not compatible bail out. */
- if (!useless_type_conversion_p (TREE_TYPE (outer_type),
- TREE_TYPE (inner_type)))
- return false;
-
- /* Method types should belong to a compatible base class. */
- if (TREE_CODE (inner_type) == METHOD_TYPE
- && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type),
- TYPE_METHOD_BASETYPE (inner_type)))
- return false;
-
- /* A conversion to an unprototyped argument list is ok. */
- if (!prototype_p (outer_type))
- return true;
-
- /* If the unqualified argument types are compatible the conversion
- is useless. */
- if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type))
- return true;
-
- for (outer_parm = TYPE_ARG_TYPES (outer_type),
- inner_parm = TYPE_ARG_TYPES (inner_type);
- outer_parm && inner_parm;
- outer_parm = TREE_CHAIN (outer_parm),
- inner_parm = TREE_CHAIN (inner_parm))
- if (!useless_type_conversion_p
- (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)),
- TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm))))
- return false;
-
- /* If there is a mismatch in the number of arguments the functions
- are not compatible. */
- if (outer_parm || inner_parm)
- return false;
-
- /* Defer to the target if necessary. */
- if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
- return comp_type_attributes (outer_type, inner_type) != 0;
-
- return true;
- }
-
- /* For aggregates we rely on TYPE_CANONICAL exclusively and require
- explicit conversions for types involving to be structurally
- compared types. */
- else if (AGGREGATE_TYPE_P (inner_type)
- && TREE_CODE (inner_type) == TREE_CODE (outer_type))
- return false;
-
- return false;
-}
-
-/* Return true if a conversion from either type of TYPE1 and TYPE2
- to the other is not required. Otherwise return false. */
-
-bool
-types_compatible_p (tree type1, tree type2)
-{
- return (type1 == type2
- || (useless_type_conversion_p (type1, type2)
- && useless_type_conversion_p (type2, type1)));
-}
-
/* Return true if EXPR is a useless type conversion, otherwise return
false. */
}
-/* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
- described in walk_use_def_chains.
-
- VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
- infinite loops. We used to have a bitmap for this to just mark
- SSA versions we had visited. But non-sparse bitmaps are way too
- expensive, while sparse bitmaps may cause quadratic behavior.
+/* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
+ should be returned if the value is only partially undefined. */
- IS_DFS is true if the caller wants to perform a depth-first search
- when visiting PHI nodes. A DFS will visit each PHI argument and
- call FN after each one. Otherwise, all the arguments are
- visited first and then FN is called with each of the visited
- arguments in a separate pass. */
-
-static bool
-walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
- struct pointer_set_t *visited, bool is_dfs)
+bool
+ssa_undefined_value_p (tree t, bool partial)
{
gimple def_stmt;
+ tree var = SSA_NAME_VAR (t);
- if (pointer_set_insert (visited, var))
+ if (!var)
+ ;
+ /* Parameters get their initial value from the function entry. */
+ else if (TREE_CODE (var) == PARM_DECL)
+ return false;
+ /* When returning by reference the return address is actually a hidden
+ parameter. */
+ else if (TREE_CODE (var) == RESULT_DECL && DECL_BY_REFERENCE (var))
+ return false;
+ /* Hard register variables get their initial value from the ether. */
+ else if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
return false;
- def_stmt = SSA_NAME_DEF_STMT (var);
+ /* The value is undefined iff its definition statement is empty. */
+ def_stmt = SSA_NAME_DEF_STMT (t);
+ if (gimple_nop_p (def_stmt))
+ return true;
- if (gimple_code (def_stmt) != GIMPLE_PHI)
+ /* Check if the complex was not only partially defined. */
+ if (partial && is_gimple_assign (def_stmt)
+ && gimple_assign_rhs_code (def_stmt) == COMPLEX_EXPR)
{
- /* If we reached the end of the use-def chain, call FN. */
- return fn (var, def_stmt, data);
- }
- else
- {
- size_t i;
-
- /* When doing a breadth-first search, call FN before following the
- use-def links for each argument. */
- if (!is_dfs)
- for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
- if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
- return true;
-
- /* Follow use-def links out of each PHI argument. */
- for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
- {
- tree arg = gimple_phi_arg_def (def_stmt, i);
+ tree rhs1, rhs2;
- /* ARG may be NULL for newly introduced PHI nodes. */
- if (arg
- && TREE_CODE (arg) == SSA_NAME
- && walk_use_def_chains_1 (arg, fn, data, visited, is_dfs))
- return true;
- }
-
- /* When doing a depth-first search, call FN after following the
- use-def links for each argument. */
- if (is_dfs)
- for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
- if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
- return true;
+ rhs1 = gimple_assign_rhs1 (def_stmt);
+ rhs2 = gimple_assign_rhs2 (def_stmt);
+ return (TREE_CODE (rhs1) == SSA_NAME && ssa_undefined_value_p (rhs1))
+ || (TREE_CODE (rhs2) == SSA_NAME && ssa_undefined_value_p (rhs2));
}
-
return false;
}
-
-/* Walk use-def chains starting at the SSA variable VAR. Call
- function FN at each reaching definition found. FN takes three
- arguments: VAR, its defining statement (DEF_STMT) and a generic
- pointer to whatever state information that FN may want to maintain
- (DATA). FN is able to stop the walk by returning true, otherwise
- in order to continue the walk, FN should return false.
-
- Note, that if DEF_STMT is a PHI node, the semantics are slightly
- different. The first argument to FN is no longer the original
- variable VAR, but the PHI argument currently being examined. If FN
- wants to get at VAR, it should call PHI_RESULT (PHI).
-
- If IS_DFS is true, this function will:
-
- 1- walk the use-def chains for all the PHI arguments, and,
- 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
-
- If IS_DFS is false, the two steps above are done in reverse order
- (i.e., a breadth-first search). */
-
-void
-walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
- bool is_dfs)
-{
- gimple def_stmt;
-
- gcc_assert (TREE_CODE (var) == SSA_NAME);
-
- def_stmt = SSA_NAME_DEF_STMT (var);
-
- /* We only need to recurse if the reaching definition comes from a PHI
- node. */
- if (gimple_code (def_stmt) != GIMPLE_PHI)
- (*fn) (var, def_stmt, data);
- else
- {
- struct pointer_set_t *visited = pointer_set_create ();
- walk_use_def_chains_1 (var, fn, data, visited, is_dfs);
- pointer_set_destroy (visited);
- }
-}
-
-\f
-/* Emit warnings for uninitialized variables. This is done in two passes.
-
- The first pass notices real uses of SSA names with undefined values.
- Such uses are unconditionally uninitialized, and we can be certain that
- such a use is a mistake. This pass is run before most optimizations,
- so that we catch as many as we can.
-
- The second pass follows PHI nodes to find uses that are potentially
- uninitialized. In this case we can't necessarily prove that the use
- is really uninitialized. This pass is run after most optimizations,
- so that we thread as many jumps and possible, and delete as much dead
- code as possible, in order to reduce false positives. We also look
- again for plain uninitialized variables, since optimization may have
- changed conditionally uninitialized to unconditionally uninitialized. */
-
-/* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
- warning text is in MSGID and LOCUS may contain a location or be null. */
-
-void
-warn_uninit (tree t, const char *gmsgid, void *data)
-{
- tree var = SSA_NAME_VAR (t);
- gimple context = (gimple) data;
- location_t location;
- expanded_location xloc, floc;
-
- if (!ssa_undefined_value_p (t))
- return;
-
- /* TREE_NO_WARNING either means we already warned, or the front end
- wishes to suppress the warning. */
- if (TREE_NO_WARNING (var))
- return;
-
- /* Do not warn if it can be initialized outside this module. */
- if (is_global_var (var))
- return;
-
- location = (context != NULL && gimple_has_location (context))
- ? gimple_location (context)
- : DECL_SOURCE_LOCATION (var);
- xloc = expand_location (location);
- floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
- if (warning_at (location, OPT_Wuninitialized, gmsgid, var))
- {
- TREE_NO_WARNING (var) = 1;
-
- if (location == DECL_SOURCE_LOCATION (var))
- return;
- if (xloc.file != floc.file
- || xloc.line < floc.line
- || xloc.line > LOCATION_LINE (cfun->function_end_locus))
- inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var);
- }
-}
-
-struct walk_data {
- gimple stmt;
- bool always_executed;
- bool warn_possibly_uninitialized;
-};
-
-/* Called via walk_tree, look for SSA_NAMEs that have empty definitions
- and warn about them. */
-
-static tree
-warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_)
-{
- struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
- struct walk_data *data = (struct walk_data *) wi->info;
- tree t = *tp;
-
- /* We do not care about LHS. */
- if (wi->is_lhs)
- {
- /* Except for operands of dereferences. */
- if (!INDIRECT_REF_P (t)
- && TREE_CODE (t) != MEM_REF)
- return NULL_TREE;
- t = TREE_OPERAND (t, 0);
- }
-
- switch (TREE_CODE (t))
- {
- case ADDR_EXPR:
- /* Taking the address of an uninitialized variable does not
- count as using it. */
- *walk_subtrees = 0;
- break;
-
- case VAR_DECL:
- {
- /* A VAR_DECL in the RHS of a gimple statement may mean that
- this variable is loaded from memory. */
- use_operand_p vuse;
- tree op;
-
- /* If there is not gimple stmt,
- or alias information has not been computed,
- then we cannot check VUSE ops. */
- if (data->stmt == NULL)
- return NULL_TREE;
-
- /* If the load happens as part of a call do not warn about it. */
- if (is_gimple_call (data->stmt))
- return NULL_TREE;
-
- vuse = gimple_vuse_op (data->stmt);
- if (vuse == NULL_USE_OPERAND_P)
- return NULL_TREE;
-
- op = USE_FROM_PTR (vuse);
- if (t != SSA_NAME_VAR (op)
- || !SSA_NAME_IS_DEFAULT_DEF (op))
- return NULL_TREE;
- /* If this is a VUSE of t and it is the default definition,
- then warn about op. */
- t = op;
- /* Fall through into SSA_NAME. */
- }
-
- case SSA_NAME:
- /* We only do data flow with SSA_NAMEs, so that's all we
- can warn about. */
- if (data->always_executed)
- warn_uninit (t, "%qD is used uninitialized in this function",
- data->stmt);
- else if (data->warn_possibly_uninitialized)
- warn_uninit (t, "%qD may be used uninitialized in this function",
- data->stmt);
- *walk_subtrees = 0;
- break;
-
- case REALPART_EXPR:
- case IMAGPART_EXPR:
- /* The total store transformation performed during gimplification
- creates uninitialized variable uses. If all is well, these will
- be optimized away, so don't warn now. */
- if (TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME)
- *walk_subtrees = 0;
- break;
-
- default:
- if (IS_TYPE_OR_DECL_P (t))
- *walk_subtrees = 0;
- break;
- }
-
- return NULL_TREE;
-}
-
-unsigned int
-warn_uninitialized_vars (bool warn_possibly_uninitialized)
-{
- gimple_stmt_iterator gsi;
- basic_block bb;
- struct walk_data data;
-
- data.warn_possibly_uninitialized = warn_possibly_uninitialized;
-
-
- FOR_EACH_BB (bb)
- {
- data.always_executed = dominated_by_p (CDI_POST_DOMINATORS,
- single_succ (ENTRY_BLOCK_PTR), bb);
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
- {
- struct walk_stmt_info wi;
- data.stmt = gsi_stmt (gsi);
- if (is_gimple_debug (data.stmt))
- continue;
- memset (&wi, 0, sizeof (wi));
- wi.info = &data;
- walk_gimple_op (gsi_stmt (gsi), warn_uninitialized_var, &wi);
- }
- }
-
- return 0;
-}
-
-static unsigned int
-execute_early_warn_uninitialized (void)
-{
- /* Currently, this pass runs always but
- execute_late_warn_uninitialized only runs with optimization. With
- optimization we want to warn about possible uninitialized as late
- as possible, thus don't do it here. However, without
- optimization we need to warn here about "may be uninitialized".
- */
- calculate_dominance_info (CDI_POST_DOMINATORS);
-
- warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize);
-
- /* Post-dominator information can not be reliably updated. Free it
- after the use. */
-
- free_dominance_info (CDI_POST_DOMINATORS);
- return 0;
-}
-
-static bool
-gate_warn_uninitialized (void)
-{
- return warn_uninitialized != 0;
-}
-
-struct gimple_opt_pass pass_early_warn_uninitialized =
-{
- {
- GIMPLE_PASS,
- "*early_warn_uninitialized", /* name */
- gate_warn_uninitialized, /* gate */
- execute_early_warn_uninitialized, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_TREE_UNINIT, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0 /* todo_flags_finish */
- }
-};
-
-
/* If necessary, rewrite the base of the reference tree *TP from
a MEM_REF to a plain or converted symbol. */
static void
-maybe_rewrite_mem_ref_base (tree *tp)
+maybe_rewrite_mem_ref_base (tree *tp, bitmap suitable_for_renaming)
{
tree sym;
&& (sym = TREE_OPERAND (TREE_OPERAND (*tp, 0), 0))
&& DECL_P (sym)
&& !TREE_ADDRESSABLE (sym)
- && symbol_marked_for_renaming (sym))
+ && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
{
if (TREE_CODE (TREE_TYPE (sym)) == VECTOR_TYPE
&& useless_type_conversion_p (TREE_TYPE (*tp),
TYPE_SIZE (TREE_TYPE (*tp)),
int_const_binop (MULT_EXPR,
bitsize_int (BITS_PER_UNIT),
- TREE_OPERAND (*tp, 1), 0));
+ TREE_OPERAND (*tp, 1)));
}
else if (TREE_CODE (TREE_TYPE (sym)) == COMPLEX_TYPE
&& useless_type_conversion_p (TREE_TYPE (*tp),
|| TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE)
&& useless_type_conversion_p (TREE_TYPE (base),
TREE_TYPE (TREE_TYPE (decl)))
- && double_int_fits_in_uhwi_p (mem_ref_offset (base))
- && double_int_ucmp
- (tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (decl))),
- mem_ref_offset (base)) == 1
+ && wi::fits_uhwi_p (mem_ref_offset (base))
+ && wi::gtu_p (wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl))),
+ mem_ref_offset (base))
&& multiple_of_p (sizetype, TREE_OPERAND (base, 1),
TYPE_SIZE_UNIT (TREE_TYPE (base))))
return NULL_TREE;
if (DECL_P (lhs))
return false;
+ /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
+ a reasonably efficient manner... */
+ if ((TREE_CODE (lhs) == REALPART_EXPR
+ || TREE_CODE (lhs) == IMAGPART_EXPR)
+ && DECL_P (TREE_OPERAND (lhs, 0)))
+ return false;
+
/* A decl that is wrapped inside a MEM-REF that covers
it full is also rewritable.
??? The following could be relaxed allowing component
mark the variable VAR for conversion into SSA. Return true when updating
stmts is required. */
-static bool
-maybe_optimize_var (tree var, bitmap addresses_taken, bitmap not_reg_needs)
+static void
+maybe_optimize_var (tree var, bitmap addresses_taken, bitmap not_reg_needs,
+ bitmap suitable_for_renaming)
{
- bool update_vops = false;
-
/* Global Variables, result decls cannot be changed. */
if (is_global_var (var)
|| TREE_CODE (var) == RESULT_DECL
|| bitmap_bit_p (addresses_taken, DECL_UID (var)))
- return false;
-
- /* If the variable is not in the list of referenced vars then we
- do not need to touch it nor can we rename it. */
- if (!referenced_var_lookup (cfun, DECL_UID (var)))
- return false;
+ return;
if (TREE_ADDRESSABLE (var)
/* Do not change TREE_ADDRESSABLE if we need to preserve var as
a non-register. Otherwise we are confused and forget to
add virtual operands for it. */
&& (!is_gimple_reg_type (TREE_TYPE (var))
+ || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE
+ || TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
|| !bitmap_bit_p (not_reg_needs, DECL_UID (var))))
{
TREE_ADDRESSABLE (var) = 0;
if (is_gimple_reg (var))
- mark_sym_for_renaming (var);
- update_vops = true;
+ bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
if (dump_file)
{
fprintf (dump_file, "No longer having address taken: ");
&& (TREE_CODE (var) != VAR_DECL || !DECL_HARD_REGISTER (var)))
{
DECL_GIMPLE_REG_P (var) = 1;
- mark_sym_for_renaming (var);
- update_vops = true;
+ bitmap_set_bit (suitable_for_renaming, DECL_UID (var));
if (dump_file)
{
fprintf (dump_file, "Now a gimple register: ");
fprintf (dump_file, "\n");
}
}
-
- return update_vops;
}
/* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
void
execute_update_addresses_taken (void)
{
- gimple_stmt_iterator gsi;
basic_block bb;
bitmap addresses_taken = BITMAP_ALLOC (NULL);
bitmap not_reg_needs = BITMAP_ALLOC (NULL);
- bool update_vops = false;
+ bitmap suitable_for_renaming = BITMAP_ALLOC (NULL);
tree var;
unsigned i;
/* Collect into ADDRESSES_TAKEN all variables whose address is taken within
the function body. */
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
{
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
enum gimple_code code = gimple_code (stmt);
else if (code == GIMPLE_ASM)
{
- for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
+ gasm *asm_stmt = as_a <gasm *> (stmt);
+ for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
{
- tree link = gimple_asm_output_op (stmt, i);
+ tree link = gimple_asm_output_op (asm_stmt, i);
tree lhs = TREE_VALUE (link);
if (TREE_CODE (lhs) != SSA_NAME)
{
bitmap_set_bit (not_reg_needs, DECL_UID (decl));
}
}
- for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
+ for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
{
- tree link = gimple_asm_input_op (stmt, i);
+ tree link = gimple_asm_input_op (asm_stmt, i);
if ((decl = non_rewritable_mem_ref_base (TREE_VALUE (link))))
bitmap_set_bit (not_reg_needs, DECL_UID (decl));
}
}
}
- for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
+ gsi_next (&gsi))
{
size_t i;
- gimple phi = gsi_stmt (gsi);
+ gphi *phi = gsi.phi ();
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
unused vars from BLOCK trees, which causes code generation differences
for -g vs. -g0. */
for (var = DECL_ARGUMENTS (cfun->decl); var; var = DECL_CHAIN (var))
- update_vops |= maybe_optimize_var (var, addresses_taken, not_reg_needs);
+ maybe_optimize_var (var, addresses_taken, not_reg_needs,
+ suitable_for_renaming);
- FOR_EACH_VEC_ELT (tree, cfun->local_decls, i, var)
- update_vops |= maybe_optimize_var (var, addresses_taken, not_reg_needs);
+ FOR_EACH_VEC_SAFE_ELT (cfun->local_decls, i, var)
+ maybe_optimize_var (var, addresses_taken, not_reg_needs,
+ suitable_for_renaming);
/* Operand caches need to be recomputed for operands referencing the updated
- variables. */
- if (update_vops)
+ variables and operands need to be rewritten to expose bare symbols. */
+ if (!bitmap_empty_p (suitable_for_renaming))
{
- FOR_EACH_BB (bb)
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ FOR_EACH_BB_FN (bb, cfun)
+ for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
{
gimple stmt = gsi_stmt (gsi);
tree rhs, *rhsp = gimple_assign_rhs1_ptr (stmt);
tree sym;
+ /* Rewrite LHS IMAG/REALPART_EXPR similar to
+ gimplify_modify_expr_complex_part. */
+ if ((TREE_CODE (lhs) == IMAGPART_EXPR
+ || TREE_CODE (lhs) == REALPART_EXPR)
+ && DECL_P (TREE_OPERAND (lhs, 0))
+ && bitmap_bit_p (suitable_for_renaming,
+ DECL_UID (TREE_OPERAND (lhs, 0))))
+ {
+ tree other = make_ssa_name (TREE_TYPE (lhs));
+ tree lrhs = build1 (TREE_CODE (lhs) == IMAGPART_EXPR
+ ? REALPART_EXPR : IMAGPART_EXPR,
+ TREE_TYPE (other),
+ TREE_OPERAND (lhs, 0));
+ gimple load = gimple_build_assign (other, lrhs);
+ location_t loc = gimple_location (stmt);
+ gimple_set_location (load, loc);
+ gimple_set_vuse (load, gimple_vuse (stmt));
+ gsi_insert_before (&gsi, load, GSI_SAME_STMT);
+ gimple_assign_set_lhs (stmt, TREE_OPERAND (lhs, 0));
+ gimple_assign_set_rhs_with_ops
+ (&gsi, COMPLEX_EXPR,
+ TREE_CODE (lhs) == IMAGPART_EXPR
+ ? other : gimple_assign_rhs1 (stmt),
+ TREE_CODE (lhs) == IMAGPART_EXPR
+ ? gimple_assign_rhs1 (stmt) : other, NULL_TREE);
+ stmt = gsi_stmt (gsi);
+ unlink_stmt_vdef (stmt);
+ update_stmt (stmt);
+ continue;
+ }
+
/* We shouldn't have any fancy wrapping of
component-refs on the LHS, but look through
VIEW_CONVERT_EXPRs as that is easy. */
&& (sym = TREE_OPERAND (TREE_OPERAND (lhs, 0), 0))
&& DECL_P (sym)
&& !TREE_ADDRESSABLE (sym)
- && symbol_marked_for_renaming (sym))
+ && bitmap_bit_p (suitable_for_renaming, DECL_UID (sym)))
lhs = sym;
else
lhs = gimple_assign_lhs (stmt);
/* Rewrite the RHS and make sure the resulting assignment
is validly typed. */
- maybe_rewrite_mem_ref_base (rhsp);
+ maybe_rewrite_mem_ref_base (rhsp, suitable_for_renaming);
rhs = gimple_assign_rhs1 (stmt);
if (gimple_assign_lhs (stmt) != lhs
&& !useless_type_conversion_p (TREE_TYPE (lhs),
for (i = 0; i < gimple_call_num_args (stmt); ++i)
{
tree *argp = gimple_call_arg_ptr (stmt, i);
- maybe_rewrite_mem_ref_base (argp);
+ maybe_rewrite_mem_ref_base (argp, suitable_for_renaming);
}
}
else if (gimple_code (stmt) == GIMPLE_ASM)
{
+ gasm *asm_stmt = as_a <gasm *> (stmt);
unsigned i;
- for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
+ for (i = 0; i < gimple_asm_noutputs (asm_stmt); ++i)
{
- tree link = gimple_asm_output_op (stmt, i);
- maybe_rewrite_mem_ref_base (&TREE_VALUE (link));
+ tree link = gimple_asm_output_op (asm_stmt, i);
+ maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
+ suitable_for_renaming);
}
- for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
+ for (i = 0; i < gimple_asm_ninputs (asm_stmt); ++i)
{
- tree link = gimple_asm_input_op (stmt, i);
- maybe_rewrite_mem_ref_base (&TREE_VALUE (link));
+ tree link = gimple_asm_input_op (asm_stmt, i);
+ maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
+ suitable_for_renaming);
}
}
+ else if (gimple_debug_bind_p (stmt)
+ && gimple_debug_bind_has_value_p (stmt))
+ {
+ tree *valuep = gimple_debug_bind_get_value_ptr (stmt);
+ tree decl;
+ maybe_rewrite_mem_ref_base (valuep, suitable_for_renaming);
+ decl = non_rewritable_mem_ref_base (*valuep);
+ if (decl
+ && bitmap_bit_p (suitable_for_renaming, DECL_UID (decl)))
+ gimple_debug_bind_reset_value (stmt);
+ }
+
if (gimple_references_memory_p (stmt)
|| is_gimple_debug (stmt))
update_stmt (stmt);
+
+ gsi_next (&gsi);
}
/* Update SSA form here, we are called as non-pass as well. */
- update_ssa (TODO_update_ssa);
+ if (number_of_loops (cfun) > 1
+ && loops_state_satisfies_p (LOOP_CLOSED_SSA))
+ rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
+ else
+ update_ssa (TODO_update_ssa);
}
BITMAP_FREE (not_reg_needs);
BITMAP_FREE (addresses_taken);
+ BITMAP_FREE (suitable_for_renaming);
timevar_pop (TV_ADDRESS_TAKEN);
}
-struct gimple_opt_pass pass_update_address_taken =
+namespace {
+
+const pass_data pass_data_update_address_taken =
{
- {
- GIMPLE_PASS,
- "addressables", /* name */
- NULL, /* gate */
- NULL, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_ADDRESS_TAKEN, /* tv_id */
- PROP_ssa, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- TODO_update_address_taken
- | TODO_dump_func /* todo_flags_finish */
- }
+ GIMPLE_PASS, /* type */
+ "addressables", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ TV_ADDRESS_TAKEN, /* tv_id */
+ PROP_ssa, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_update_address_taken, /* todo_flags_finish */
};
+
+class pass_update_address_taken : public gimple_opt_pass
+{
+public:
+ pass_update_address_taken (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_update_address_taken, ctxt)
+ {}
+
+ /* opt_pass methods: */
+
+}; // class pass_update_address_taken
+
+} // anon namespace
+
+gimple_opt_pass *
+make_pass_update_address_taken (gcc::context *ctxt)
+{
+ return new pass_update_address_taken (ctxt);
+}