gcc/gcc/graphite-ppl.c
Jan Hubicka 24e47c76ba tree-vrp.c (debug_value_range, [...]): Annotate with DEBUG_FUNCTION.
* tree-vrp.c (debug_value_range, debug_all_value_ranges,
	debug_asserts_for, debug_all_asserts): Annotate with DEBUG_FUNCTION.
	* tree-into-ssa.c (debug_decl_set, debug_defs_stack, debug_currdefs,
	debug_tree_ssa, debug_tree_ssa_stats, debug_def_blocks,
	debug_names_replaced_by, debug_update_ssa): Likewise.	
	* sbitmap.c (debug_sbitmap): Likewise.
	* genrecog.c (debug_decision, debug_decision_list): Likewise.
	* tree-pretty-print.c (debug_generic_expr, debug_generic_stmt,
	debug_tree_chain): Likewise.
	* tree-loop-distribution.c (debug_rdg_partitions): Likewise.
	* cgraph.c (debug_cgraph_node, debug_cgraph): Likewise.
	* optabs.c  (debug_optab_libfuncs): Likewise.
	(verify_loop_closed_ssa): Likewise.
	* value-prof.c (verify_histograms): Likewise.
	* reload.c (debug_reload_to_stream, debug_reload): Likewise.
	* bitmap.c (debug_bitmap_file, debug_bitmap, bitmap_print): Likewise.
	* cfghooks.c (verify_flow_info): Likewise.
	* fold-const.c (debug_fold_checksum): Likewise.
	* omp-low.c (debug_omp_region, debug_all_omp_regions): Likewise.
	* cfg.c (debug_regset, debug_flow_info, debug_bb, debug_bb_n):
	Likewise.
	* omega.c (debug_omega_problem): Likewise.
	* cgraphunit.c (verify_cgraph_node, verify_cgraph): Likewise.
	* tree-ssa-ccp.c (debug_lattice_value): Likewise.
	* dominance.c (verify_dominators, debug_dominance_info,
	debug_dominance_tree): Likewise.
	* df-core.c (df_insn_uid_debug, df_insn_debug, df_insn_debug_regno,
	* df_regno_debug, df_ref_debug,
	debug_df_insn, debug_df_reg, debug_df_regno, debug_df_ref,
	debug_df_defno, debug_df_useno, debug_df_chain): Likewise.
	* tree-ssa-dom.c (debug_dominator_optimization_stats): Likewise.
	* sel-sched.c (debug_state): Likewise.
	* tree-ssa-alias.c (debug_alias_info, debug_points_to_info_for): Likewise.
	* cfganal.c (print_edge_list, verify_edge_list): Likewise.
	* dwarf2out.c (debug_dwarf_die, debug_dwarf): Likewise.
	* tree-eh.c (verify_eh_edges, verify_eh_dispatch_edge): Likewise.
	* gimple-pretty-print.c (debug_gimple_stmt, debug_gimple_seq): Likewise.
	* c-pretty-print.c (debug_c_tree): Likewise.
	* sel-sched-dump.c (debug_insn_rtx, debug_vinsn, debug_expr, debug_insn
	debug_av_set, debug_lv_set, debug_ilist, debug_blist, debug_insn_vector,
	debug_hard_reg_set, debug_mem_addr_value): Likewise.
	* ebitmap.c (debug_ebitmap): Likewise.
	* function.c (debug_find_var_in_block_tree): Likewise.
	* print-rtl.c (debug_rtx): Likewise.
	(debug_rtx_count): Likewise.
	(debug_rtx_list, debug_rtx_range, debug_rtx_find): Likewise.
	* stor-layout.c (debug_rli): Likewise.
	* ipa.c (debug_cgraph_node_set, debug_varpool_node_set): Likewise.
	* tree-data-ref.c (debug_data_references, debug_data_dependence_relations,
	debug_data_reference, debug_data_dependence_relation, debug_rdg_vertex,
	debug_rdg_component, debug_rdg): Likewise.
	* tree-affine.c (debug_aff): Likewise.
	* tree-dfa.c (debug_referenced_vars, debug_variable, debug_dfa_stats): Likewise.
	* except.c (debug_eh_tree, verify_eh_tree): Likewise.
	* emit-rtl.c (verify_rtl_sharing): Likewise.
	* tree-ssa-pre.c (debug_pre_expr, debug_bitmap_set,
	debug_value_expressions): Likewise.
	* tree-ssa-live.c (debug_scope_block, debug_scope_blocks): Likewise.
	* sese.c (debug_rename_map, debug_ivtype_map): Likewise.
	* print-tree.c (debug_tree, debug_vec_tree): Likewise.
	* cfglayout.c (verify_insn_chain): Likewise.
	* graphite-clast-to-gimple.c (debug_clast_name_indexes,
	debug_clast_stmt, debug_generated_program): Likewise.
	* ggc-page.c (debug_print_page_list): Likewise.
	* tree-ssa-ter.c (debug_ter): Likewise.
	* graphite-dependences.c (debug_pddr): Likewise.
	* sched-deps.c (debug_ds): Likewise.
	* tree-ssa.c (verify_ssa): Likewise.
	* graphite-poly.c (debug_scattering_function, debug_iteration_domain,
	debug_scattering_functions, debug_iteration_domains, debug_pdr,
	debug_pdrs, debug_pbb_domain, debug_pbb, debug_scop_context, debug_scop,
	debug_cloog, debug_scop_params, debug_lst): Likewise.
	* tree-inline.c (debug_find_tree): Likewise.
	* graphite-ppl.c (debug_ppl_linear_expr, debug_ppl_polyhedron_matrix,
	debug_ppl_powerset_matrix): Likewise.
	* var-tracking.c (debug_dv): Likewise.
	* system.h (DEBUG_FUNCTION, DEBUG_VARIABLE): Define.
	* cfgloop.c (verify_loop_structure): Likewise.
	* plugin.c (dump_active_plugins, debug_active_plugins): Likewise.
	* c-common.c (verify_sequence_points): Likewise.
	* sched-rgn.c (debug_regions, debug_region, debug_candidate,
	debug_candidates, debug_rgn_dependencies): Likewise.
	* tree-ssa-structalias.c (debug_constraint, debug_constraints,
	* debug_constraint_graph, debug_solution_for_var,
	debug_sa_points_to_info): Likewise.
	* sched-vis.c (debug_insn_slim, debug_bb_slim, debug_bb_n_slim):
	Likewie.
	* tree-cfg.c (debug_cfg_stats, verify_stmts, debug_function,
	debug_loops, debug_loop, debug_loop_num): Likewise.
	* passes.c (debug_pass): Likewise.
	(dump_properties): Likewise; add cfglayout property.
	(debug_properties): Likewise.
	* tree-ssa-reassoc.c (debug_ops_vector): Likewise.
	* varpool.c (debug_varpool): Likewise.
	* regcprop.c (debug_value_data): Likewise.
	* tree-ssa-operands.c (verify_imm_links, debug_immediate_uses,
	debug_immediate_uses_for): Likewise.

From-SVN: r160036
2010-05-29 20:31:45 +00:00

750 lines
20 KiB
C

/* Gimple Represented as Polyhedra.
Copyright (C) 2009, 2010 Free Software Foundation, Inc.
Contributed by Sebastian Pop <sebastian.pop@amd.com>
and Tobias Grosser <grosser@fim.uni-passau.de>
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 3, 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 COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "ggc.h"
#ifdef HAVE_cloog
#include "ppl_c.h"
#include "cloog/cloog.h"
#include "graphite-ppl.h"
/* Translates row ROW of the CloogMatrix MATRIX to a PPL Constraint. */
static ppl_Constraint_t
cloog_matrix_to_ppl_constraint (CloogMatrix *matrix, int row)
{
int j;
ppl_Constraint_t cstr;
ppl_Coefficient_t coef;
ppl_Linear_Expression_t expr;
ppl_dimension_type dim = matrix->NbColumns - 2;
ppl_new_Coefficient (&coef);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
for (j = 1; j < matrix->NbColumns - 1; j++)
{
ppl_assign_Coefficient_from_mpz_t (coef, matrix->p[row][j]);
ppl_Linear_Expression_add_to_coefficient (expr, j - 1, coef);
}
ppl_assign_Coefficient_from_mpz_t (coef,
matrix->p[row][matrix->NbColumns - 1]);
ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
ppl_delete_Coefficient (coef);
if (mpz_sgn (matrix->p[row][0]))
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_EQUAL);
else
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
return cstr;
}
/* Creates a PPL constraint system from MATRIX. */
static void
new_Constraint_System_from_Cloog_Matrix (ppl_Constraint_System_t *pcs,
CloogMatrix *matrix)
{
int i;
ppl_new_Constraint_System (pcs);
for (i = 0; i < matrix->NbRows; i++)
{
ppl_Constraint_t c = cloog_matrix_to_ppl_constraint (matrix, i);
ppl_Constraint_System_insert_Constraint (*pcs, c);
ppl_delete_Constraint (c);
}
}
/* Creates a PPL Polyhedron from MATRIX. */
void
new_C_Polyhedron_from_Cloog_Matrix (ppl_Polyhedron_t *ph,
CloogMatrix *matrix)
{
ppl_Constraint_System_t cs;
new_Constraint_System_from_Cloog_Matrix (&cs, matrix);
ppl_new_C_Polyhedron_recycle_Constraint_System (ph, cs);
}
/* Counts the number of constraints in PCS. */
static int
ppl_Constrain_System_number_of_constraints (ppl_const_Constraint_System_t pcs)
{
ppl_Constraint_System_const_iterator_t cit, end;
int num = 0;
ppl_new_Constraint_System_const_iterator (&cit);
ppl_new_Constraint_System_const_iterator (&end);
for (ppl_Constraint_System_begin (pcs, cit),
ppl_Constraint_System_end (pcs, end);
!ppl_Constraint_System_const_iterator_equal_test (cit, end);
ppl_Constraint_System_const_iterator_increment (cit))
num++;
ppl_delete_Constraint_System_const_iterator (cit);
ppl_delete_Constraint_System_const_iterator (end);
return num;
}
static void
oppose_constraint (CloogMatrix *m, int row)
{
int k;
/* Do not oppose the first column: it is the eq/ineq one. */
for (k = 1; k < m->NbColumns; k++)
mpz_neg (m->p[row][k], m->p[row][k]);
}
/* Inserts constraint CSTR at row ROW of matrix M. */
void
insert_constraint_into_matrix (CloogMatrix *m, int row,
ppl_const_Constraint_t cstr)
{
ppl_Coefficient_t c;
ppl_dimension_type i, dim, nb_cols = m->NbColumns;
ppl_Constraint_space_dimension (cstr, &dim);
ppl_new_Coefficient (&c);
for (i = 0; i < dim; i++)
{
ppl_Constraint_coefficient (cstr, i, c);
ppl_Coefficient_to_mpz_t (c, m->p[row][i + 1]);
}
for (i = dim; i < nb_cols - 1; i++)
mpz_set_si (m->p[row][i + 1], 0);
ppl_Constraint_inhomogeneous_term (cstr, c);
ppl_Coefficient_to_mpz_t (c, m->p[row][nb_cols - 1]);
mpz_set_si (m->p[row][0], 1);
switch (ppl_Constraint_type (cstr))
{
case PPL_CONSTRAINT_TYPE_LESS_THAN:
oppose_constraint (m, row);
case PPL_CONSTRAINT_TYPE_GREATER_THAN:
mpz_sub_ui (m->p[row][nb_cols - 1],
m->p[row][nb_cols - 1], 1);
break;
case PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL:
oppose_constraint (m, row);
case PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL:
break;
case PPL_CONSTRAINT_TYPE_EQUAL:
mpz_set_si (m->p[row][0], 0);
break;
default:
/* Not yet implemented. */
gcc_unreachable();
}
ppl_delete_Coefficient (c);
}
/* Creates a CloogMatrix from constraint system PCS. */
static CloogMatrix *
new_Cloog_Matrix_from_ppl_Constraint_System (ppl_const_Constraint_System_t pcs)
{
CloogMatrix *matrix;
ppl_Constraint_System_const_iterator_t cit, end;
ppl_dimension_type dim;
int rows;
int row = 0;
rows = ppl_Constrain_System_number_of_constraints (pcs);
ppl_Constraint_System_space_dimension (pcs, &dim);
matrix = cloog_matrix_alloc (rows, dim + 2);
ppl_new_Constraint_System_const_iterator (&cit);
ppl_new_Constraint_System_const_iterator (&end);
for (ppl_Constraint_System_begin (pcs, cit),
ppl_Constraint_System_end (pcs, end);
!ppl_Constraint_System_const_iterator_equal_test (cit, end);
ppl_Constraint_System_const_iterator_increment (cit))
{
ppl_const_Constraint_t c;
ppl_Constraint_System_const_iterator_dereference (cit, &c);
insert_constraint_into_matrix (matrix, row, c);
row++;
}
ppl_delete_Constraint_System_const_iterator (cit);
ppl_delete_Constraint_System_const_iterator (end);
return matrix;
}
/* Creates a CloogMatrix from polyhedron PH. */
CloogMatrix *
new_Cloog_Matrix_from_ppl_Polyhedron (ppl_const_Polyhedron_t ph)
{
ppl_const_Constraint_System_t pcs;
CloogMatrix *res;
ppl_Polyhedron_get_constraints (ph, &pcs);
res = new_Cloog_Matrix_from_ppl_Constraint_System (pcs);
return res;
}
/* Creates a CloogDomain from polyhedron PH. */
CloogDomain *
new_Cloog_Domain_from_ppl_Polyhedron (ppl_const_Polyhedron_t ph)
{
CloogMatrix *mat = new_Cloog_Matrix_from_ppl_Polyhedron (ph);
CloogDomain *res = cloog_domain_matrix2domain (mat);
cloog_matrix_free (mat);
return res;
}
/* Creates a CloogDomain from a pointset powerset PS. */
CloogDomain *
new_Cloog_Domain_from_ppl_Pointset_Powerset (
ppl_Pointset_Powerset_C_Polyhedron_t ps)
{
CloogDomain *res = NULL;
ppl_Pointset_Powerset_C_Polyhedron_iterator_t it, end;
ppl_new_Pointset_Powerset_C_Polyhedron_iterator (&it);
ppl_new_Pointset_Powerset_C_Polyhedron_iterator (&end);
for (ppl_Pointset_Powerset_C_Polyhedron_iterator_begin (ps, it),
ppl_Pointset_Powerset_C_Polyhedron_iterator_end (ps, end);
!ppl_Pointset_Powerset_C_Polyhedron_iterator_equal_test (it, end);
ppl_Pointset_Powerset_C_Polyhedron_iterator_increment (it))
{
ppl_const_Polyhedron_t ph;
CloogDomain *tmp;
ppl_Pointset_Powerset_C_Polyhedron_iterator_dereference (it, &ph);
tmp = new_Cloog_Domain_from_ppl_Polyhedron (ph);
if (res == NULL)
res = tmp;
else
res = cloog_domain_union (res, tmp);
}
ppl_delete_Pointset_Powerset_C_Polyhedron_iterator (it);
ppl_delete_Pointset_Powerset_C_Polyhedron_iterator (end);
gcc_assert (res != NULL);
return res;
}
/* Set the inhomogeneous term of E to X. */
void
ppl_set_inhomogeneous_gmp (ppl_Linear_Expression_t e, mpz_t x)
{
mpz_t v0, v1;
ppl_Coefficient_t c;
mpz_init (v0);
mpz_init (v1);
ppl_new_Coefficient (&c);
ppl_Linear_Expression_inhomogeneous_term (e, c);
ppl_Coefficient_to_mpz_t (c, v1);
mpz_neg (v1, v1);
mpz_set (v0, x);
mpz_add (v0, v0, v1);
ppl_assign_Coefficient_from_mpz_t (c, v0);
ppl_Linear_Expression_add_to_inhomogeneous (e, c);
mpz_clear (v0);
mpz_clear (v1);
ppl_delete_Coefficient (c);
}
/* Set E[I] to X. */
void
ppl_set_coef_gmp (ppl_Linear_Expression_t e, ppl_dimension_type i, mpz_t x)
{
mpz_t v0, v1;
ppl_Coefficient_t c;
mpz_init (v0);
mpz_init (v1);
ppl_new_Coefficient (&c);
ppl_Linear_Expression_coefficient (e, i, c);
ppl_Coefficient_to_mpz_t (c, v1);
mpz_neg (v1, v1);
mpz_set (v0, x);
mpz_add (v0, v0, v1);
ppl_assign_Coefficient_from_mpz_t (c, v0);
ppl_Linear_Expression_add_to_coefficient (e, i, c);
mpz_clear (v0);
mpz_clear (v1);
ppl_delete_Coefficient (c);
}
/* Insert after X NB_NEW_DIMS empty dimensions into PH.
With x = 3 and nb_new_dims = 4
| d0 d1 d2 d3 d4
is transformed to
| d0 d1 d2 x0 x1 x2 x3 d3 d4
| map = {0, 1, 2, 7, 8, 3, 4, 5, 6}
*/
void
ppl_insert_dimensions_pointset (ppl_Pointset_Powerset_C_Polyhedron_t ph, int x,
int nb_new_dims)
{
ppl_dimension_type i, dim;
ppl_dimension_type *map;
ppl_dimension_type x_ppl, nb_new_dims_ppl;
x_ppl = (ppl_dimension_type) x;
nb_new_dims_ppl = (ppl_dimension_type) nb_new_dims;
ppl_Pointset_Powerset_C_Polyhedron_space_dimension (ph, &dim);
ppl_Pointset_Powerset_C_Polyhedron_add_space_dimensions_and_embed (ph, nb_new_dims);
map = (ppl_dimension_type *) XNEWVEC (ppl_dimension_type, dim + nb_new_dims);
for (i = 0; i < x_ppl; i++)
map[i] = i;
for (i = x_ppl; i < x_ppl + nb_new_dims_ppl; i++)
map[dim + i - x_ppl] = i;
for (i = x_ppl + nb_new_dims_ppl; i < dim + nb_new_dims_ppl; i++)
map[i - nb_new_dims_ppl] = i;
ppl_Pointset_Powerset_C_Polyhedron_map_space_dimensions (ph, map, dim + nb_new_dims);
free (map);
}
/* Insert after X NB_NEW_DIMS empty dimensions into PH.
With x = 3 and nb_new_dims = 4
| d0 d1 d2 d3 d4
is transformed to
| d0 d1 d2 x0 x1 x2 x3 d3 d4
| map = {0, 1, 2, 7, 8, 3, 4, 5, 6}
*/
void
ppl_insert_dimensions (ppl_Polyhedron_t ph, int x,
int nb_new_dims)
{
ppl_dimension_type i, dim;
ppl_dimension_type *map;
ppl_dimension_type x_ppl, nb_new_dims_ppl;
x_ppl = (ppl_dimension_type) x;
nb_new_dims_ppl = (ppl_dimension_type) nb_new_dims;
ppl_Polyhedron_space_dimension (ph, &dim);
ppl_Polyhedron_add_space_dimensions_and_embed (ph, nb_new_dims);
map = (ppl_dimension_type *) XNEWVEC (ppl_dimension_type, dim + nb_new_dims);
for (i = 0; i < x_ppl; i++)
map[i] = i;
for (i = x_ppl; i < x_ppl + nb_new_dims_ppl; i++)
map[dim + i - x_ppl] = i;
for (i = x_ppl + nb_new_dims_ppl; i < dim + nb_new_dims_ppl; i++)
map[i - nb_new_dims_ppl] = i;
ppl_Polyhedron_map_space_dimensions (ph, map, dim + nb_new_dims);
free (map);
}
/* Based on the original polyhedron PH, returns a new polyhedron with
an extra dimension placed at position LOOP + 1 that slices the
dimension LOOP into strips of size STRIDE. */
ppl_Polyhedron_t
ppl_strip_loop (ppl_Polyhedron_t ph, ppl_dimension_type loop, int stride)
{
ppl_const_Constraint_System_t pcs;
ppl_Constraint_System_const_iterator_t cit, end;
ppl_const_Constraint_t cstr;
ppl_Linear_Expression_t expr;
int v;
ppl_dimension_type dim;
ppl_Polyhedron_t res;
ppl_Coefficient_t c;
mpz_t val;
mpz_init (val);
ppl_new_Coefficient (&c);
ppl_Polyhedron_space_dimension (ph, &dim);
ppl_Polyhedron_get_constraints (ph, &pcs);
/* Start from a copy of the constraints. */
ppl_new_C_Polyhedron_from_space_dimension (&res, dim + 1, 0);
ppl_Polyhedron_add_constraints (res, pcs);
/* Add an empty dimension for the strip loop. */
ppl_insert_dimensions (res, loop, 1);
/* Identify the constraints that define the lower and upper bounds
of the strip-mined loop, and add them to the strip loop. */
{
ppl_Polyhedron_t tmp;
ppl_new_C_Polyhedron_from_space_dimension (&tmp, dim + 1, 0);
ppl_new_Constraint_System_const_iterator (&cit);
ppl_new_Constraint_System_const_iterator (&end);
for (ppl_Constraint_System_begin (pcs, cit),
ppl_Constraint_System_end (pcs, end);
!ppl_Constraint_System_const_iterator_equal_test (cit, end);
ppl_Constraint_System_const_iterator_increment (cit))
{
ppl_Constraint_System_const_iterator_dereference (cit, &cstr);
ppl_new_Linear_Expression_from_Constraint (&expr, cstr);
ppl_Linear_Expression_coefficient (expr, loop, c);
ppl_delete_Linear_Expression (expr);
ppl_Coefficient_to_mpz_t (c, val);
v = mpz_get_si (val);
if (0 < v || v < 0)
ppl_Polyhedron_add_constraint (tmp, cstr);
}
ppl_delete_Constraint_System_const_iterator (cit);
ppl_delete_Constraint_System_const_iterator (end);
ppl_insert_dimensions (tmp, loop + 1, 1);
ppl_Polyhedron_get_constraints (tmp, &pcs);
ppl_Polyhedron_add_constraints (res, pcs);
ppl_delete_Polyhedron (tmp);
}
/* Lower bound of a tile starts at "stride * outer_iv". */
{
ppl_Constraint_t new_cstr;
ppl_new_Linear_Expression_with_dimension (&expr, dim + 1);
ppl_set_coef (expr, loop + 1, 1);
ppl_set_coef (expr, loop, -1 * stride);
ppl_new_Constraint (&new_cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
ppl_Polyhedron_add_constraint (res, new_cstr);
ppl_delete_Constraint (new_cstr);
}
/* Upper bound of a tile stops at "stride * outer_iv + stride - 1",
or at the old upper bound that is not modified. */
{
ppl_Constraint_t new_cstr;
ppl_new_Linear_Expression_with_dimension (&expr, dim + 1);
ppl_set_coef (expr, loop + 1, -1);
ppl_set_coef (expr, loop, stride);
ppl_set_inhomogeneous (expr, stride - 1);
ppl_new_Constraint (&new_cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_delete_Linear_Expression (expr);
ppl_Polyhedron_add_constraint (res, new_cstr);
ppl_delete_Constraint (new_cstr);
}
mpz_clear (val);
ppl_delete_Coefficient (c);
return res;
}
/* Lexicographically compares two linear expressions A and B and
returns negative when A < B, 0 when A == B and positive when A > B. */
int
ppl_lexico_compare_linear_expressions (ppl_Linear_Expression_t a,
ppl_Linear_Expression_t b)
{
ppl_dimension_type min_length, length1, length2;
ppl_dimension_type i;
ppl_Coefficient_t c;
int res;
mpz_t va, vb;
ppl_Linear_Expression_space_dimension (a, &length1);
ppl_Linear_Expression_space_dimension (b, &length2);
ppl_new_Coefficient (&c);
mpz_init (va);
mpz_init (vb);
if (length1 < length2)
min_length = length1;
else
min_length = length2;
for (i = 0; i < min_length; i++)
{
ppl_Linear_Expression_coefficient (a, i, c);
ppl_Coefficient_to_mpz_t (c, va);
ppl_Linear_Expression_coefficient (b, i, c);
ppl_Coefficient_to_mpz_t (c, vb);
res = mpz_cmp (va, vb);
if (res == 0)
continue;
mpz_clear (va);
mpz_clear (vb);
ppl_delete_Coefficient (c);
return res;
}
mpz_clear (va);
mpz_clear (vb);
ppl_delete_Coefficient (c);
return length1 - length2;
}
/* Print to FILE the polyhedron PH under its PolyLib matrix form. */
void
ppl_print_polyhedron_matrix (FILE *file, ppl_const_Polyhedron_t ph)
{
CloogMatrix *mat = new_Cloog_Matrix_from_ppl_Polyhedron (ph);
cloog_matrix_print (file, mat);
cloog_matrix_free (mat);
}
/* Print to FILE the linear expression LE. */
void
ppl_print_linear_expr (FILE *file, ppl_Linear_Expression_t le)
{
ppl_Constraint_t c;
ppl_Polyhedron_t pol;
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (le, &dim);
ppl_new_C_Polyhedron_from_space_dimension (&pol, dim, 0);
ppl_new_Constraint (&c, le, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (pol, c);
ppl_print_polyhedron_matrix (file, pol);
}
/* Print to STDERR the linear expression LE. */
DEBUG_FUNCTION void
debug_ppl_linear_expr (ppl_Linear_Expression_t le)
{
ppl_print_linear_expr (stderr, le);
}
/* Print to FILE the powerset PS in its PolyLib matrix form. */
void
ppl_print_powerset_matrix (FILE *file,
ppl_Pointset_Powerset_C_Polyhedron_t ps)
{
size_t nb_disjuncts;
ppl_Pointset_Powerset_C_Polyhedron_iterator_t it, end;
ppl_new_Pointset_Powerset_C_Polyhedron_iterator (&it);
ppl_new_Pointset_Powerset_C_Polyhedron_iterator (&end);
ppl_Pointset_Powerset_C_Polyhedron_size (ps, &nb_disjuncts);
fprintf (file, "%d\n", (int) nb_disjuncts);
for (ppl_Pointset_Powerset_C_Polyhedron_iterator_begin (ps, it),
ppl_Pointset_Powerset_C_Polyhedron_iterator_end (ps, end);
!ppl_Pointset_Powerset_C_Polyhedron_iterator_equal_test (it, end);
ppl_Pointset_Powerset_C_Polyhedron_iterator_increment (it))
{
ppl_const_Polyhedron_t ph;
ppl_Pointset_Powerset_C_Polyhedron_iterator_dereference (it, &ph);
ppl_print_polyhedron_matrix (file, ph);
}
ppl_delete_Pointset_Powerset_C_Polyhedron_iterator (it);
ppl_delete_Pointset_Powerset_C_Polyhedron_iterator (end);
}
/* Print to STDERR the polyhedron PH under its PolyLib matrix form. */
DEBUG_FUNCTION void
debug_ppl_polyhedron_matrix (ppl_Polyhedron_t ph)
{
ppl_print_polyhedron_matrix (stderr, ph);
}
/* Print to STDERR the powerset PS in its PolyLib matrix form. */
DEBUG_FUNCTION void
debug_ppl_powerset_matrix (ppl_Pointset_Powerset_C_Polyhedron_t ps)
{
ppl_print_powerset_matrix (stderr, ps);
}
/* Read from FILE a polyhedron under PolyLib matrix form and return a
PPL polyhedron object. */
void
ppl_read_polyhedron_matrix (ppl_Polyhedron_t *ph, FILE *file)
{
CloogMatrix *mat = cloog_matrix_read (file);
new_C_Polyhedron_from_Cloog_Matrix (ph, mat);
cloog_matrix_free (mat);
}
/* Return in RES the maximum of the linear expression LE on the
pointset powerset of polyhedra PS. */
void
ppl_max_for_le_pointset (ppl_Pointset_Powerset_C_Polyhedron_t ps,
ppl_Linear_Expression_t le, mpz_t res)
{
ppl_Coefficient_t num, denom;
mpz_t dv, nv;
int maximum, err;
mpz_init (nv);
mpz_init (dv);
ppl_new_Coefficient (&num);
ppl_new_Coefficient (&denom);
err = ppl_Pointset_Powerset_C_Polyhedron_maximize (ps, le, num, denom, &maximum);
if (err > 0)
{
ppl_Coefficient_to_mpz_t (num, nv);
ppl_Coefficient_to_mpz_t (denom, dv);
gcc_assert (value_notzero_p (dv));
mpz_tdiv_q (res, nv, dv);
}
mpz_clear (nv);
mpz_clear (dv);
ppl_delete_Coefficient (num);
ppl_delete_Coefficient (denom);
}
/* Return in RES the maximum of the linear expression LE on the
polyhedron POL. */
void
ppl_min_for_le_pointset (ppl_Pointset_Powerset_C_Polyhedron_t ps,
ppl_Linear_Expression_t le, mpz_t res)
{
ppl_Coefficient_t num, denom;
mpz_t dv, nv;
int minimum, err;
mpz_init (nv);
mpz_init (dv);
ppl_new_Coefficient (&num);
ppl_new_Coefficient (&denom);
err = ppl_Pointset_Powerset_C_Polyhedron_minimize (ps, le, num, denom, &minimum);
if (err > 0)
{
ppl_Coefficient_to_mpz_t (num, nv);
ppl_Coefficient_to_mpz_t (denom, dv);
gcc_assert (value_notzero_p (dv));
mpz_tdiv_q (res, nv, dv);
}
mpz_clear (nv);
mpz_clear (dv);
ppl_delete_Coefficient (num);
ppl_delete_Coefficient (denom);
}
/* Builds a constraint in dimension DIM relating dimensions POS1 to
POS2 as "POS1 - POS2 + C CSTR_TYPE 0" */
ppl_Constraint_t
ppl_build_relation (int dim, int pos1, int pos2, int c,
enum ppl_enum_Constraint_Type cstr_type)
{
ppl_Linear_Expression_t expr;
ppl_Constraint_t cstr;
ppl_Coefficient_t coef;
mpz_t v, v_op, v_c;
mpz_init (v);
mpz_init (v_op);
mpz_init (v_c);
mpz_set_si (v, 1);
mpz_set_si (v_op, -1);
mpz_set_si (v_c, c);
ppl_new_Coefficient (&coef);
ppl_new_Linear_Expression_with_dimension (&expr, dim);
ppl_assign_Coefficient_from_mpz_t (coef, v);
ppl_Linear_Expression_add_to_coefficient (expr, pos1, coef);
ppl_assign_Coefficient_from_mpz_t (coef, v_op);
ppl_Linear_Expression_add_to_coefficient (expr, pos2, coef);
ppl_assign_Coefficient_from_mpz_t (coef, v_c);
ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
ppl_new_Constraint (&cstr, expr, cstr_type);
ppl_delete_Linear_Expression (expr);
ppl_delete_Coefficient (coef);
mpz_clear (v);
mpz_clear (v_op);
mpz_clear (v_c);
return cstr;
}
#endif