references.c

Go to the documentation of this file.

/*
 
  $Id: references.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
/*  
 * Function of manipulation of reference lists
 * 
  * Corinne Ancourt
  */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include "linear.h"
 
#include "genC.h"
#include "ri.h"
#include "effects.h"
#include "misc.h"
#include "ri-util.h"
#include "effects-util.h"
#include "constants.h"
#include "ri.h"
#include "effects.h"
 
#include "dg.h"
typedef dg_arc_label arc_label;
typedef dg_vertex_label vertex_label;
#include "graph.h"
 
#include "matrice.h"
#include "tiling.h"
#include "database.h"
#include "text.h"
#include "text-util.h"
#include "resources.h"
 
#include "wp65.h"
 
bool ref_in_list_p(list lt,reference r)
{
  pips_assert("true", lt==lt && r==r);
    return (false);
}
 
void update_map(statement_mapping m, statement st, reference r) 
{
    list lt;
 
    lt = (list) GET_STATEMENT_MAPPING(m,st);
    if (lt != (list) HASH_UNDEFINED_VALUE) { 
        if (!ref_in_list_p(lt,r)) {
            lt =  gen_nconc(lt, CONS(REFERENCE,r, NIL));
            ifdebug(9) 
                (void) fprintf(stderr,
                               "ajout de la ref: %s au statement %"PRIdPTR"\n",
                               entity_local_name(reference_variable(r)), 
                               statement_number(st));    
        }
    }
    else {
        lt= CONS(REFERENCE,r, NIL);
        ifdebug(9) 
            (void) fprintf (stderr,
                "ajout de la ref: %s au statement %"PRIdPTR"\n",
                entity_local_name(reference_variable(r)), 
                statement_number(st));   
    }
    SET_STATEMENT_MAPPING(m,st,lt);
}
 
/* This function gives the list of operands belonging to Expression e
*/
list expression_to_operand_list(e, lr)
expression e;
list lr;
{
    syntax s = expression_syntax(e);
    switch(syntax_tag(s)) {
    case is_syntax_reference:
        lr = gen_nconc(lr, CONS(REFERENCE, syntax_reference(s), NIL));
                break;
    case is_syntax_range:
        lr = expression_to_operand_list(range_lower(syntax_range(s)), lr);
        lr = expression_to_operand_list(range_upper(syntax_range(s)), lr);
        lr = expression_to_operand_list(range_increment(syntax_range(s)),
                                          lr);
        break;
    case is_syntax_call:
        MAPL(ce, {
            expression e = EXPRESSION(CAR(ce));
            lr = expression_to_operand_list(e, lr);
            },
             call_arguments(syntax_call(s)));
        break;
    default:
        (void) fprintf(stderr, 
                       "expression_to_operand_list - unexpected syntax\n");
    }
 
    return lr;
}
 
/* This function tests whether at least one  array indice of 
 * Reference r  belongs to  List lwr or not
 */
 
bool reference_in_list_p(reference r,list lwr)
{ 
    list lref2;
    bool result = false;
    for (lref2 = lwr; 
         lref2 != NULL && !result; 
         result = result || reference_equal_p(r,REFERENCE(CAR(lref2))),
         lref2 = CDR(lref2)) ;
    return(result);
}
bool array_indice_in_list_p(reference r,list lwr)
{ 
 
    list lr = NIL;
    bool result = false;
    list lref1;
    MAPL(ce,{    expression e = EXPRESSION(CAR(ce));
                 lr = expression_to_reference_list(e, lr);
             },
         reference_indices(r));
    for (lref1 = lr; 
         lref1 != NIL && !result;
         result = result || reference_in_list_p(REFERENCE(CAR(lref1)),
                                                lwr),
         lref1 = CDR(lref1));
   
    return result;
}
 
/* This function add Reference r to List l, if r doesn't belong to l
*/
void reference_list_update(list *l, reference r)
{
    list lref1 =*l ;
    if (*l != NIL)  {
        for(; lref1!= NIL && !(reference_equal_p(REFERENCE(CAR(lref1)),r)) ; 
            lref1 = CDR(lref1));
        if (lref1 == NIL) 
            *l= gen_nconc(*l, CONS(REFERENCE,r,NIL));
    }
    else *l =  CONS(REFERENCE,r,NIL);
}
 
/* This function adds all the references of l2 to l1 if they don't appear in l1
*/
void reference_list_add(list *l1,list *l2)
{
    list lref2 =*l2 ;
    for(; lref2!= NIL; 
        reference_list_update(l1, REFERENCE(CAR(lref2))),
        lref2 = CDR(lref2));
}
 
 
/* This function prints the references belonging to l
*/ 
void reference_list_print(list l)
{
    list lref;
    for (lref = l; 
         lref != NIL;
         (void) fprintf(stderr, 
                       "%s,",
                       entity_local_name(reference_variable(REFERENCE(CAR(lref))))), 
         lref = CDR(lref));
    (void) fprintf(stderr,"\n");
}
 
 
void reference_scalar_defined_p(reference r)
{
    assert(!reference_undefined_p(r) 
           && r!=NULL && reference_variable(r)!=NULL 
           && reference_indices(r) == NIL);
}
/* This function adds the reference r to List l, if the reference_variable(r) 
 * doesn't belong to l
*/
void variable_list_update(list *l, reference r)
{
    list lvar1 =*l ;
    if (*l != NIL)  {
        for(; 
            lvar1!= NIL 
            && strcmp(entity_local_name(reference_variable(REFERENCE(CAR(lvar1)))),
                      entity_local_name(reference_variable(r))); 
            lvar1 = CDR(lvar1));
        if (lvar1 == NIL) 
            *l= gen_nconc(*l, CONS(REFERENCE,r,NIL));
    }
    else *l =  CONS(REFERENCE,r,NIL);
}
 
/* This function adds all the references of l2 to l1 if they don't appear in l1
*/
void variable_list_add(list *l1,list *l2)
{
    list lvar2 =*l2 ;
    for(; lvar2!= NIL; 
        variable_list_update(l1,REFERENCE(CAR(lvar2))),
        lvar2 = CDR(lvar2));
}
 
 
 
 
void  concat_data_list(list * l,list * lr, statement st,statement_mapping map, bool perfect_nested_loop)
{
    instruction inst; 
    list  lt = (list) GET_STATEMENT_MAPPING(map,st);
 
    if (lt != (list) HASH_UNDEFINED_VALUE)  {
        variable_list_add(l, &lt);
        reference_list_add(lr,&lt);
    }
    inst = statement_instruction(st);
    switch(instruction_tag(inst)) {
    case is_instruction_block:{
        cons * b;
        b = instruction_block(inst);
        if (list_of_calls_p(b))
            concat_data_list(l,lr,STATEMENT(CAR(b)),map,perfect_nested_loop);
        else
            MAPL(st, { 
                concat_data_list(l,lr,STATEMENT(CAR(st)), map,
                                 perfect_nested_loop);
                   } , b);
        break;
    }
   
    case is_instruction_loop: {
        concat_data_list(l,lr,loop_body(instruction_loop(inst)),map,
                         perfect_nested_loop);
        break;} 
    default:  return;
    }
}