Subversion Repositories openrisc

/* Gimple Represented as Polyhedra.

   Copyright (C) 2009, 2010 Free Software Foundation, Inc.

   Contributed by Sebastian Pop <sebastian.pop@inria.fr>

   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"

#ifdef HAVE_cloog

#include "ppl_c.h"

#include "cloog/cloog.h"

#include "graphite-cloog-util.h"

#include "graphite-cloog-compat.h"

/* 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.  */

  /* Cast needed to remove warning that is generated as CLooG isl

     is using an unsigned int for NbColumns and CLooG PPL is

     using a signed int for NBColumns.  */

  for (k = 1; k < (int)m->NbColumns; k++)

    mpz_neg (m->p[row][k], m->p[row][k]);

}

/* Inserts constraint CSTR at row ROW of matrix M.  */

static 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;

}

/* 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);

  /* Cast needed to remove warning that is generated as CLooG isl

     is using an unsigned int for NbColumns and CLooG PPL is

     using a signed int for NBColumns.  */

  for (j = 1; j < (int)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]) == 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);

  /* Cast needed to remove warning that is generated as CLooG isl

     is using an unsigned int for NbColumns and CLooG PPL is

     using a signed int for NBColumns.  */

  for (i = 0; i < (int)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);

}

/* Creates a CloogDomain from polyhedron PH.  */

CloogDomain *

new_Cloog_Domain_from_ppl_Polyhedron (ppl_const_Polyhedron_t ph, int nb_params,

                                      CloogState *state ATTRIBUTE_UNUSED)

{

  CloogMatrix *mat = new_Cloog_Matrix_from_ppl_Polyhedron (ph);

  CloogDomain *res = cloog_domain_from_cloog_matrix (state, mat, nb_params);

  cloog_matrix_free (mat);

  return res;

}

/* Create a CloogScattering from polyhedron PH.  */

CloogScattering *

new_Cloog_Scattering_from_ppl_Polyhedron (ppl_const_Polyhedron_t ph,

                                          int nb_params ATTRIBUTE_UNUSED,

                                          int nb_scatt ATTRIBUTE_UNUSED,

                                          CloogState *state ATTRIBUTE_UNUSED)

{

#ifdef CLOOG_ORG

  CloogMatrix *mat = new_Cloog_Matrix_from_ppl_Polyhedron (ph);

  CloogScattering *res = cloog_scattering_from_cloog_matrix (state, mat,

                                                             nb_scatt,

                                                             nb_params);

  cloog_matrix_free (mat);

  return res;

#else

  return new_Cloog_Domain_from_ppl_Polyhedron (ph, nb_params, state);

#endif

}

/* Creates a CloogDomain from a pointset powerset PS.  */

CloogDomain *

new_Cloog_Domain_from_ppl_Pointset_Powerset

  (ppl_Pointset_Powerset_C_Polyhedron_t ps, int nb_params,

   CloogState *state ATTRIBUTE_UNUSED)

{

  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, nb_params, state);

      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;

}

/* Print to FILE the matrix MAT in OpenScop format.  OUTPUT is the number

   of output dimensions, INPUT is the number of input dimensions, LOCALS

   is the number of existentially quantified variables and PARAMS is the

   number of parameters.  */

static void

openscop_print_cloog_matrix (FILE *file, CloogMatrix *mat,

                             int output, int input, int locals,

                             int params)

{

  int i, j;

  fprintf (file, "%d %d %d %d %d %d \n", cloog_matrix_nrows (mat),

           cloog_matrix_ncolumns (mat), output, input, locals, params);

  for (i = 0; i < cloog_matrix_nrows (mat); i++)

    {

      for (j = 0; j < cloog_matrix_ncolumns (mat); j++)

        if (j == 0)

          fprintf (file, "%ld ", mpz_get_si (mat->p[i][j]));

        else

          fprintf (file, "%6ld ", mpz_get_si (mat->p[i][j]));

      fprintf (file, "\n");

    }

}

/* Print to FILE the polyhedron PH in OpenScop format.  OUTPUT is the number

   of output dimensions, INPUT is the number of input dimensions, LOCALS is

   the number of existentially quantified variables and PARAMS is the number

   of parameters.  */

void

openscop_print_polyhedron_matrix (FILE *file, ppl_const_Polyhedron_t ph,

                                  int output, int input, int locals,

                                  int params)

{

  CloogMatrix *mat = new_Cloog_Matrix_from_ppl_Polyhedron (ph);

  openscop_print_cloog_matrix (file, mat, output, input, locals, params);

  cloog_matrix_free (mat);

}

/* Read from FILE a matrix in OpenScop format.  OUTPUT is the number of

   output dimensions, INPUT is the number of input dimensions, LOCALS

   is the number of existentially quantified variables and PARAMS is the

   number of parameters.  */

static CloogMatrix *

openscop_read_cloog_matrix (FILE *file, int *output, int *input, int *locals,

                            int *params)

{

  int nb_rows, nb_cols, i, j;

  CloogMatrix *mat;

  int *openscop_matrix_header, *matrix_line;

  openscop_matrix_header = openscop_read_N_int (file, 6);

  nb_rows = openscop_matrix_header[0];

  nb_cols = openscop_matrix_header[1];

  *output = openscop_matrix_header[2];

  *input = openscop_matrix_header[3];

  *locals = openscop_matrix_header[4];

  *params = openscop_matrix_header[5];

  free (openscop_matrix_header);

  if (nb_rows == 0 || nb_cols == 0)

    return NULL;

  mat = cloog_matrix_alloc (nb_rows, nb_cols);

  mat->NbRows = nb_rows;

  mat->NbColumns = nb_cols;

  for (i = 0; i < nb_rows; i++)

    {

      matrix_line = openscop_read_N_int (file, nb_cols);

      for (j = 0; j < nb_cols; j++)

        mpz_set_si (mat->p[i][j], matrix_line[j]);

    }

  return mat;

}

/* Read from FILE the polyhedron PH in OpenScop format.  OUTPUT is the number

   of output dimensions, INPUT is the number of input dimensions, LOCALS is

   the number of existentially quantified variables and PARAMS is the number

   of parameters.  */

void

openscop_read_polyhedron_matrix (FILE *file, ppl_Polyhedron_t *ph,

                                 int *output, int *input, int *locals,

                                 int *params)

{

  CloogMatrix *mat;

  mat = openscop_read_cloog_matrix (file, output, input, locals, params);

  if (!mat)

    *ph = NULL;

  else

    {

      new_C_Polyhedron_from_Cloog_Matrix (ph, mat);

      cloog_matrix_free (mat);

    }

}

#endif