variable.c

Go to the documentation of this file.

/*
 
  $Id: variable.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/>.
 
*/
 
/*
 * This file contains functions used to compute all pointer locations
 * within an entity, if any. It is tricky for structures containing
 * structures and for arrays of structures or pointeurs and much
 * easier for scalar pointers.
 *
 * Several pieces of code have been cut-and-pasted. Either more
 * functions should have been defined or array of structs are not
 * handled in a graceful way or both problems occur.
 *
 * The similar functions in Amira's implementation are located in
 * points_to_analysis_general_algorithm.c.
 */
 
#include <stdlib.h>
#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "database.h"
#include "ri-util.h"
#include "effects-util.h"
#include "constants.h"
#include "misc.h"
#include "properties.h"
#include "effects-generic.h"
#include "effects-simple.h"
//#include "effects-convex.h"
#include "newgen_set.h"
#include "points_to_private.h"
#include "points-to.h"
 
␌
/* When the declaration of "e" does not contain an initial value, find
 * all allocated pointers in entity e. We distinguish between scalar
 * pointers, array of pointers and struct containing pointers and
 * struct. Return a list of cells each containing a reference to aa
 * pointer. These cells are used later as sources to build a points-to
 * data structure pointing to nowhere/undefined.
 */
list variable_to_pointer_locations(entity e)
{
  list l = NIL;
  
  if (entity_variable_p(e)) {
    /*AM: missing recursive descent on variable_dimensions. int a[*(q=p)]*/
 
    type t =  entity_basic_concrete_type(e);
    if(pointer_type_p(t) || array_of_pointers_type_p(t)) {
      if (entity_array_p(e)) {
        /* variable v = type_variable(t); */
        /* int d = (int) gen_length(variable_dimensions(v)); */
        /* list sl = NIL; */
        /* int i; */
        /* for(i=0;i<d;i++) { */
        /*   expression ind = make_unbounded_expression(); */
        /*   sl = CONS(EXPRESSION, ind, sl); */
        /* } */
        /* reference r = make_reference(e, sl); */
        reference r = make_reference(e, NIL);
        cell c = make_cell_reference(r);
        points_to_cell_add_unbounded_subscripts(c);
        l = CONS(CELL, c, NIL);
      }
      else {
        // FI: could be unified with previous case using d==0
        reference r = make_reference(e, NIL);
        cell c = make_cell_reference(r);
        l = CONS(CELL, c, NIL);
      } 
    }
    else if(struct_type_p(t) || array_of_struct_type_p(t)) {
      basic b = variable_basic(type_variable(t));
      entity ee = basic_derived(b);
      l = struct_variable_to_pointer_locations(e, ee);
    }
    //free_type(t); ee is used above
  }
 
  return l;
}
 
/* return list of cells for pointers declared directly or indirecltly in
 * variable "e" of type struct defined by entity "ee" and its type.
 *
 * Typedefs have already been taken care of by the caller (?).
 *
 * Signature with e and ee inherited from Amira Mensi.
 */
list struct_variable_to_pointer_locations(entity e, entity ee)
{
  list l = NIL;
  // bool  eval = true;
  type tt = entity_type(ee);
  pips_assert("entity ee has type struct", type_struct_p(tt));
  list fl = type_struct(tt); // list of fields, or field list
 
  list sl = NIL;
  if(array_entity_p(e)) {
    int i;
    for(i=0; i< variable_entity_dimension(e); i++) {
      expression se = make_unbounded_expression();
      sl = CONS(EXPRESSION, se, sl);
    }
  }
 
  FOREACH(ENTITY, f, fl) {
    type ft = ultimate_type(entity_type(f));
    if(pointer_type_p(ft) || array_of_pointers_type_p(ft)) {
      // FI: I wonder if we should not build the points-to right away
      // when we know the type of the nowehere/undefined cell;
      // reminder: this type is useful to switch to a anywhere
      // abstract location
      list l2 = NIL;
      if(array_type_p(entity_type(f))) {
        expression s2 = make_unbounded_expression();
        l2 = CONS(EXPRESSION, s2, NIL);
      }
      expression s = entity_to_expression(f);
      list fsl = CONS(EXPRESSION, s, l2); // field list
      list nsl = gen_full_copy_list(sl); // subscript list
      list fl = gen_nconc(nsl,fsl); // full list
      reference r = make_reference(e, fl);
      cell c = make_cell_reference(r);
      l = gen_nconc(l, CONS(CELL, c, NIL));
    }
    else if(struct_type_p(ft) || array_of_struct_type_p(ft)) {
      // The main data structure contains a secondary data structure
      // FI: build the prefix and go down
      list l2 = NIL;
      if(array_type_p(entity_type(f))) {
        expression s2 = make_unbounded_expression();
        l2 = CONS(EXPRESSION, s2, gen_full_copy_list(l2));
      }
      expression s = entity_to_expression(f);
      list fsl = CONS(EXPRESSION, s, l2); // field list
      list nsl = gen_full_copy_list(sl); // subscript list
      list fl = gen_nconc(nsl,fsl); // full list
      reference r = make_reference(e, fl);
      cell c = make_cell_reference(r);
 
      /* Find pointers downwards and build a list of cells. */
      list ll = struct_variable_to_pointer_subscripts(c, f);
 
      free_cell(c);
      l = gen_nconc(l, ll);
      //pips_internal_error("Not implemented yet.\n");
      //l = array_of_struct_to_pointer_location(e, ee);
    }
  }
  gen_full_free_list(sl);
  return l;
}
 
/* returns a list of cells to reach pointers depending
 * on field f. Cell c is the current prefix.
 */
list struct_variable_to_pointer_subscripts(cell c, entity f)
{
  list sl = NIL;
  type ft = ultimate_type(entity_type(f));
  pips_assert("We are dealing with a struct", struct_type_p(ft)
              || array_of_struct_type_p(ft));
  basic fb = variable_basic(type_variable(ft));
  type st = entity_type(basic_derived(fb));
  list sfl = type_struct(st);
 
  /* In case we are dealing with an array of structs, add subscript
     expressions in mc, a modified copy of parameter c */
  cell mc = copy_cell(c); // modified cell c
  /*
  if(array_type_p(ft)) {
    list ssl = NIL;
    int i;
    for(i=0; i< variable_dimension_number(type_variable(ft)); i++) {
      expression se = make_unbounded_expression();
      ssl = CONS(EXPRESSION, se, ssl);
    }
    reference r = cell_any_reference(mc);
    reference_indices(r) = gen_nconc(reference_indices(r), ssl);
  }
  */
 
  /* Take care of each field in the structure. */
  FOREACH(ENTITY, sf, sfl) {
    type sft = ultimate_type(entity_type(sf));
    if(pointer_type_p(sft) || array_of_pointers_type_p(sft)) {
      /* copy cell c and add a subscript for f */
      cell nc = copy_cell(mc);
      reference r = cell_any_reference(nc);
      expression se = entity_to_expression(sf);
      reference_indices(r) = gen_nconc(reference_indices(r),
                                       CONS(EXPRESSION, se, NIL));
      if(array_entity_p(sf)) {
        expression ue = make_unbounded_expression();
        reference_indices(r) = gen_nconc(reference_indices(r),
                                         CONS(EXPRESSION, ue, NIL));
      }
      sl = gen_nconc(sl, CONS(CELL, nc, NIL));
    }
    else if(struct_type_p(sft) || array_of_struct_type_p(sft)) {
      /* copy cell c and add a subscript for f */
      cell nc = copy_cell(c);
      reference r = cell_any_reference(nc);
      expression se = entity_to_expression(sf);
      reference_indices(r) = gen_nconc(reference_indices(r),
                                       CONS(EXPRESSION, se, NIL));
      if(array_entity_p(sf)) {
        expression ue = make_unbounded_expression();
        reference_indices(r) = gen_nconc(reference_indices(r),
                                         CONS(EXPRESSION, ue, NIL));
      }
      list nsl = struct_variable_to_pointer_subscripts(nc, sf);
      sl = gen_nconc(sl, nsl);
      free_cell(nc);
    }
  }
 
  free_cell(mc);
 
  return sl;
}