variable.c File Reference

#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 "newgen_set.h"
#include "points_to_private.h"
#include "points-to.h"

Include dependency graph for variable.c:

Go to the source code of this file.

Functions
list	variable_to_pointer_locations (entity e)
	When the declaration of "e" does not contain an initial value, find all allocated pointers in entity e. More...
list	struct_variable_to_pointer_locations (entity e, entity ee)
	return list of cells for pointers declared directly or indirecltly in variable "e" of type struct defined by entity "ee" and its type. More...
list	struct_variable_to_pointer_subscripts (cell c, entity f)
	returns a list of cells to reach pointers depending on field f. More...

Function Documentation

struct_variable_to_pointer_locations()

list struct_variable_to_pointer_locations	(	entity	e,
		entity	ee
	)

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.

Find pointers downwards and build a list of cells.

Parameters

ee

e

Definition at line 115 of file variable.c.

{
  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;
}

References array_entity_p(), array_of_pointers_type_p(), array_of_struct_type_p(), array_type_p(), CELL, CONS, ENTITY, entity_to_expression(), entity_type, EXPRESSION, f(), FOREACH, free_cell(), gen_full_copy_list(), gen_full_free_list(), gen_nconc(), make_cell_reference(), make_reference(), make_unbounded_expression(), NIL, pips_assert, pointer_type_p(), struct_type_p(), struct_variable_to_pointer_subscripts(), type_struct, type_struct_p, ultimate_type(), and variable_entity_dimension().

Referenced by variable_to_pointer_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

struct_variable_to_pointer_subscripts()

list struct_variable_to_pointer_subscripts	(	cell	c,
		entity	f
	)

returns a list of cells to reach pointers depending on field f.

Cell c is the current prefix.

In case we are dealing with an array of structs, add subscript expressions in mc, a modified copy of parameter c

Take care of each field in the structure.

copy cell c and add a subscript for f

copy cell c and add a subscript for f

Definition at line 183 of file variable.c.

{
  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;
}

References array_entity_p(), array_of_pointers_type_p(), array_of_struct_type_p(), basic_derived, CELL, cell_any_reference(), CONS, copy_cell(), ENTITY, entity_to_expression(), entity_type, EXPRESSION, f(), FOREACH, free_cell(), gen_nconc(), make_unbounded_expression(), NIL, pips_assert, pointer_type_p(), reference_indices, struct_type_p(), struct_variable_to_pointer_subscripts(), type_struct, type_variable, ultimate_type(), and variable_basic.

Referenced by struct_variable_to_pointer_locations(), and struct_variable_to_pointer_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_to_pointer_locations()

list variable_to_pointer_locations

(

entity

e

)

When the declaration of "e" does not contain an initial value, find all allocated pointers in entity e.

variable.c

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.

M: missing recursive descent on variable_dimensions. int a[*(q=p)]

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

Definition at line 66 of file variable.c.

{
  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;
}

References array_of_pointers_type_p(), array_of_struct_type_p(), basic_derived, CELL, CONS, entity_array_p(), entity_basic_concrete_type(), entity_variable_p, make_cell_reference(), make_reference(), NIL, pointer_type_p(), points_to_cell_add_unbounded_subscripts(), struct_type_p(), struct_variable_to_pointer_locations(), type_variable, and variable_basic.

Referenced by declaration_statement_to_points_to(), malloc_to_points_to_sinks(), and struct_initialization_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function: