gcc/gcc/graphite-poly.c
Jakub Jelinek a554497024 Update copyright years.
From-SVN: r267494
2019-01-01 13:31:55 +01:00

637 lines
13 KiB
C

/* Graphite polyhedral representation.
Copyright (C) 2009-2019 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/>. */
#define USES_ISL
#include "config.h"
#ifdef HAVE_isl
#include "system.h"
#include "coretypes.h"
#include "backend.h"
#include "tree.h"
#include "gimple.h"
#include "cfghooks.h"
#include "diagnostic-core.h"
#include "fold-const.h"
#include "gimple-iterator.h"
#include "tree-ssa-loop.h"
#include "cfgloop.h"
#include "tree-data-ref.h"
#include "pretty-print.h"
#include "gimple-pretty-print.h"
#include "graphite.h"
#include "dumpfile.h"
/* Print to STDERR the GMP value VAL. */
DEBUG_FUNCTION void
debug_gmp_value (mpz_t val)
{
gmp_fprintf (stderr, "%Zd", val);
}
/* Prints to FILE the iteration domain of PBB. */
void
print_iteration_domain (FILE *file, poly_bb_p pbb)
{
print_pbb_domain (file, pbb);
}
/* Prints to FILE the iteration domains of every PBB of SCOP. */
void
print_iteration_domains (FILE *file, scop_p scop)
{
int i;
poly_bb_p pbb;
FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
print_iteration_domain (file, pbb);
}
/* Prints to STDERR the iteration domain of PBB. */
DEBUG_FUNCTION void
debug_iteration_domain (poly_bb_p pbb)
{
print_iteration_domain (stderr, pbb);
}
/* Prints to STDERR the iteration domains of every PBB of SCOP. */
DEBUG_FUNCTION void
debug_iteration_domains (scop_p scop)
{
print_iteration_domains (stderr, scop);
}
/* Create a new polyhedral data reference and add it to PBB. It is
defined by its ACCESSES, its TYPE, and the number of subscripts
NB_SUBSCRIPTS. */
void
new_poly_dr (poly_bb_p pbb, gimple *stmt, enum poly_dr_type type,
isl_map *acc, isl_set *subscript_sizes)
{
static int id = 0;
poly_dr_p pdr = XNEW (struct poly_dr);
pdr->stmt = stmt;
PDR_ID (pdr) = id++;
PDR_NB_REFS (pdr) = 1;
PDR_PBB (pdr) = pbb;
pdr->accesses = acc;
pdr->subscript_sizes = subscript_sizes;
PDR_TYPE (pdr) = type;
PBB_DRS (pbb).safe_push (pdr);
if (dump_file)
{
fprintf (dump_file, "Converting dr: ");
print_pdr (dump_file, pdr);
fprintf (dump_file, "To polyhedral representation:\n");
fprintf (dump_file, " - access functions: ");
print_isl_map (dump_file, acc);
fprintf (dump_file, " - subscripts: ");
print_isl_set (dump_file, subscript_sizes);
}
}
/* Free polyhedral data reference PDR. */
static void
free_poly_dr (poly_dr_p pdr)
{
isl_map_free (pdr->accesses);
isl_set_free (pdr->subscript_sizes);
XDELETE (pdr);
}
/* Create a new polyhedral black box. */
poly_bb_p
new_poly_bb (scop_p scop, gimple_poly_bb_p black_box)
{
poly_bb_p pbb = XNEW (struct poly_bb);
pbb->domain = NULL;
pbb->iterators = NULL;
PBB_SCOP (pbb) = scop;
pbb_set_black_box (pbb, black_box);
PBB_DRS (pbb).create (3);
GBB_PBB ((gimple_poly_bb_p) black_box) = pbb;
return pbb;
}
/* Free polyhedral black box. */
static void
free_poly_bb (poly_bb_p pbb)
{
int i;
poly_dr_p pdr;
isl_set_free (pbb->domain);
pbb->domain = NULL;
isl_set_free (pbb->iterators);
pbb->iterators = NULL;
if (PBB_DRS (pbb).exists ())
FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
free_poly_dr (pdr);
PBB_DRS (pbb).release ();
XDELETE (pbb);
}
/* Prints to FILE the polyhedral data reference PDR. */
void
print_pdr (FILE *file, poly_dr_p pdr)
{
fprintf (file, "pdr_%d (", PDR_ID (pdr));
switch (PDR_TYPE (pdr))
{
case PDR_READ:
fprintf (file, "read \n");
break;
case PDR_WRITE:
fprintf (file, "write \n");
break;
case PDR_MAY_WRITE:
fprintf (file, "may_write \n");
break;
default:
gcc_unreachable ();
}
fprintf (file, "in gimple stmt: ");
print_gimple_stmt (file, pdr->stmt, 0);
fprintf (file, "data accesses: ");
print_isl_map (file, pdr->accesses);
fprintf (file, "subscript sizes: ");
print_isl_set (file, pdr->subscript_sizes);
fprintf (file, ")\n");
}
/* Prints to STDERR the polyhedral data reference PDR. */
DEBUG_FUNCTION void
debug_pdr (poly_dr_p pdr)
{
print_pdr (stderr, pdr);
}
/* Store the GRAPHITE representation of BB. */
gimple_poly_bb_p
new_gimple_poly_bb (basic_block bb, vec<data_reference_p> drs,
vec<scalar_use> reads, vec<tree> writes)
{
gimple_poly_bb_p gbb = XNEW (struct gimple_poly_bb);
GBB_BB (gbb) = bb;
GBB_DATA_REFS (gbb) = drs;
gbb->read_scalar_refs = reads;
gbb->write_scalar_refs = writes;
GBB_CONDITIONS (gbb).create (0);
GBB_CONDITION_CASES (gbb).create (0);
return gbb;
}
/* Frees GBB. */
static void
free_gimple_poly_bb (gimple_poly_bb_p gbb)
{
free_data_refs (GBB_DATA_REFS (gbb));
GBB_CONDITIONS (gbb).release ();
GBB_CONDITION_CASES (gbb).release ();
gbb->read_scalar_refs.release ();
gbb->write_scalar_refs.release ();
XDELETE (gbb);
}
/* Deletes all gimple bbs in SCOP. */
static void
remove_gbbs_in_scop (scop_p scop)
{
int i;
poly_bb_p pbb;
FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
free_gimple_poly_bb (PBB_BLACK_BOX (pbb));
}
/* Creates a new SCOP containing the region (ENTRY, EXIT). */
scop_p
new_scop (edge entry, edge exit)
{
sese_info_p region = new_sese_info (entry, exit);
scop_p s = XNEW (struct scop);
s->original_schedule = NULL;
s->transformed_schedule = NULL;
s->param_context = NULL;
scop_set_region (s, region);
s->pbbs.create (3);
s->drs.create (3);
s->dependence = NULL;
return s;
}
/* Deletes SCOP. */
void
free_scop (scop_p scop)
{
int i;
poly_bb_p pbb;
remove_gbbs_in_scop (scop);
free_sese_info (scop->scop_info);
FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
free_poly_bb (pbb);
scop->pbbs.release ();
scop->drs.release ();
isl_set_free (scop->param_context);
scop->param_context = NULL;
isl_union_map_free (scop->dependence);
scop->dependence = NULL;
isl_schedule_free (scop->original_schedule);
scop->original_schedule = NULL;
isl_schedule_free (scop->transformed_schedule);
scop->transformed_schedule = NULL;
XDELETE (scop);
}
/* Print to FILE the domain of PBB. */
void
print_pbb_domain (FILE *file, poly_bb_p pbb)
{
print_isl_set (file, pbb->domain);
}
/* Dump the cases of a graphite basic block GBB on FILE. */
static void
dump_gbb_cases (FILE *file, gimple_poly_bb_p gbb)
{
int i;
gimple *stmt;
vec<gimple *> cases;
if (!gbb)
return;
cases = GBB_CONDITION_CASES (gbb);
if (cases.is_empty ())
return;
fprintf (file, "cases bb_%d (\n", GBB_BB (gbb)->index);
FOR_EACH_VEC_ELT (cases, i, stmt)
print_gimple_stmt (file, stmt, 0);
fprintf (file, ")\n");
}
/* Dump conditions of a graphite basic block GBB on FILE. */
static void
dump_gbb_conditions (FILE *file, gimple_poly_bb_p gbb)
{
int i;
gimple *stmt;
vec<gimple *> conditions;
if (!gbb)
return;
conditions = GBB_CONDITIONS (gbb);
if (conditions.is_empty ())
return;
fprintf (file, "conditions bb_%d (\n", GBB_BB (gbb)->index);
FOR_EACH_VEC_ELT (conditions, i, stmt)
print_gimple_stmt (file, stmt, 0);
fprintf (file, ")\n");
}
/* Print to FILE all the data references of PBB. */
void
print_pdrs (FILE *file, poly_bb_p pbb)
{
int i;
poly_dr_p pdr;
int nb_reads = 0;
int nb_writes = 0;
if (PBB_DRS (pbb).is_empty ())
return;
fprintf (file, "Data references (\n");
FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
if (PDR_TYPE (pdr) == PDR_READ)
nb_reads++;
else
nb_writes++;
fprintf (file, "Read data references (\n");
FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
if (PDR_TYPE (pdr) == PDR_READ)
print_pdr (file, pdr);
fprintf (file, ")\n");
fprintf (file, "Write data references (\n");
FOR_EACH_VEC_ELT (PBB_DRS (pbb), i, pdr)
if (PDR_TYPE (pdr) != PDR_READ)
print_pdr (file, pdr);
fprintf (file, ")\n");
fprintf (file, ")\n");
}
/* Print to STDERR all the data references of PBB. */
DEBUG_FUNCTION void
debug_pdrs (poly_bb_p pbb)
{
print_pdrs (stderr, pbb);
}
/* Print to FILE the body of PBB. */
static void
print_pbb_body (FILE *file, poly_bb_p pbb)
{
fprintf (file, "Body (\n");
dump_bb (file, pbb_bb (pbb), 0, TDF_NONE);
fprintf (file, ")\n");
}
/* Print to FILE the domain and scattering function of PBB. */
void
print_pbb (FILE *file, poly_bb_p pbb)
{
fprintf (file, "pbb_%d (\n", pbb_index (pbb));
dump_gbb_conditions (file, PBB_BLACK_BOX (pbb));
dump_gbb_cases (file, PBB_BLACK_BOX (pbb));
print_pbb_domain (file, pbb);
print_pdrs (file, pbb);
print_pbb_body (file, pbb);
fprintf (file, ")\n");
}
/* Print to FILE the parameters of SCOP. */
void
print_scop_params (FILE *file, scop_p scop)
{
if (scop->scop_info->params.is_empty ())
return;
int i;
tree t;
fprintf (file, "parameters (");
FOR_EACH_VEC_ELT (scop->scop_info->params, i, t)
{
print_generic_expr (file, t);
fprintf (file, ", ");
}
fprintf (file, ")\n");
}
/* Print to FILE the context of SCoP. */
void
print_scop_context (FILE *file, scop_p scop)
{
if (!scop->param_context)
return;
fprintf (file, "Context (\n");
print_isl_set (file, scop->param_context);
fprintf (file, ")\n");
}
/* Print to FILE the SCOP. */
void
print_scop (FILE *file, scop_p scop)
{
int i;
poly_bb_p pbb;
fprintf (file, "SCoP (\n");
print_scop_context (file, scop);
print_scop_params (file, scop);
fprintf (file, "Number of statements: ");
fprintf (file, "%d\n", scop->pbbs.length ());
FOR_EACH_VEC_ELT (scop->pbbs, i, pbb)
print_pbb (file, pbb);
fprintf (file, ")\n");
}
/* Print to STDERR the domain of PBB. */
DEBUG_FUNCTION void
debug_pbb_domain (poly_bb_p pbb)
{
print_pbb_domain (stderr, pbb);
}
/* Print to FILE the domain and scattering function of PBB. */
DEBUG_FUNCTION void
debug_pbb (poly_bb_p pbb)
{
print_pbb (stderr, pbb);
}
/* Print to STDERR the context of SCOP. */
DEBUG_FUNCTION void
debug_scop_context (scop_p scop)
{
print_scop_context (stderr, scop);
}
/* Print to STDERR the SCOP. */
DEBUG_FUNCTION void
debug_scop (scop_p scop)
{
print_scop (stderr, scop);
}
/* Print to STDERR the parameters of SCOP. */
DEBUG_FUNCTION void
debug_scop_params (scop_p scop)
{
print_scop_params (stderr, scop);
}
extern isl_ctx *the_isl_ctx;
void
print_isl_set (FILE *f, __isl_keep isl_set *set)
{
isl_printer *p = isl_printer_to_file (the_isl_ctx, f);
p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK);
p = isl_printer_print_set (p, set);
p = isl_printer_print_str (p, "\n");
isl_printer_free (p);
}
DEBUG_FUNCTION void
debug_isl_set (__isl_keep isl_set *set)
{
print_isl_set (stderr, set);
}
void
print_isl_map (FILE *f, __isl_keep isl_map *map)
{
isl_printer *p = isl_printer_to_file (the_isl_ctx, f);
p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK);
p = isl_printer_print_map (p, map);
p = isl_printer_print_str (p, "\n");
isl_printer_free (p);
}
DEBUG_FUNCTION void
debug_isl_map (__isl_keep isl_map *map)
{
print_isl_map (stderr, map);
}
void
print_isl_union_map (FILE *f, __isl_keep isl_union_map *map)
{
isl_printer *p = isl_printer_to_file (the_isl_ctx, f);
p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK);
p = isl_printer_print_union_map (p, map);
p = isl_printer_print_str (p, "\n");
isl_printer_free (p);
}
DEBUG_FUNCTION void
debug_isl_union_map (__isl_keep isl_union_map *map)
{
print_isl_union_map (stderr, map);
}
void
print_isl_aff (FILE *f, __isl_keep isl_aff *aff)
{
isl_printer *p = isl_printer_to_file (the_isl_ctx, f);
p = isl_printer_print_aff (p, aff);
p = isl_printer_print_str (p, "\n");
isl_printer_free (p);
}
DEBUG_FUNCTION void
debug_isl_aff (__isl_keep isl_aff *aff)
{
print_isl_aff (stderr, aff);
}
void
print_isl_constraint (FILE *f, __isl_keep isl_constraint *c)
{
isl_printer *p = isl_printer_to_file (the_isl_ctx, f);
p = isl_printer_print_constraint (p, c);
p = isl_printer_print_str (p, "\n");
isl_printer_free (p);
}
DEBUG_FUNCTION void
debug_isl_constraint (__isl_keep isl_constraint *c)
{
print_isl_constraint (stderr, c);
}
void
print_isl_schedule (FILE *f, __isl_keep isl_schedule *s)
{
isl_printer *p = isl_printer_to_file (the_isl_ctx, f);
p = isl_printer_set_yaml_style (p, ISL_YAML_STYLE_BLOCK);
p = isl_printer_print_schedule (p, s);
p = isl_printer_print_str (p, "\n");
isl_printer_free (p);
}
DEBUG_FUNCTION void
debug_isl_schedule (__isl_keep isl_schedule *s)
{
print_isl_schedule (stderr, s);
}
void
print_isl_ast (FILE *file, __isl_keep isl_ast_node *n)
{
isl_printer *prn = isl_printer_to_file (the_isl_ctx, file);
prn = isl_printer_set_output_format (prn, ISL_FORMAT_C);
prn = isl_printer_print_ast_node (prn, n);
prn = isl_printer_print_str (prn, "\n");
isl_printer_free (prn);
}
DEBUG_FUNCTION void
debug_isl_ast (isl_ast_node *n)
{
print_isl_ast (stderr, n);
}
DEBUG_FUNCTION void
debug_scop_pbb (scop_p scop, int i)
{
debug_pbb (scop->pbbs[i]);
}
#endif /* HAVE_isl */