#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
-#include "ggc.h"
-#include "tree.h"
-#include "rtl.h"
-#include "basic-block.h"
-#include "diagnostic.h"
+#include "diagnostic-core.h"
#include "tree-flow.h"
-#include "toplev.h"
#include "tree-dump.h"
-#include "timevar.h"
#include "cfgloop.h"
#include "tree-chrec.h"
#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"
-#include "langhooks.h"
#include "sese.h"
#ifdef HAVE_cloog
#include "ppl_c.h"
#include "graphite-cloog-util.h"
#include "graphite-ppl.h"
-#include "graphite.h"
#include "graphite-poly.h"
-#include "graphite-scop-detection.h"
#include "graphite-clast-to-gimple.h"
#include "graphite-dependences.h"
#include "graphite-cloog-compat.h"
#ifdef ENABLE_CHECKING
verify_loop_structure ();
verify_dominators (CDI_DOMINATORS);
- verify_dominators (CDI_POST_DOMINATORS);
verify_loop_closed_ssa (true);
#endif
}
if (slot)
{
- if (*slot)
- free (*slot);
+ free (*slot);
*slot = new_clast_name_index (name, index);
}
if (mpz_sgn (y) < 0)
mpz_neg (y, y);
- while (mpz_cmp (y, x) > 0)
+ while (mpz_cmp (y, x) >= 0)
{
mpz_mul (x, x, two);
precision++;
gcc_assert (mpz_cmp (low, up) <= 0);
- if (mpz_sgn (low) < 0)
- unsigned_p = false;
-
prec_up = precision_for_value (up);
prec_int = precision_for_interval (low, up);
precision = MAX (prec_up, prec_int);
return integer_type_node;
}
+ if (mpz_sgn (low) <= 0)
+ unsigned_p = false;
+
+ else if (precision < BITS_PER_WORD)
+ {
+ unsigned_p = false;
+ precision++;
+ }
+
mode = smallest_mode_for_size (precision, MODE_INT);
precision = GET_MODE_PRECISION (mode);
type = build_nonstandard_integer_type (precision, unsigned_p);
ppl_max_for_le_pointset (ps, le, up);
ppl_min_for_le_pointset (ps, le, low);
+ ppl_delete_Linear_Expression (le);
+ ppl_delete_Pointset_Powerset_C_Polyhedron (ps);
}
/* Compute the type for the induction variable at LEVEL for the
newivs_index, params_index);
tree ub = clast_to_gcc_expression (type, stmt->UB, region, newivs,
newivs_index, params_index);
- tree one = POINTER_TYPE_P (type) ? size_one_node
- : fold_convert (type, integer_one_node);
- /* Adding +1 and using LT_EXPR helps with loop latches that have a
- loop iteration count of "PARAMETER - 1". For PARAMETER == 0 this becomes
- 2^{32|64}, and the condition lb <= ub is true, even if we do not want this.
- However lb < ub + 1 is false, as expected. */
- tree ub_one = fold_build2 (POINTER_TYPE_P (type) ? POINTER_PLUS_EXPR
- : PLUS_EXPR, type, ub, one);
-
- /* When ub + 1 wraps around, use lb <= ub. */
- if (integer_zerop (ub_one))
+ /* When ub is simply a constant or a parameter, use lb <= ub. */
+ if (TREE_CODE (ub) == INTEGER_CST || TREE_CODE (ub) == SSA_NAME)
cond_expr = fold_build2 (LE_EXPR, boolean_type_node, lb, ub);
else
- cond_expr = fold_build2 (LT_EXPR, boolean_type_node, lb, ub_one);
+ {
+ tree one = (POINTER_TYPE_P (type)
+ ? size_one_node
+ : fold_convert (type, integer_one_node));
+ /* Adding +1 and using LT_EXPR helps with loop latches that have a
+ loop iteration count of "PARAMETER - 1". For PARAMETER == 0 this becomes
+ 2^k-1 due to integer overflow, and the condition lb <= ub is true,
+ even if we do not want this. However lb < ub + 1 is false, as
+ expected. */
+ tree ub_one = fold_build2 (POINTER_TYPE_P (type) ? POINTER_PLUS_EXPR
+ : PLUS_EXPR, type, ub, one);
+
+ cond_expr = fold_build2 (LT_EXPR, boolean_type_node, lb, ub_one);
+ }
exit_edge = create_empty_if_region_on_edge (entry_edge, cond_expr);
scattering);
}
+/* Initialize a CLooG input file. */
+
+static FILE *
+init_cloog_input_file (int scop_number)
+{
+ FILE *graphite_out_file;
+ int len = strlen (dump_base_name);
+ char *dumpname = XNEWVEC (char, len + 25);
+ char *s_scop_number = XNEWVEC (char, 15);
+
+ memcpy (dumpname, dump_base_name, len + 1);
+ strip_off_ending (dumpname, len);
+ sprintf (s_scop_number, ".%d", scop_number);
+ strcat (dumpname, s_scop_number);
+ strcat (dumpname, ".cloog");
+ graphite_out_file = fopen (dumpname, "w+b");
+
+ if (graphite_out_file == 0)
+ fatal_error ("can%'t open %s for writing: %m", dumpname);
+
+ free (dumpname);
+
+ return graphite_out_file;
+}
+
/* Build cloog program for SCoP. */
static void
build_cloog_prog (scop_p scop, CloogProgram *prog,
- CloogOptions *options, CloogState *state ATTRIBUTE_UNUSED)
+ CloogOptions *options)
{
int i;
int max_nb_loops = scop_max_loop_depth (scop);
cloog_program_set_context
(prog, new_Cloog_Domain_from_ppl_Pointset_Powerset (SCOP_CONTEXT (scop),
- scop_nb_params (scop), state));
+ scop_nb_params (scop), cloog_state));
nbs = unify_scattering_dimensions (scop);
scaldims = (int *) xmalloc (nbs * (sizeof (int)));
cloog_program_set_nb_scattdims (prog, nbs);
continue;
/* Build the new statement and its block. */
- stmt = cloog_statement_alloc (state, pbb_index (pbb));
+ stmt = cloog_statement_alloc (cloog_state, pbb_index (pbb));
dom = new_Cloog_Domain_from_ppl_Pointset_Powerset (PBB_DOMAIN (pbb),
scop_nb_params (scop),
- state);
+ cloog_state);
block = cloog_block_alloc (stmt, 0, NULL, pbb_dim_iter_domain (pbb));
cloog_statement_set_usr (stmt, pbb);
/* Build loop list. */
{
- CloogLoop *new_loop_list = cloog_loop_malloc (state);
+ CloogLoop *new_loop_list = cloog_loop_malloc (cloog_state);
cloog_loop_set_next (new_loop_list, loop_list);
cloog_loop_set_domain (new_loop_list, dom);
cloog_loop_set_block (new_loop_list, block);
scat = PBB_TRANSFORMED_SCATTERING (pbb);
dom = new_Cloog_Scattering_from_ppl_Polyhedron
(scat, scop_nb_params (scop), pbb_nb_scattering_transform (pbb),
- state);
+ cloog_state);
cloog_set_next_scattering (new_scattering, scattering);
cloog_set_scattering (new_scattering, dom);
/* Extract scalar dimensions to simplify the code generation problem. */
cloog_program_extract_scalars (prog, scattering, options);
+ /* Dump a .cloog input file, if requested. This feature is only
+ enabled in the Graphite branch. */
+ if (0)
+ {
+ static size_t file_scop_number = 0;
+ FILE *cloog_file = init_cloog_input_file (file_scop_number);
+
+ cloog_program_dump_cloog (cloog_file, prog, scattering);
+ ++file_scop_number;
+ }
+
/* Apply scattering. */
cloog_program_scatter (prog, scattering, options);
free_scattering (scattering);
/* Return the options that will be used in GLOOG. */
static CloogOptions *
-set_cloog_options (CloogState *state ATTRIBUTE_UNUSED)
+set_cloog_options (void)
{
- CloogOptions *options = cloog_options_malloc (state);
+ CloogOptions *options = cloog_options_malloc (cloog_state);
/* Change cloog output language to C. If we do use FORTRAN instead, cloog
will stop e.g. with "ERROR: unbounded loops not allowed in FORTRAN.", if
void
print_clast_stmt (FILE *file, struct clast_stmt *stmt)
{
- CloogState *state = cloog_state_malloc ();
- CloogOptions *options = set_cloog_options (state);
+ CloogOptions *options = set_cloog_options ();
clast_pprint (file, stmt, 0, options);
cloog_options_free (options);
- cloog_state_free (state);
}
/* Prints STMT to STDERR. */
without a program. */
cloog_prog_clast
-scop_to_clast (scop_p scop, CloogState *state)
+scop_to_clast (scop_p scop)
{
- CloogOptions *options = set_cloog_options (state);
+ CloogOptions *options = set_cloog_options ();
cloog_prog_clast pc;
/* Connect new cloog prog generation to graphite. */
pc.prog = cloog_program_malloc ();
- build_cloog_prog (scop, pc.prog, options, state);
+ build_cloog_prog (scop, pc.prog, options);
pc.prog = cloog_program_generate (pc.prog, options);
pc.stmt = cloog_clast_create (pc.prog, options);
void
print_generated_program (FILE *file, scop_p scop)
{
- CloogState *state = cloog_state_malloc ();
- CloogOptions *options = set_cloog_options (state);
+ CloogOptions *options = set_cloog_options ();
- cloog_prog_clast pc = scop_to_clast (scop, state);
+ cloog_prog_clast pc = scop_to_clast (scop);
fprintf (file, " (prog: \n");
cloog_program_print (file, pc.prog);
ifsese if_region = NULL;
htab_t newivs_index, params_index;
cloog_prog_clast pc;
- CloogState *state;
- state = cloog_state_malloc ();
timevar_push (TV_GRAPHITE_CODE_GEN);
gloog_error = false;
- pc = scop_to_clast (scop, state);
+ pc = scop_to_clast (scop);
if (dump_file && (dump_flags & TDF_DETAILS))
{
&newivs, newivs_index,
bb_pbb_mapping, 1, params_index);
graphite_verify ();
- scev_reset_htab ();
+ scev_reset ();
recompute_all_dominators ();
graphite_verify ();
num_no_dependency);
}
- cloog_state_free (state);
-
return !gloog_error;
}
#endif
OSDN Git Service
