abstract_location.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "points_to_private.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "text.h"
#include "text-util.h"
#include "misc.h"
#include "properties.h"

Include dependency graph for abstract_location.c:

Go to the source code of this file.

Functions
bool	entity_heap_location_p (entity b)
	package abstract location. More...
entity	entity_flow_or_context_sentitive_heap_location (int stmt_number, type t)
bool	entity_flow_or_context_sentitive_heap_location_p (entity e)
type	malloc_arg_to_type (expression e)
	generate the type of the allocated area from the malloc argument More...
entity	malloc_type_to_abstract_location (type t, sensitivity_information *psi)
	generate an abstract heap location entity More...
entity	malloc_to_abstract_location (expression malloc_exp, sensitivity_information *psi)
	generate an abstract heap location entity More...
entity	calloc_to_abstract_location (expression n, expression size, sensitivity_information *psi)
	generate an abstract heap location entity More...
reference	original_malloc_to_abstract_location (expression lhs __attribute__((unused)), type __attribute__((unused)) var_t, type __attribute__((unused)) cast_t, expression sizeof_exp, entity f, statement stmt)
	to handle malloc statemennts: More...
sensitivity_information	make_sensitivity_information (statement current_stmt, entity current_module, list enclosing_flow)

Function Documentation

calloc_to_abstract_location()

entity calloc_to_abstract_location	(	expression	n,
		expression	size,
		sensitivity_information *	psi
	)

generate an abstract heap location entity

Parameters

n	is the first argument expression of the call to calloc
size	is the second argument expression of the call to calloc
psi	is a pointer towards a structure which contains context and/or flow sensitivity information

Returns

an abstract heap location entity

Parameters

size	ize
psi	si

Definition at line 414 of file abstract_location.c.

{
  expression malloc_exp = make_op_exp("*",
                                      copy_expression(n),
                                      copy_expression(size));
  entity e = malloc_to_abstract_location(malloc_exp, psi);
  free_expression(malloc_exp);
  return(e);
}

References copy_expression(), free_expression(), make_op_exp(), and malloc_to_abstract_location().

Here is the call graph for this function:

entity_flow_or_context_sentitive_heap_location()

entity entity_flow_or_context_sentitive_heap_location	(	int	stmt_number,
		type	t
	)

FI: Beware, the symbol table is updated but this is not reflected in pipsmake.rc

We need to keep track of these pseudo-variables to destroy them before a module is reanalyzed after a code transformation, for instance a constant propagation that changed dependent types into cosntant types.

We might be in trouble, unless a piece of code is reanalyzed. Let's assume the type is unchanged

Parameters

stmt_number

tmt_number

Definition at line 78 of file abstract_location.c.

{
  entity e;
  string s;
  asprintf(&s, HEAP_AREA_LOCAL_NAME "_l_%d", stmt_number);
 
  e = FindOrCreateEntity(get_current_module_name(),s);
  free(s);
  if(type_undefined_p(entity_type(e))) {
    entity f = get_current_module_entity();
    entity a = module_to_heap_area(f);
    //ram r = make_ram(f, a, UNKNOWN_RAM_OFFSET, NIL);
    ram r = make_ram(f, a, DYNAMIC_RAM_OFFSET, NIL);
 
    /* FI: Beware, the symbol table is updated but this is not
       reflected in pipsmake.rc */
    type ct = compute_basic_concrete_type(t);
    entity_type(e) = copy_type(ct);
    entity_storage(e) = make_storage_ram(r);
    entity_initial(e) = make_value_unknown();
    entity_kind(e) = ABSTRACT_LOCATION;
    (void) add_C_variable_to_area(a, e);
    /* We need to keep track of these pseudo-variables to destroy them
       before a module is reanalyzed after a code transformation, for
       instance a constant propagation that changed dependent types
       into cosntant types. */
    AddEntityToDeclarations(e, f);
  }
  else {
    /* We might be in trouble, unless a piece of code is
       reanalyzed. Let's assume the type is unchanged */
    type ct = compute_basic_concrete_type(t);
    type et = entity_type(e);
    // FI: too strong if 1-D arrays and pointers can be assimilated
    //pips_assert("The type is unchanged",
    // type_equal_p(ct, et));
    if(!type_equal_p(ct,et)) {
      // FI: this might be improvable with array_pointer_type_equal_p
      if(pointer_type_p(ct) && array_type_p(et)) {
        type pt = type_to_pointed_type(ct);
        basic pb = variable_basic(type_variable(pt));
        variable etv = type_variable(et);
        basic eb = variable_basic(etv);
        int d = (int) gen_length(variable_dimensions(etv));
        if(d==1 && basic_equal_p(pb, eb)) 
          ;
        else
          pips_assert("The type is unchanged or compatible", false);
      }
      else if(pointer_type_p(et) && array_type_p(ct)) {
        type pt = type_to_pointed_type(et);
        basic pb = variable_basic(type_variable(pt));
        variable etv = type_variable(ct);
        basic eb = variable_basic(etv);
        int d = (int) gen_length(variable_dimensions(etv));
        if(d==1 && basic_equal_p(pb, eb)) 
          ;
        else
          pips_assert("The type is unchanged or compatible", false);
      }
      else
        pips_assert("The type is unchanged or compatible", false);
    }
    free_type(ct);
  }
  return e;
 
}

References ABSTRACT_LOCATION, add_C_variable_to_area(), AddEntityToDeclarations(), array_type_p(), asprintf, basic_equal_p(), compute_basic_concrete_type(), copy_type(), DYNAMIC_RAM_OFFSET, entity_initial, entity_kind, entity_storage, entity_type, f(), FindOrCreateEntity(), free(), free_type(), gen_length(), get_current_module_entity(), get_current_module_name(), HEAP_AREA_LOCAL_NAME, int, make_ram(), make_storage_ram(), make_value_unknown(), module_to_heap_area(), NIL, pips_assert, pointer_type_p(), type_equal_p(), type_to_pointed_type(), type_undefined_p, type_variable, variable_basic, and variable_dimensions.

Referenced by malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_flow_or_context_sentitive_heap_location_p()

bool entity_flow_or_context_sentitive_heap_location_p

(

entity

e

)

Definition at line 147 of file abstract_location.c.

{
  bool result = false;
  const char* ln = entity_local_name(e);
  string found = strstr(ln, ANYWHERE_LOCATION);
 
  pips_debug(9, "input entity: %s\n", ln);
  pips_debug(9, "found (1) = : %s\n", found);
 
  if (found == NULL)
    {
      found = strstr(ln, HEAP_AREA_LOCAL_NAME);
      pips_debug(9, "found (2) = : %s\n", found);
      if (found!=NULL)
        {
          size_t found_n = strspn(found, HEAP_AREA_LOCAL_NAME);
          ln = &found[found_n];
          pips_debug(9, "ln : %s\n", ln);
          found = strstr(ln, "_l_");
          pips_debug(9, "found (3) = : %s\n", found);
          result = (found != NULL);
        }
      else
        result = false;
    }
  else
    result = false;
  pips_debug(9, "result = %d\n", (int) result);
  return result;
}

References ANYWHERE_LOCATION, entity_local_name(), HEAP_AREA_LOCAL_NAME, and pips_debug.

Referenced by convex_cells_inclusion_p(), convex_cells_intersection_p(), free_to_post_pv(), generic_transform_sink_cells_from_matching_list(), references_may_conflict_p(), simple_cells_inclusion_p(), and simple_cells_intersection_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_heap_location_p()

bool entity_heap_location_p

(

entity

b

)

package abstract location.

abstract_location.c

Amira Mensi 2010

File: abstract_location.c

This file contains various useful functions to modelize a heap. check if an entity b may represent a bucket or a set of buckets in the heap.

Definition at line 64 of file abstract_location.c.

{
  bool bucket_p = entity_all_heap_locations_p(b) ||
    entity_all_module_heap_locations_p(b);
 
  if(!heap_area_p(b) && !bucket_p) {
      const char* ln = entity_local_name(b);
      const char* found = strstr(ln, HEAP_AREA_LOCAL_NAME);
      bucket_p = found != NULL;
  }
 
  return bucket_p;
}

References entity_all_heap_locations_p(), entity_all_module_heap_locations_p(), entity_local_name(), HEAP_AREA_LOCAL_NAME, and heap_area_p().

Referenced by analyzable_scalar_entity_p(), cell_out_of_scope_p(), cells_to_read_or_write_effects(), clean_up_points_to_stubs(), generic_atomic_points_to_reference_p(), generic_eval_cell_with_points_to(), generic_remove_unreachable_vertices_in_points_to_graph(), module_to_value_mappings(), points_to_reference_to_typed_index(), and semantics_usable_points_to_reference_p().

Here is the call graph for this function:

Here is the caller graph for this function:

make_sensitivity_information()

sensitivity_information make_sensitivity_information	(	statement	current_stmt,
		entity	current_module,
		list	enclosing_flow
	)

Parameters

current_stmt	urrent_stmt
current_module	urrent_module
enclosing_flow	nclosing_flow

Definition at line 522 of file abstract_location.c.

{
  sensitivity_information si;
  si.current_stmt = current_stmt;
  si.current_module = current_module;
  si.enclosing_flow = enclosing_flow;
  return si;
}

References sensitivity_information::current_module, current_module, current_stmt, sensitivity_information::current_stmt, and sensitivity_information::enclosing_flow.

Referenced by flow_sensitive_malloc_to_points_to_sinks(), heap_intrinsic_to_post_pv(), and original_malloc_to_abstract_location().

Here is the caller graph for this function:

malloc_arg_to_type()

type malloc_arg_to_type

(

expression

e

)

generate the type of the allocated area from the malloc argument

Parameters

e	is the malloc argument expression

Returns

a new type (no sharing)

Store dependent types are not generated. It means that whenever the size of the allocated space is store dependent, the returned type is an array of unbounded_dimension.

which one is the sizeof operator ? try the second one first

sizeofexpression is an expression

Definition at line 187 of file abstract_location.c.

{
  type t = type_undefined;
  syntax s = expression_syntax(e);
  expression n = expression_undefined;
  sizeofexpression sizeof_exp = sizeofexpression_undefined;
  bool scalar_p = false;;
 
  pips_debug(5, "begin for expression:%s\n", expression_to_string(e));
 
  if (syntax_sizeofexpression_p(s))
    {
      scalar_p = true; // Not necessarily! An array type may be argument
      sizeof_exp = syntax_sizeofexpression(s);
    }
  else if(syntax_cast_p(s)) {
    cast c = syntax_cast(s);
    expression ce = cast_expression(c);
    t = malloc_arg_to_type(ce);
    return t; // FI: I hate doing this...
  }
  else if (syntax_call_p(s))
    {
      call c = syntax_call(s);
      entity func = call_function(c);
      list func_args = call_arguments(c);
 
      if (same_string_p(entity_local_name(func), MULTIPLY_OPERATOR_NAME))
        {
          pips_debug(5, "multiply operator found\n");
          expression arg1 = EXPRESSION(CAR(func_args));
          expression arg2 = EXPRESSION(CAR(CDR(func_args)));
 
          /* which one is the sizeof operator ? try the second one first */
          if (syntax_sizeofexpression_p(expression_syntax(arg2)))
            {
              pips_debug(5," second arg is a sizeof expression\n");
              sizeof_exp = syntax_sizeofexpression(expression_syntax(arg2));
              n = make_op_exp("-", copy_expression(arg1), int_to_expression(1));
            }
          else if (syntax_sizeofexpression_p(expression_syntax(arg1)))
            {
              pips_debug(5," first arg is a sizeof expression\n");
              sizeof_exp = syntax_sizeofexpression(expression_syntax(arg1));
              n = make_op_exp("-", copy_expression(arg2), int_to_expression(1));
            }
          else
            {
              n = make_unbounded_expression();
            }
        }
      else
        {
          n = make_op_exp("-", copy_expression(e), int_to_expression(1));
        }
    }
  else
    n = make_op_exp("-", copy_expression(e), int_to_expression(1));
 
  if (!expression_undefined_p(n) && !unbounded_expression_p(n)
      && !expression_constant_p(n))
    {
      // FI: I do not see why we cannot generate dependent types...
      // We would have to be careful to evaluate the expression in
      // case its variables are modified. Just as the parser should do.
      pips_debug(5, "non constant number of elements "
                 "-> generating unbounded dimension\n");
      free_expression(n);
      n = make_unbounded_expression();
    }
 
  if (sizeofexpression_undefined_p(sizeof_exp))
    {
      t = make_type_variable
        (make_variable(make_basic_int(DEFAULT_CHARACTER_TYPE_SIZE),
                       CONS(DIMENSION,
                            make_dimension(int_to_expression(0), n, NIL),
                            NIL),
                       NIL));
    }
  else if (sizeofexpression_type_p(sizeof_exp))
    {
      type t_sizeof_exp = sizeofexpression_type(sizeof_exp);
      variable t_var_sizeof_exp = type_variable_p(t_sizeof_exp) ?
        type_variable(t_sizeof_exp) : variable_undefined;
      pips_assert("type must be variable",
                  !variable_undefined_p(t_var_sizeof_exp));
 
      if (scalar_p)
        t = make_type_variable
          (make_variable(copy_basic(variable_basic(t_var_sizeof_exp)),
                         gen_full_copy_list(variable_dimensions
                                            (t_var_sizeof_exp)),
                         NIL));
      else
        t = make_type_variable
          (make_variable(copy_basic(variable_basic(t_var_sizeof_exp)),
                         CONS(DIMENSION,
                              make_dimension(int_to_expression(0), n, NIL),
                              gen_full_copy_list(variable_dimensions
                                                 (t_var_sizeof_exp))),
                         NIL));
    }
  else /* sizeofexpression is an expression */
    {
      type t_sizeof_exp =
        expression_to_type(sizeofexpression_expression(sizeof_exp));
      variable t_var_sizeof_exp = type_variable_p(t_sizeof_exp) ?
        type_variable(t_sizeof_exp) : variable_undefined;
 
      if (scalar_p)
        t = make_type_variable
          (make_variable(copy_basic(variable_basic( t_var_sizeof_exp)),
                         gen_full_copy_list(variable_dimensions
                                            (t_var_sizeof_exp)),
                         NIL));
      else
        t = make_type_variable
          (make_variable(copy_basic(variable_basic(t_var_sizeof_exp)),
                         CONS(DIMENSION,
                              make_dimension(int_to_expression(0), n, NIL),
                              gen_full_copy_list(variable_dimensions
                                                 (t_var_sizeof_exp))),
                         NIL));
      free_type(t_sizeof_exp);
    }
  pips_debug(5, "end with type %s\n", string_of_type(t));
  return t;
}

References call_arguments, call_function, CAR, cast_expression, CDR, CONS, copy_basic(), copy_expression(), DEFAULT_CHARACTER_TYPE_SIZE, DIMENSION, entity_local_name(), EXPRESSION, expression_constant_p(), expression_syntax, expression_to_string(), expression_to_type(), expression_undefined, expression_undefined_p, free_expression(), free_type(), gen_full_copy_list(), int_to_expression(), make_basic_int(), make_dimension(), make_op_exp(), make_type_variable(), make_unbounded_expression(), make_variable(), MULTIPLY_OPERATOR_NAME, NIL, pips_assert, pips_debug, same_string_p, sizeofexpression_expression, sizeofexpression_type, sizeofexpression_type_p, sizeofexpression_undefined, sizeofexpression_undefined_p, string_of_type(), syntax_call, syntax_call_p, syntax_cast, syntax_cast_p, syntax_sizeofexpression, syntax_sizeofexpression_p, type_undefined, type_variable, type_variable_p, unbounded_expression_p(), variable_basic, variable_dimensions, variable_undefined, and variable_undefined_p.

Referenced by malloc_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

malloc_to_abstract_location()

entity malloc_to_abstract_location	(	expression	malloc_exp,
		sensitivity_information *	psi
	)

generate an abstract heap location entity

Parameters

malloc_exp	is the argument expression of the call to malloc
psi	is a pointer towards a structure which contains context and/or flow sensitivity information

Returns

an abstract heap location entity

free_type(ct)

Parameters

malloc_exp	alloc_exp
psi	si

Definition at line 389 of file abstract_location.c.

{
  entity e = entity_undefined;
 
  pips_debug(8, "begin for expression %s\n", expression_to_string(malloc_exp));
  type t = malloc_arg_to_type(malloc_exp);
  //type ct = copy_type(compute_basic_concrete_type(t));
  //e = malloc_type_to_abstract_location(ct, psi);
  e = malloc_type_to_abstract_location(t, psi);
  free_type(t)/*, free_type(ct)*/;
  pips_debug(8, "returning entity %s of type %s\n", entity_name(e),
             string_of_type(entity_type(e)));
 
  return e;
}

References entity_name, entity_type, entity_undefined, expression_to_string(), free_type(), malloc_arg_to_type(), malloc_type_to_abstract_location(), pips_debug, and string_of_type().

Referenced by calloc_to_abstract_location(), flow_sensitive_malloc_to_points_to_sinks(), heap_intrinsic_to_post_pv(), and original_malloc_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

malloc_type_to_abstract_location()

entity malloc_type_to_abstract_location	(	type	t,
		sensitivity_information *	psi
	)

generate an abstract heap location entity

Parameters

t	is type of the allocated space
psi	is a pointer towards a structure which contains context and/or flow sensitivity information

Returns

an abstract heap location entity

in case we want an anywhere abstract heap location : the property ABSTRACT_HEAP_LOCATIONS is set to "unique" and a unique abstract location is used for all heap buckets.

in case the property ABSTRACT_HEAP_LOCATIONS is set to "insensitive": an abstract location is used for each function.

in case the property ABSTRACT_HEAP_LOCATIONS is set to "flow-sensitive" or "context-sensitive".

No difference here between the two values. The diffferent behavior will show when points-to and effects are translated at call sites

At this level, we want to use the statement number or the statement ordering. The statement ordering is safer because two statements or more can be put on the same line. The statement number is more user-friendly.

There is no need to distinguish between types since the statement ordering is at least as effective.

Parameters

psi

si

Definition at line 324 of file abstract_location.c.

{
  entity e = entity_undefined;
  const char* opt = get_string_property("ABSTRACT_HEAP_LOCATIONS");
  bool type_sensitive_p = !get_bool_property("ALIASING_ACROSS_TYPES");
 
  pips_debug(8, "begin for type %s\n",
             string_of_type(t));
  /* in case we want an anywhere abstract heap location : the property
     ABSTRACT_HEAP_LOCATIONS is set to "unique" and a unique abstract
     location is used for all heap buckets. */
  if(strcmp(opt, "unique")==0){
    if(type_sensitive_p)
      e = entity_all_heap_locations_typed(t);
    else
      e = entity_all_heap_locations();
  }
 
  /* in case the property ABSTRACT_HEAP_LOCATIONS is set to
     "insensitive": an abstract location is used for each function. */
  else if(strcmp(opt, "insensitive")==0){
    if(type_sensitive_p)
      e = entity_all_module_heap_locations_typed(psi->current_module,
                                                 copy_type(t));
    else
      e = entity_all_module_heap_locations(psi->current_module);
  }
 
  /* in case the property ABSTRACT_HEAP_LOCATIONS is set to
     "flow-sensitive" or "context-sensitive".
 
     No difference here between the two values. The diffferent
     behavior will show when points-to and effects are translated at
     call sites
 
     At this level, we want to use the statement number or the
     statement ordering. The statement ordering is safer because two
     statements or more can be put on the same line. The statement
     number is more user-friendly.
 
     There is no need to distinguish between types since the statement
     ordering is at least as effective.
  */
  else if(strcmp(opt, "flow-sensitive")==0
          || strcmp(opt, "context-sensitive")==0 )
    e = entity_flow_or_context_sentitive_heap_location
      (statement_number(psi->current_stmt),
       copy_type(t));
  else
    pips_user_error("Unrecognized value for property ABSTRACT_HEAP_LOCATION:"
                    " \"%s\"", opt);
 
  pips_debug(8, "returning entity %s of type %s\n", entity_name(e),
             string_of_type(entity_type(e)));
 
  return e;
}

References copy_type(), sensitivity_information::current_module, sensitivity_information::current_stmt, entity_all_heap_locations(), entity_all_heap_locations_typed(), entity_all_module_heap_locations(), entity_all_module_heap_locations_typed(), entity_flow_or_context_sentitive_heap_location(), entity_name, entity_type, entity_undefined, get_bool_property(), get_string_property(), pips_debug, pips_user_error, statement_number, and string_of_type().

Referenced by malloc_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

original_malloc_to_abstract_location()

reference original_malloc_to_abstract_location	(	expression lhs	__attribute__(unused),
		type __attribute__((unused))	var_t,
		type __attribute__((unused))	cast_t,
		expression	sizeof_exp,
		entity	f,
		statement	stmt
	)

to handle malloc statemennts:

p = (cast t) malloc(sizeof(expression))

This function return a reference according to the value of the property ABSTRACT_HEAP_LOCATIONS. the list of callers will be added to ensure the context sensitive property. We should keep in mind that context and sensitive properties are orthogonal and we should modify them in pipsmake.

ABSTRACT_HEAP_LOCATIONS is set to "unique" and a unique abstract

location is used for all heap buckets. *\/

if(strcmp(opt, "unique")==0){

if(type_sensitive_p) {

e = entity_all_heap_locations_typed(var_t);

r = make_reference(e , NIL);

}

else {

e = entity_all_heap_locations();

r = make_reference(e , NIL);

}

}

/* in case the property ABSTRACT_HEAP_LOCATIONS is set to

"insensitive": an abstract location is used for each function. *\/

else if(strcmp(opt, "insensitive")==0){

if(type_sensitive_p) {

e = entity_all_module_heap_locations_typed(get_current_module_entity(),

var_t);

r = make_reference(e , NIL);

}

else {

e = entity_all_module_heap_locations(f);

r = make_reference(e , NIL);

}

}

/* in case the property ABSTRACT_HEAP_LOCATIONS is set to

"flow-sensitive" or "context-sensitive".

No difference here between the two values. The diffferent

behavior will show when points-to and effects are translated at

call sites

At this level, we want to use the statement number or the

statement ordering. The statement ordering is safer because two

statements or more can be put on the same line. The statement

number is more user-friendly.

There is no need to distinguish between types since the statement

ordering is at least as effective.

*\/

else if(strcmp(opt, "flow-sensitive")==0

|| strcmp(opt, "context-sensitive")==0 ){

e = entity_flow_or_context_sentitive_heap_location(stmt_number, var_t);

r = make_reference(e , NIL);

}

else {

pips_user_error("Unrecognized value for property ABSTRACT_HEAP_LOCATION:"

" \"s"", opt);

}

pips_debug(8, "Reference to ");

Definition at line 436 of file abstract_location.c.

{
  reference r = reference_undefined;
  entity e = entity_undefined;
  sensitivity_information si =
    make_sensitivity_information(stmt,
                                 f,
                                 NIL);
  //string opt = get_string_property("ABSTRACT_HEAP_LOCATIONS");
  //bool type_sensitive_p = !get_bool_property("ALIASING_ACROSS_TYPES");
 
  e = malloc_to_abstract_location(sizeof_exp, &si);
  if(!entity_array_p(e))
    r = make_reference(e , NIL);
  else
  r = make_reference(e , CONS(EXPRESSION, int_to_expression(0), NIL));
  /* /\* in case we want an anywhere abstract heap location : the property */
/*      ABSTRACT_HEAP_LOCATIONS is set to "unique" and a unique abstract */
/*      location is used for all heap buckets. *\/ */
/*   if(strcmp(opt, "unique")==0){ */
/*     if(type_sensitive_p) { */
/*       e = entity_all_heap_locations_typed(var_t); */
/*       r = make_reference(e , NIL); */
/*     } */
/*     else { */
/*       e = entity_all_heap_locations(); */
/*       r = make_reference(e , NIL); */
/*     } */
/*   } */
 
/*   /\* in case the property ABSTRACT_HEAP_LOCATIONS is set to */
/*      "insensitive": an abstract location is used for each function. *\/ */
/*   else if(strcmp(opt, "insensitive")==0){ */
/*     if(type_sensitive_p) { */
/*       e = entity_all_module_heap_locations_typed(get_current_module_entity(), */
/*                                               var_t); */
/*       r = make_reference(e , NIL); */
/*     } */
/*     else { */
/*       e = entity_all_module_heap_locations(f); */
/*       r = make_reference(e , NIL); */
/*     } */
/*   } */
 
/*   /\* in case the property ABSTRACT_HEAP_LOCATIONS is set to */
/*      "flow-sensitive" or "context-sensitive". */
 
/*      No difference here between the two values. The diffferent */
/*      behavior will show when points-to and effects are translated at */
/*      call sites */
 
/*      At this level, we want to use the statement number or the */
/*      statement ordering. The statement ordering is safer because two */
/*      statements or more can be put on the same line. The statement */
/*      number is more user-friendly. */
 
/*      There is no need to distinguish between types since the statement */
/*      ordering is at least as effective. */
/*   *\/ */
/*   else if(strcmp(opt, "flow-sensitive")==0 */
/*        || strcmp(opt, "context-sensitive")==0 ){ */
/*     e = entity_flow_or_context_sentitive_heap_location(stmt_number, var_t); */
/*     r = make_reference(e , NIL); */
/*   } */
/*   else { */
/*     pips_user_error("Unrecognized value for property ABSTRACT_HEAP_LOCATION:" */
/*                  " \"%s\"", opt); */
/*   } */
 
/*   pips_debug(8, "Reference to "); */
 
  return r;
}

References CONS, entity_array_p(), entity_undefined, EXPRESSION, f(), int_to_expression(), make_reference(), make_sensitivity_information(), malloc_to_abstract_location(), NIL, and reference_undefined.

Here is the call graph for this function: