overlap.c

Go to the documentation of this file.

/*
 
  $Id: overlap.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS 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 of the License, or
  any later version.
 
  PIPS 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 PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
/* Overlap Management Module for HPFC
 * Fabien Coelho, August 1993
 */
 
#include "defines-local.h"
bool expression_constant_p(expression); /* in static_controlize */
 
GENERIC_GLOBAL_FUNCTION(overlap_status, overlapsmap)
 
static void create_overlaps(e)
entity e;
{
    type t = entity_type(e);
    list o=NIL;
    int n;
 
    assert(type_variable_p(t));
 
    n = gen_length(variable_dimensions(type_variable(t)));
    for(; n>=1; n--) o = CONS(OVERLAP, make_overlap(0, 0), o);
 
    store_overlap_status(e, o);
 
    assert(bound_overlap_status_p(e));
}
 
/* set_overlap(ent, dim, side, width)
 *
 * set the overlap value for entity ent, on dimension dim,
 * dans side side to width, which must be a positive integer.
 * if necessary, the overlap is updates with the value width.
 */
void set_overlap(ent, dim, side, width)
entity ent;
int dim, side, width;
{
    overlap o;
    int current;
 
    assert(dim>0);
 
    if (!bound_overlap_status_p(ent)) create_overlaps(ent);
    o = OVERLAP(gen_nth(dim-1, load_overlap_status(ent)));
 
    if (side) /* upper */
    {
        current = overlap_upper(o);
        if (current<width) overlap_upper(o)=width;
    }
    else /* lower */
    {
        current = overlap_lower(o);
        if (current<width) overlap_lower(o)=width;
    }
}
 
/* int get_overlap(ent, dim, side)
 *
 * returns the overlap for a given entity, dimension and side,
 * to be used in the declaration modifications
 */
int get_overlap(ent, dim, side)
entity ent;
int dim, side;
{
    overlap o;
 
    assert(dim>0);
 
    if (!bound_overlap_status_p(ent)) create_overlaps(ent);
    assert(bound_overlap_status_p(ent));
 
    o = OVERLAP(gen_nth(dim-1, load_overlap_status(ent)));
    return(side ? overlap_upper(o) : overlap_lower(o));
}
 
/* static void overlap_redefine_expression(pexpr, ov)
 *
 * redefine the bound given the overlap which is to be included
 */
static void overlap_redefine_expression(pexpr, ov)
expression *pexpr;
int ov;
{
    expression
        copy = *pexpr;
 
    if (expression_constant_p(*pexpr))
    {
        *pexpr = int_to_expression(HpfcExpressionToInt(*pexpr)+ov);
        free_expression(copy); /* this avoid a memory leak */
    }
    else
        *pexpr = MakeBinaryCall(FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, 
                                                   PLUS_OPERATOR_NAME),
                                *pexpr,
                                int_to_expression(ov));
}
 
static void declaration_with_overlaps(l)
list l;
{
    entity ent;
    int ndim, i, lower_overlap, upper_overlap;
    dimension the_dim;
 
    MAP(ENTITY, oldent,
     {
         ent = load_new_node(oldent);
         ndim = variable_entity_dimension(ent);
 
         assert(type_variable_p(entity_type(ent)));
 
         for (i=1 ; i<=ndim ; i++)
         {
             the_dim = entity_ith_dimension(ent, i);
             lower_overlap = get_overlap(oldent, i, 0);
             upper_overlap = get_overlap(oldent, i, 1);
 
             debug(8, "declaration_with_overlaps", 
                   "%s(DIM=%d): -%d, +%d\n", 
                   entity_name(ent), i, lower_overlap, upper_overlap);
 
             if (lower_overlap!=0) 
                 overlap_redefine_expression(&dimension_lower(the_dim),
                                             -lower_overlap);
                 
             if (upper_overlap!=0) 
                 overlap_redefine_expression(&dimension_upper(the_dim),
                                             upper_overlap);
         }
     },
         l);
}
 
/* updates overlaps for similar arrays that are going to be merged
 */
static void deal_with_similars(list le)
{
  FOREACH(ENTITY, array, le)
    {
        //if (entity_dynamic_p(array) && load_similar_mapping(array)!=array)
        if (variable_dynamic_p(array) && load_similar_mapping(array)!=array)
        {
            entity sim = load_similar_mapping(array);
            int dim;
 
            pips_debug(8, "translating overlaps from %s to %s\n",
                       entity_name(array), entity_name(sim));
 
            for (dim=variable_entity_dimension(array); dim>0; dim--)
            {
                int o;
 
                o = get_overlap(array, dim, 0);
                set_overlap(sim, dim, 0, o);
                o = get_overlap(array, dim, 1);
                set_overlap(sim, dim, 1, o);
            }
        }
    }
}
 
void declaration_with_overlaps_for_module(module)
entity  module;
{
    list l = list_of_distributed_arrays_for_module(module);
 
    deal_with_similars(l);
    declaration_with_overlaps(l);
    gen_free_list(l);
}
 
/*   That is all
 */