/* Miscellaneous SSA utility functions.
- Copyright (C) 2001-2014 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 "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 "langhooks.h"
-#include "basic-block.h"
+#include "predict.h"
+#include "hard-reg-set.h"
#include "function.h"
+#include "dominance.h"
+#include "cfg.h"
+#include "basic-block.h"
#include "gimple-pretty-print.h"
-#include "pointer-set.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 "tree-into-ssa.h"
#include "tree-ssa.h"
#include "tree-inline.h"
-#include "hashtab.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 *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);
- head = (edge_var_map_vector *) *slot;
- if (!head)
- vec_safe_reserve (head, 5);
+ 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 (head, new_node);
- *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 (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;
- edge_var_map_vector *new_head = NULL;
- if (head)
- new_head = vec_safe_copy (head);
- else
- vec_safe_reserve (new_head, 5);
- *new_slot = new_head;
+ 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 (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;
{
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));
}
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
;
else
{
- gimple def_temp;
+ gdebug *def_temp;
tree vexpr = make_node (DEBUG_EXPR_DECL);
def_temp = gimple_build_debug_bind (vexpr,
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;
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;
internal_error ("verify_ssa failed");
}
-/* Return true if the DECL_UID in both trees are equal. */
-
-static int
-uid_ssaname_map_eq (const void *va, const void *vb)
-{
- 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);
-}
-
-/* Hash a tree in a uid_decl_map. */
-
-static unsigned int
-uid_ssaname_map_hash (const void *item)
-{
- return ((const_tree)item)->ssa_name.var->decl_minimal.uid;
-}
-
/* Initialize global DFA and SSA structures. */
void
init_tree_ssa (struct function *fn)
{
- fn->gimple_df = ggc_alloc_cleared_gimple_df ();
- fn->gimple_df->default_defs = htab_create_ggc (20, uid_ssaname_map_hash,
- uid_ssaname_map_eq, NULL);
+ 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);
}
GIMPLE_PASS, /* type */
"*init_datastructures", /* name */
OPTGROUP_NONE, /* optinfo_flags */
- true, /* has_execute */
TV_NONE, /* tv_id */
PROP_cfg, /* properties_required */
0, /* properties_provided */
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;
}
-/* Return true if T, an SSA_NAME, has an undefined value. */
+/* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
+ should be returned if the value is only partially undefined. */
bool
-ssa_undefined_value_p (tree t)
+ssa_undefined_value_p (tree t, bool partial)
{
+ gimple def_stmt;
tree var = SSA_NAME_VAR (t);
if (!var)
return false;
/* The value is undefined iff its definition statement is empty. */
- return gimple_nop_p (SSA_NAME_DEF_STMT (t));
+ def_stmt = SSA_NAME_DEF_STMT (t);
+ if (gimple_nop_p (def_stmt))
+ return true;
+
+ /* Check if the complex was not only partially defined. */
+ if (partial && is_gimple_assign (def_stmt)
+ && gimple_assign_rhs_code (def_stmt) == COMPLEX_EXPR)
+ {
+ tree rhs1, rhs2;
+
+ 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;
}
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
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);
the function body. */
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++)
{
if (!bitmap_empty_p (suitable_for_renaming))
{
FOR_EACH_BB_FN (bb, cfun)
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
+ 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. */
if (gimple_assign_lhs (stmt) != lhs)
gimple_assign_set_lhs (stmt, lhs);
- /* For var ={v} {CLOBBER}; where var lost
- TREE_ADDRESSABLE just remove the stmt. */
- if (DECL_P (lhs)
- && TREE_CLOBBER_P (rhs)
- && bitmap_bit_p (suitable_for_renaming, DECL_UID (lhs)))
- {
- unlink_stmt_vdef (stmt);
- gsi_remove (&gsi, true);
- release_defs (stmt);
- continue;
- }
-
if (gimple_assign_rhs1 (stmt) != rhs)
{
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
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);
+ 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);
+ tree link = gimple_asm_input_op (asm_stmt, i);
maybe_rewrite_mem_ref_base (&TREE_VALUE (link),
suitable_for_renaming);
}
GIMPLE_PASS, /* type */
"addressables", /* name */
OPTGROUP_NONE, /* optinfo_flags */
- false, /* has_execute */
TV_ADDRESS_TAKEN, /* tv_id */
PROP_ssa, /* properties_required */
0, /* properties_provided */
projects / gcc.git / blobdiff