#include "tree-data-ref.h"
#include "tree-scalar-evolution.h"
#include "tree-pass.h"
-#include "domwalk.h"
#include "value-prof.h"
#include "pointer-set.h"
#include "gimple.h"
#ifdef HAVE_cloog
+
+/* The CLooG header file is not -Wc++-compat ready as of 2009-05-11.
+ This #pragma should be removed when it is ready. */
+#if GCC_VERSION >= 4003
+#pragma GCC diagnostic warning "-Wc++-compat"
+#endif
+
#include "cloog/cloog.h"
#include "graphite.h"
sese
new_sese (edge entry, edge exit)
{
- sese res = XNEW (struct sese);
+ sese res = XNEW (struct sese_d);
SESE_ENTRY (res) = entry;
SESE_EXIT (res) = exit;
loop_iv_stack_push_iv (loop_iv_stack stack, tree iv, const char *name)
{
iv_stack_entry *entry = XNEW (iv_stack_entry);
- name_tree named_iv = XNEW (struct name_tree);
+ name_tree named_iv = XNEW (struct name_tree_d);
named_iv->t = iv;
named_iv->name = name;
/* Structure containing the mapping between the CLooG's induction
variable and the type of the old induction variable. */
-typedef struct ivtype_map_elt
+typedef struct ivtype_map_elt_d
{
tree type;
const char *cloog_iv;
static int
debug_ivtype_map_1 (void **slot, void *s ATTRIBUTE_UNUSED)
{
- struct ivtype_map_elt *entry = (struct ivtype_map_elt *) *slot;
+ struct ivtype_map_elt_d *entry = (struct ivtype_map_elt_d *) *slot;
debug_ivtype_elt (entry);
return 1;
}
{
ivtype_map_elt res;
- res = XNEW (struct ivtype_map_elt);
+ res = XNEW (struct ivtype_map_elt_d);
res->cloog_iv = cloog_iv;
res->type = type;
static hashval_t
ivtype_map_elt_info (const void *elt)
{
- return htab_hash_pointer (((const struct ivtype_map_elt *) elt)->cloog_iv);
+ return htab_hash_pointer (((const struct ivtype_map_elt_d *) elt)->cloog_iv);
}
/* Compares database elements E1 and E2. */
static int
eq_ivtype_map_elts (const void *e1, const void *e2)
{
- const struct ivtype_map_elt *elt1 = (const struct ivtype_map_elt *) e1;
- const struct ivtype_map_elt *elt2 = (const struct ivtype_map_elt *) e2;
+ const struct ivtype_map_elt_d *elt1 = (const struct ivtype_map_elt_d *) e1;
+ const struct ivtype_map_elt_d *elt2 = (const struct ivtype_map_elt_d *) e2;
return (elt1->cloog_iv == elt2->cloog_iv);
}
static tree
gcc_type_for_cloog_iv (const char *cloog_iv, graphite_bb_p gbb)
{
- struct ivtype_map_elt tmp;
+ struct ivtype_map_elt_d tmp;
PTR *slot;
tmp.cloog_iv = cloog_iv;
|| evolution_function_is_affine_multivariate_p (scev, n));
}
-/* Return false if the tree_code of the operand OP or any of its operands
- is component_ref. */
+/* Return true if REF or any of its subtrees contains a
+ component_ref. */
static bool
-exclude_component_ref (tree op)
+contains_component_ref_p (tree ref)
{
- int i;
- int len;
+ if (!ref)
+ return false;
- if (op)
+ while (handled_component_p (ref))
{
- if (TREE_CODE (op) == COMPONENT_REF)
- return false;
- else
- {
- len = TREE_OPERAND_LENGTH (op);
- for (i = 0; i < len; ++i)
- {
- if (!exclude_component_ref (TREE_OPERAND (op, i)))
- return false;
- }
- }
+ if (TREE_CODE (ref) == COMPONENT_REF)
+ return true;
+
+ ref = TREE_OPERAND (ref, 0);
}
- return true;
+ return false;
}
/* Return true if the operand OP is simple. */
if (DECL_P (op)
/* or a structure, */
|| AGGREGATE_TYPE_P (TREE_TYPE (op))
+ /* or a COMPONENT_REF, */
+ || contains_component_ref_p (op)
/* or a memory access that cannot be analyzed by the data
reference analysis. */
|| ((handled_component_p (op) || INDIRECT_REF_P (op))
&& !stmt_simple_memref_p (loop, stmt, op)))
return false;
- return exclude_component_ref (op);
+ return true;
}
/* Return true only when STMT is simple enough for being handled by
harmful_stmt_in_bb (basic_block scop_entry, basic_block bb)
{
gimple_stmt_iterator gsi;
+ gimple stmt;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
if (!stmt_simple_for_scop_p (scop_entry, gsi_stmt (gsi)))
return gsi_stmt (gsi);
+ stmt = last_stmt (bb);
+ if (stmt && gimple_code (stmt) == GIMPLE_COND)
+ {
+ tree lhs = gimple_cond_lhs (stmt);
+ tree rhs = gimple_cond_rhs (stmt);
+
+ if (TREE_CODE (TREE_TYPE (lhs)) == REAL_TYPE
+ || TREE_CODE (TREE_TYPE (rhs)) == REAL_TYPE)
+ return stmt;
+ }
+
return NULL;
}
/* Structure containing the mapping between the old names and the new
names used after block copy in the new loop context. */
-typedef struct rename_map_elt
+typedef struct rename_map_elt_d
{
tree old_name, new_name;
} *rename_map_elt;
static int
debug_rename_map_1 (void **slot, void *s ATTRIBUTE_UNUSED)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
debug_rename_elt (entry);
return 1;
}
{
rename_map_elt res;
- res = XNEW (struct rename_map_elt);
+ res = XNEW (struct rename_map_elt_d);
res->old_name = old_name;
res->new_name = new_name;
static hashval_t
rename_map_elt_info (const void *elt)
{
- return htab_hash_pointer (((const struct rename_map_elt *) elt)->old_name);
+ return htab_hash_pointer (((const struct rename_map_elt_d *) elt)->old_name);
}
/* Compares database elements E1 and E2. */
static int
eq_rename_map_elts (const void *e1, const void *e2)
{
- const struct rename_map_elt *elt1 = (const struct rename_map_elt *) e1;
- const struct rename_map_elt *elt2 = (const struct rename_map_elt *) e2;
+ const struct rename_map_elt_d *elt1 = (const struct rename_map_elt_d *) e1;
+ const struct rename_map_elt_d *elt2 = (const struct rename_map_elt_d *) e2;
return (elt1->old_name == elt2->old_name);
}
static tree
get_new_name_from_old_name (htab_t map, tree old_name)
{
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
PTR *slot;
tmp.old_name = old_name;
scev = analyze_scalar_evolution (loop, PHI_RESULT (phi));
scev = instantiate_parameters (loop, scev);
- if (!simple_iv (loop, phi, PHI_RESULT (phi), &iv, true))
+ if (!simple_iv (loop, loop, PHI_RESULT (phi), &iv, true))
res++;
}
tree nit;
gimple_seq stmts;
edge exit = single_dom_exit (loop);
+ bool known_niter = number_of_iterations_exit (loop, exit, &niter, false);
+
+ gcc_assert (known_niter);
- gcc_assert (number_of_iterations_exit (loop, exit, &niter, false));
nit = force_gimple_operand (unshare_expr (niter.niter), &stmts, true,
NULL_TREE);
if (stmts)
if (nb_reductions_in_loop (loop) > 0)
return NULL_TREE;
- return canonicalize_loop_ivs (loop, NULL, nit);
+ return canonicalize_loop_ivs (loop, NULL, &nit);
}
/* Record LOOP as occuring in SCOP. Returns true when the operation
if (!induction_var)
return false;
- oldiv = XNEW (struct name_tree);
+ oldiv = XNEW (struct name_tree_d);
oldiv->t = induction_var;
oldiv->name = get_name (SSA_NAME_VAR (oldiv->t));
oldiv->loop = loop;
gcc_assert (SCOP_ADD_PARAMS (scop));
- nvar = XNEW (struct name_tree);
+ nvar = XNEW (struct name_tree_d);
nvar->t = var;
nvar->name = NULL;
VEC_safe_push (name_tree, heap, SCOP_PARAMS (scop), nvar);
}
break;
}
- case SWITCH_EXPR:
+ case GIMPLE_SWITCH:
/* Switch statements are not supported right know. */
gcc_unreachable ();
break;
bool res = true;
int i, j;
graphite_bb_p gbb;
- gimple_stmt_iterator gsi;
basic_block bb_child, bb_iter;
VEC (basic_block, heap) *dom;
+ gimple stmt;
/* Make sure we are in the SCoP. */
if (!bb_in_sese_p (bb, SCOP_REGION (scop)))
dom = get_dominated_by (CDI_DOMINATORS, bb);
- for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
+ stmt = last_stmt (bb);
+ if (stmt)
{
- gimple stmt = gsi_stmt (gsi);
VEC (edge, gc) *edges;
edge e;
ssa_op_iter iter;
use_operand_p use_p;
- FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE)
+ FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
{
tree use = USE_FROM_PTR (use_p);
tree new_name = get_new_name_from_old_name (map, use);
tree new_name = force_gimple_operand_gsi (gsi, expr, true, NULL,
true, GSI_SAME_STMT);
- set_symbol_mem_tag (SSA_NAME_VAR (new_name),
- symbol_mem_tag (SSA_NAME_VAR (old_name)));
return fold_build1 (code, type, new_name);
}
for (i = 0; VEC_iterate (name_tree, SCOP_OLDIVS (scop), i, iv); i++)
{
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
if (!flow_bb_inside_loop_p (iv->loop, GBB_BB (gbb)))
continue;
static void
register_old_and_new_names (htab_t map, tree old_name, tree new_name)
{
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
PTR *slot;
tmp.old_name = old_name;
operands. */
copy = gimple_copy (stmt);
gsi_insert_after (&gsi_tgt, copy, GSI_NEW_STMT);
- mark_symbols_for_renaming (copy);
+ mark_sym_for_renaming (gimple_vop (cfun));
region = lookup_stmt_eh_region (stmt);
if (region >= 0)
/* Create new names for all the definitions created by COPY and
add replacement mappings for each new name. */
- FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_DEF)
+ FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
{
tree old_name = DEF_FROM_PTR (def_p);
tree new_name = create_new_def_for (old_name, copy, def_p);
static int
add_loop_exit_phis (void **slot, void *s)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
tree new_name = entry->new_name;
basic_block bb = (basic_block) s;
gimple phi = create_phi_node (new_name, bb);
static int
add_guard_exit_phis (void **slot, void *s)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
struct igp *i = (struct igp *) s;
basic_block bb = i->bb;
edge true_edge = i->true_edge;
static int
copy_renames (void **slot, void *s)
{
- struct rename_map_elt *entry = (struct rename_map_elt *) *slot;
+ struct rename_map_elt_d *entry = (struct rename_map_elt_d *) *slot;
htab_t res = (htab_t) s;
tree old_name = entry->old_name;
tree new_name = entry->new_name;
- struct rename_map_elt tmp;
+ struct rename_map_elt_d tmp;
PTR *x;
tmp.old_name = old_name;
next_e, map);
htab_delete (map);
loop_iv_stack_remove_constants (ivstack);
- update_ssa (TODO_update_ssa);
recompute_all_dominators ();
+ update_ssa (TODO_update_ssa);
graphite_verify ();
return translate_clast (scop, context_loop, stmt->next, next_e, ivstack);
}
VEC_free (basic_block, heap, bbs);
}
-typedef struct ifsese {
+typedef struct ifsese_d
+{
sese region;
sese true_region;
sese false_region;
{
edge e;
edge_iterator ei;
- sese sese_region = GGC_NEW (struct sese);
- sese true_region = GGC_NEW (struct sese);
- sese false_region = GGC_NEW (struct sese);
- ifsese if_region = GGC_NEW (struct ifsese);
+ sese sese_region = GGC_NEW (struct sese_d);
+ sese true_region = GGC_NEW (struct sese_d);
+ sese false_region = GGC_NEW (struct sese_d);
+ ifsese if_region = GGC_NEW (struct ifsese_d);
edge exit = create_empty_if_region_on_edge (entry, condition);
if_region->region = sese_region;
for (t = user_stmt->substitutions; t; t = t->next, index++)
{
PTR *slot;
- struct ivtype_map_elt tmp;
+ struct ivtype_map_elt_d tmp;
struct clast_expr *expr = (struct clast_expr *)
((struct clast_assignment *)t)->RHS;
bool transform_done = false;
/* TODO: - Calculate the stride size automatically. */
- int stride_size = 64;
+ int stride_size = 51;
for (i = 0; VEC_iterate (graphite_bb_p, bbs, i, gb); i++)
transform_done |= graphite_trans_bb_block (gb, stride_size, loops);
OSDN Git Service
