anywhere_abstract_locations.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 "ri-util.h"
#include "effects-util.h"
#include "misc.h"
#include "properties.h"

Include dependency graph for anywhere_abstract_locations.c:

Go to the source code of this file.

Functions
entity	entity_all_locations ()
	eturn ANY_MODULE:ANYWHERE (the top of the lattice) More...
entity	entity_anywhere_locations ()
bool	entity_all_locations_p (entity e)
	test if an entity is the top of the lattice More...
entity	entity_typed_anywhere_locations (type t)
entity	generic_entity_typed_anywhere_locations (type t)
bool	entity_anywhere_locations_p (entity e)
	test if an entity is the bottom of the lattice More...
bool	cell_typed_anywhere_locations_p (cell c)
	test if a cell is the bottom of the lattice More...
bool	reference_typed_anywhere_locations_p (reference r)
	test if a reference is the bottom of the lattice More...
bool	entity_typed_anywhere_locations_p (entity e)
	Test if an entity is the bottom of the lattice. More...
entity	entity_nowhere_locations ()
	return ANY_MODULE:NOWHERE More...
entity	entity_typed_nowhere_locations (type t)
bool	entity_nowhere_locations_p (entity e)
	test if an entity is the bottom of the lattice More...
bool	entity_typed_nowhere_locations_p (entity e)
	test if an entity is the bottom of the lattice More...
entity	entity_null_locations ()
	return TOP-LEVEL:NULL_POINTER The NULL pointer should be a global variable, unique for all modules FI: why isn't it called entity_null_location()? More...
bool	entity_null_locations_p (entity e)
	test if an entity is the NULL POINTER More...
entity	entity_all_module_locations (entity m)
	return m:ANYWHERE Set of all memory locations related to one module. More...
bool	entity_all_module_locations_p (entity e)
	test if an entity is the set of locations defined in a module More...
entity	entity_all_module_xxx_locations (entity m, const char *xxx)
	return m:xxx*ANYWHERE* Generic set of functions for all kinds of areas More...
entity	entity_all_module_xxx_locations_typed (const char *mn, const char *xxx, type t)
bool	entity_all_module_xxx_locations_p (entity e, string xxx)
	test if an entity is the set of all memory locations in the xxx area of a module. More...
entity	entity_all_xxx_locations (string xxx)
	return ANY_MODULE:xxx More...
entity	entity_all_xxx_locations_typed (string xxx, type t)
	FI->AM: the predicate entity_all_xxx_locations_typed_p() is missing... More...
bool	entity_all_xxx_locations_p (entity e, string xxx)
	test if an entity is the set of all memory locations in the xxx area of any module. More...
entity	entity_all_module_heap_locations (entity m)
	return m:*HEAP**ANYWHERE More...
entity	entity_all_module_heap_locations_typed (entity m, type t)
bool	entity_all_module_heap_locations_p (entity e)
	test if an entity is the a heap area More...
entity	entity_all_heap_locations ()
	return ANY_MODULE:HEAP More...
bool	entity_all_heap_locations_p (entity e)
	test if an entity is the set of all heap locations More...
entity	entity_all_heap_locations_typed (type t)
entity	entity_all_module_stack_locations (entity m)
	return m:*STACK**ANYWHERE More...
bool	entity_all_module_stack_locations_p (entity e)
	test if an entity is the a stack area More...
entity	entity_all_stack_locations ()
	return ANY_MODULE:STACK More...
bool	entity_all_stack_locations_p (entity e)
	test if an entity is the set of all stack locations More...
entity	entity_all_module_static_locations (entity m)
	return m:*DYNAMIC**ANYWHERE More...
bool	entity_all_module_static_locations_p (entity e)
	test if an entity is the a static area More...
entity	entity_all_static_locations ()
	return ANY_MODULE:STATIC More...
bool	entity_all_static_locations_p (entity e)
	test if an entity is the set of all static locations More...
entity	entity_all_module_dynamic_locations (entity m)
	return m:*DYNAMIC**ANYWHERE More...
bool	entity_all_module_dynamic_locations_p (entity e)
	test if an entity is the a dynamic area More...
entity	entity_all_dynamic_locations ()
	return ANY_MODULE:DYNAMIC More...
bool	entity_all_dynamic_locations_p (entity e)
	test if an entity is the set of all dynamic locations More...
bool	entity_stub_sink_p (entity e)
	test if an entity is a stub sink for a formal parameter e.g. More...
bool	stub_entity_of_module_p (entity s, entity m)
bool	entity_abstract_location_p (entity al)
entity	variable_to_abstract_location (entity v)
	returns the smallest abstract locations containing the location of variable v. More...
entity	abstract_locations_max (entity al1, entity al2)
	eturns the smallest abstract location set greater than or equalt to al1 and al2. More...
entity	entity_locations_max (entity al1, entity al2)
	Here, entity al1 and entity al2 can be program variables. More...
entity	entity_locations_dereference (entity al __attribute__((__unused__)))
	in case we need to evaluate sigma(al), i.e. More...
void	check_abstract_locations ()
	For debugging the API. More...
bool	abstract_locations_may_conflict_p (entity al1, entity al2)
	Do these two abstract locations MAY share some real memory locations ? More...
bool	abstract_locations_must_conflict_p (entity al1 __attribute__((__unused__)), entity al2 __attribute__((__unused__)))
	Do these two abstract locations MUST share some real memory locations ? Never ! DO NOT USE THIS FUNCTION UNLESS... More...
reference	make_anywhere_reference (type t)
	This function should be located somewhere in effect-util in or near abstract locations. More...
cell	make_anywhere_cell (type t)

Function Documentation

abstract_locations_max()

entity abstract_locations_max	(	entity	al1,
		entity	al2
	)

eturns the smallest abstract location set greater than or equalt to al1 and al2.

If al1 or al2 is nowhere, then return al2 or al1.

If al1 and al2 are related to the same module, the module can be preserved. Else the anywhere module must be used.

If al1 and al2 are related to the same area, then the area is preserved. Else, the anywhere area is used.

FI: The type part of the abstract location lattice is not implemented... Since the abstract locations are somewhere defined as area, they cannot carry a type. Types are taken care of for heap modelization but not more the abstract locations.

FI: we are in trouble with the NULL pointer... here al1 and al2 must be abstract locations

avoid costly string operations in trivial case

Parameters

al1	l1
al2	l2

Definition at line 766 of file anywhere_abstract_locations.c.

{
  entity e = entity_undefined;
 
  if (same_entity_p(al1, al2)) /* avoid costly string operations in trivial case */
    e = al1;
  else if(!get_bool_property("ALIASING_ACROSS_TYPES")) {
    type t1 = entity_basic_concrete_type(al1);
    type t2 = entity_basic_concrete_type(al2);
    if(!type_equal_p(t1, t2))
      e = entity_anywhere_locations();
  }
 
  if(entity_undefined_p(e)) {
    // FI: the string based tests are not reliable as there is no link
    // between suffixes and types, even within one module
    const char* ln1 = entity_local_name(al1);
    const char* ln2 = entity_local_name(al2);
    char* mn1 = strdup(entity_module_name(al1));
    char* mn2 = strdup(entity_module_name(al2));
    const char* ln;
    const char* mn;
    static int mc = 0; // Message count: to avoid multiple repetitions
 
    if(mc==0 && !get_bool_property("ALIASING_ACROSS_TYPES")) {
      //pips_internal_error("Option not implemented yet.");
      pips_user_warning("property \"ALIASING_ACROSS_TYPES\" is assumed true"
                        " for abstract locations.\n");
      mc++;
    }
 
    if(strcmp(ln1, ln2)==0)
      ln = ln1;
    else
      ln = ANYWHERE_LOCATION;
 
    if(strcmp(mn1, mn2)==0)
      mn = mn1;
    else 
      mn = ANY_MODULE_NAME;
    e = FindEntity(mn, ln);
 
    if(true || entity_undefined_p(e)) {
      if(get_bool_property("ALIASING_ACROSS_TYPES")) {
        e = entity_anywhere_locations();
      }
      else {
        type t1 = entity_type(al1);
        type t2 = entity_type(al2);
        if(type_equal_p(t1, t2))  
          e = entity_typed_anywhere_locations(t1);
        else
          e = entity_anywhere_locations();
      }
    }
 
    free(mn1);free(mn2);
  }
  return e;
}

References ANY_MODULE_NAME, ANYWHERE_LOCATION, entity_anywhere_locations(), entity_basic_concrete_type(), entity_local_name(), entity_module_name(), entity_type, entity_typed_anywhere_locations(), entity_undefined, entity_undefined_p, FindEntity(), free(), get_bool_property(), pips_user_warning, same_entity_p(), strdup(), and type_equal_p().

Referenced by abstract_locations_may_conflict_p(), convex_cells_inclusion_p(), entity_locations_max(), and simple_cells_inclusion_p().

Here is the call graph for this function:

Here is the caller graph for this function:

abstract_locations_may_conflict_p()

bool abstract_locations_may_conflict_p	(	entity	al1,
		entity	al2
	)

Do these two abstract locations MAY share some real memory locations ?

Parameters

al1	l1
al2	l2

Definition at line 989 of file anywhere_abstract_locations.c.

 {
   entity mal = abstract_locations_max(al1, al2); // maximal abstraction location
   bool conflict_p = (mal==al1) || (mal==al2);
 
   return conflict_p;
 }

References abstract_locations_max().

Referenced by add_conflicts(), and entities_maymust_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

abstract_locations_must_conflict_p()

bool abstract_locations_must_conflict_p	(	entity al1	__attribute__(__unused__),
		entity al2	__attribute__(__unused__)
	)

Do these two abstract locations MUST share some real memory locations ? Never ! DO NOT USE THIS FUNCTION UNLESS...

The function is useful in functional drivers to avoid dealing with specific cases

Definition at line 1001 of file anywhere_abstract_locations.c.

 {
 
   /* The function is useful in functional drivers to avoid dealing
      with specific cases*/
 
   //pips_internal_error("abstract_locations_must_conflict_p is a non sense : "
   //    "it's always false ! avoid use it.");
 
   return false;
 }

Referenced by entities_maymust_conflict_p().

Here is the caller graph for this function:

cell_typed_anywhere_locations_p()

bool cell_typed_anywhere_locations_p

(

cell

c

)

test if a cell is the bottom of the lattice

Definition at line 133 of file anywhere_abstract_locations.c.

{
  reference r = cell_any_reference(c);
  bool anywhere_p = reference_typed_anywhere_locations_p(r);
  return anywhere_p;
}

References cell_any_reference(), and reference_typed_anywhere_locations_p().

Referenced by binary_intrinsic_call_to_points_to_sinks(), check_type_of_points_to_cells(), compute_points_to_binded_set(), compute_points_to_gen_set(), dereferencing_subscript_to_points_to(), freeable_points_to_cells(), freed_pointer_to_points_to(), null_equal_condition_to_points_to(), offset_cells(), offset_points_to_cell(), points_to_with_stripped_sink(), print_or_dump_points_to(), source_to_sinks(), and unique_location_cell_p().

Here is the call graph for this function:

Here is the caller graph for this function:

check_abstract_locations()

void check_abstract_locations

(

void

)

For debugging the API.

top

bottom

null pointer

all locations for a given module

all heap locations for a given module

all stack locations for a given module

all static locations for a given module

all dynamic locations for a given module

all heap locations for an application

all stack locations for an application

all static locations for an application

all dynamic locations for an application

Should/could be extended to check the max computation...

Definition at line 906 of file anywhere_abstract_locations.c.

 {
   entity al = entity_undefined;
   /* top */
   al = entity_all_locations();
   fprintf(stderr, "top: %s is %s\n", entity_name(al),
           entity_all_locations_p(al)?
           "the set of all application locations" : "bug!!!");
 
   /* bottom */
   al = entity_nowhere_locations();
   fprintf(stderr, "bottom: %s is %s\n", entity_name(al),
           entity_nowhere_locations_p(al)?
           "the bottom of the abstract location lattice" : "bug!!!");
 
   /* null pointer */
   al = entity_null_locations();
   fprintf(stderr, "null: %s is %s\n", entity_name(al),
           entity_null_locations_p(al)?
           "the null pointer" : "bug!!!");
 
   /* all locations for a given module */
   al = entity_all_module_locations(get_current_module_entity());
   fprintf(stderr, "all module locations: %s is %s\n", entity_name(al),
           entity_all_module_locations_p(al)?
           "the set of all locations of a module" : "bug!!!");
 
   /* all heap locations for a given module */
   al = entity_all_module_heap_locations(get_current_module_entity());
   fprintf(stderr, "all module heap locations: %s is %s\n", entity_name(al),
           entity_all_module_heap_locations_p(al)?
           "the set of all heap locations of a module" : "bug!!!");
 
   /* all stack locations for a given module */
   al = entity_all_module_stack_locations(get_current_module_entity());
   fprintf(stderr, "all module stack locations: %s is %s\n", entity_name(al),
           entity_all_module_stack_locations_p(al)?
           "the set of all stack locations of a module" : "bug!!!");
 
   /* all static locations for a given module */
   al = entity_all_module_static_locations(get_current_module_entity());
   fprintf(stderr, "all module static locations: %s is %s\n", entity_name(al),
           entity_all_module_static_locations_p(al)?
           "the set of all static locations of a module" : "bug!!!");
 
   /* all dynamic locations for a given module */
   al = entity_all_module_dynamic_locations(get_current_module_entity());
   fprintf(stderr, "all module dynamic locations: %s is %s\n", entity_name(al),
           entity_all_module_dynamic_locations_p(al)?
           "the set of all dynamic locations of a module" : "bug!!!");
 
 
   /* all heap locations for an application */
   al = entity_all_heap_locations();
   fprintf(stderr, "all application heap locations: %s is %s\n", entity_name(al),
           entity_all_heap_locations_p(al)?
           "the set of all heap locations of an application" : "bug!!!");
 
   /* all stack locations for an application */
   al = entity_all_stack_locations();
   fprintf(stderr, "all application stack locations: %s is %s\n", entity_name(al),
           entity_all_stack_locations_p(al)?
           "the set of all stack locations of an application" : "bug!!!");
 
   /* all static locations for an application */
   al = entity_all_static_locations();
   fprintf(stderr, "all application static locations: %s is %s\n", entity_name(al),
           entity_all_static_locations_p(al)?
           "the set of all static locations of an applciation" : "bug!!!");
 
   /* all dynamic locations for an application */
   al = entity_all_dynamic_locations();
   fprintf(stderr, "all module dynamic locations: %s is %s\n", entity_name(al),
           entity_all_dynamic_locations_p(al)?
           "the set of all dynamic locations of an application" : "bug!!!");
 
   /* Should/could be extended to check the max computation... */
 }

References entity_all_dynamic_locations(), entity_all_dynamic_locations_p(), entity_all_heap_locations(), entity_all_heap_locations_p(), entity_all_locations(), entity_all_locations_p(), entity_all_module_dynamic_locations(), entity_all_module_dynamic_locations_p(), entity_all_module_heap_locations(), entity_all_module_heap_locations_p(), entity_all_module_locations(), entity_all_module_locations_p(), entity_all_module_stack_locations(), entity_all_module_stack_locations_p(), entity_all_module_static_locations(), entity_all_module_static_locations_p(), entity_all_stack_locations(), entity_all_stack_locations_p(), entity_all_static_locations(), entity_all_static_locations_p(), entity_name, entity_nowhere_locations(), entity_nowhere_locations_p(), entity_null_locations(), entity_null_locations_p(), entity_undefined, fprintf(), and get_current_module_entity().

Here is the call graph for this function:

entity_abstract_location_p()

bool entity_abstract_location_p

(

entity

al

)

Parameters

al

l

Definition at line 641 of file anywhere_abstract_locations.c.

{
#ifndef NDEBUG
  const char * en = entity_name(al);
  const char * module_sep = strchr(en,MODULE_SEP_CHAR);
  bool abstract_locations_p = (   0 == strncmp(en,ANY_MODULE_NAME,module_sep++ - en) // << FI: this may change in the future and may not be a strong enough condition
                                  ||   0 == strncmp(module_sep, ANYWHERE_LOCATION, sizeof(ANYWHERE_LOCATION)-1)
                                  ||   0 == strncmp(module_sep, STATIC_AREA_LOCAL_NAME, sizeof(STATIC_AREA_LOCAL_NAME)-1)
                                  ||   0 == strncmp(module_sep, DYNAMIC_AREA_LOCAL_NAME, sizeof(DYNAMIC_AREA_LOCAL_NAME)-1)
                                  ||   0 == strncmp(module_sep, STACK_AREA_LOCAL_NAME, sizeof(STACK_AREA_LOCAL_NAME)-1)
                                  ||   0 == strncmp(module_sep, HEAP_AREA_LOCAL_NAME, sizeof(HEAP_AREA_LOCAL_NAME)-1)
                                  ||   0 == strncmp(module_sep, FORMAL_AREA_LOCAL_NAME, sizeof(HEAP_AREA_LOCAL_NAME)-1)
                                  //                              ||   0 == strncmp(module_sep, NULL_POINTER_NAME, sizeof(NULL_POINTER_NAME)-1)
                                  )
    ;
  pips_assert("entity_kind is consistent",abstract_locations_p == ((entity_kind(al)&ABSTRACT_LOCATION)==ABSTRACT_LOCATION));
#endif
  return (entity_kind(al) & ABSTRACT_LOCATION) ? true : false;
}

References ABSTRACT_LOCATION, ANY_MODULE_NAME, ANYWHERE_LOCATION, DYNAMIC_AREA_LOCAL_NAME, entity_kind, entity_name, FORMAL_AREA_LOCAL_NAME, HEAP_AREA_LOCAL_NAME, MODULE_SEP_CHAR, pips_assert, STACK_AREA_LOCAL_NAME, STATIC_AREA_LOCAL_NAME, and true.

Referenced by add_conflicts(), add_implicit_interprocedural_write_effects(), atomic_constant_path_p(), cell_abstract_location_p(), convex_effect_to_constant_path_effects_with_pointer_values(), create_values_for_simple_effect(), effect_reference_dereferencing_p(), effects_to_dma(), entities_maymust_conflict_p(), entity_locations_max(), generic_apply_effect_to_transformer(), generic_apply_effects_to_transformer(), generic_effects_entities_which_may_conflict_with_scalar_entity(), generic_effects_maymust_read_or_write_scalar_entity_p(), generic_eval_cell_with_points_to(), generic_transform_sink_cells_from_matching_list(), memory_dereferencing_p(), module_to_value_mappings(), opgen_may_name(), opgen_must_name(), opkill_may_name(), opkill_must_name(), points_to_cell_to_upper_bound_points_to_cells(), points_to_compare_cells(), points_to_compare_ptr_cell(), references_may_conflict_p(), simple_effect_to_constant_path_effects_with_pointer_values(), strict_constant_path_p(), struct_assignment_to_points_to(), and variable_to_abstract_location().

Here is the caller graph for this function:

entity_all_dynamic_locations()

entity entity_all_dynamic_locations

(

void

)

return ANY_MODULE:DYNAMIC

Definition at line 585 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations(DYNAMIC_AREA_LOCAL_NAME);
}

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_xxx_locations().

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_dynamic_locations_p()

bool entity_all_dynamic_locations_p

(

entity

e

)

test if an entity is the set of all dynamic locations

Definition at line 591 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations_p(e, DYNAMIC_AREA_LOCAL_NAME);
}

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_xxx_locations_p().

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_heap_locations()

entity entity_all_heap_locations

(

void

)

return ANY_MODULE:HEAP

FI->AM: I move it to ANY_MODULE:HEAP**ANYWHERE

Not compatible with entity_all_locations_p()...

Definition at line 494 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations(HEAP_AREA_LOCAL_NAME ANYWHERE_LOCATION);
}

References ANYWHERE_LOCATION, entity_all_xxx_locations(), and HEAP_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_heap_locations_p()

bool entity_all_heap_locations_p

(

entity

e

)

test if an entity is the set of all heap locations

We look for "*ANY_MODULE*:*HEAP**ANYWHERE*"... unless it is "foo:*HEAP**ANYWHERE*"

FI->AM: this is not compatible with the entity name ANY-MODULE:HEAP

Definition at line 505 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations_p(e, HEAP_AREA_LOCAL_NAME);
}

References entity_all_xxx_locations_p(), and HEAP_AREA_LOCAL_NAME.

Referenced by all_heap_locations_cell_p(), check_abstract_locations(), entity_heap_location_p(), heap_intrinsic_to_post_pv(), reference_add_field_dimension(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_heap_locations_typed()

entity entity_all_heap_locations_typed

(

type

t

)

Definition at line 510 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations_typed(HEAP_AREA_LOCAL_NAME, t);
}

References entity_all_xxx_locations_typed(), and HEAP_AREA_LOCAL_NAME.

Referenced by malloc_type_to_abstract_location(), and reference_add_field_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_locations()

entity entity_all_locations

(

void

)

eturn ANY_MODULE:ANYWHERE (the top of the lattice)

anywhere_abstract_locations.c

FI->aM: it was first decided to make this entity an area, but areas cannot be typed. So the internal representation must be changed to carry a type usable according to ALIAS_ACROSS_TYPES. The top of the location lattice should use overloaded as type, that is the top of the type lattice.

Size and layout are unknown

Definition at line 68 of file anywhere_abstract_locations.c.

{
  entity anywhere = entity_undefined;
  static const char any_name[] =
    ANY_MODULE_NAME MODULE_SEP_STRING  ANYWHERE_LOCATION;
  anywhere = gen_find_tabulated(any_name, entity_domain);
  if(entity_undefined_p(anywhere)) {
    area a = make_area(0,NIL); /* Size and layout are unknown */
    type t = make_type_area(a);
    anywhere = make_entity(strdup(any_name),
                           t,
                           make_storage_rom(),
                           make_value_unknown());
    entity_kind(anywhere)=ABSTRACT_LOCATION;
  }
 
  return anywhere;
}

References ABSTRACT_LOCATION, ANY_MODULE_NAME, ANYWHERE_LOCATION, entity_domain, entity_kind, entity_undefined, entity_undefined_p, gen_find_tabulated(), make_area(), make_entity, make_storage_rom(), make_type_area(), make_value_unknown(), MODULE_SEP_STRING, NIL, and strdup().

Referenced by anywhere_effect(), check_abstract_locations(), entity_anywhere_locations(), entity_anywhere_locations_p(), entity_locations_dereference(), generic_entity_typed_anywhere_locations(), make_anywhere_anywhere_pvs(), make_anywhere_points_to_cell(), max_module(), module_initial_parameter_pv(), and points_to_anywhere_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_locations_p()

bool entity_all_locations_p

(

entity

e

)

test if an entity is the top of the lattice

This test does not take typed anywhere into account. This is consistent with the function name, but may be not with its uses.

It is not consistent with hiding the impact of ALIASING_ACROSS_TYPES from callers.

Definition at line 100 of file anywhere_abstract_locations.c.

{
 
  bool anywhere_p;
  anywhere_p = same_string_p(entity_local_name(e), ANYWHERE_LOCATION);
  anywhere_p = anywhere_p
    && same_string_p(entity_module_name(e), ANY_MODULE_NAME);
 
  return anywhere_p;
}

References ANY_MODULE_NAME, ANYWHERE_LOCATION, entity_local_name(), entity_module_name(), and same_string_p.

Referenced by anywhere_cell_p(), anywhere_reference_p(), c_convex_effects_on_formal_parameter_backward_translation(), check_abstract_locations(), effect_reference_dereferencing_p(), entities_maymust_conflict_p(), generic_anywhere_effect_p(), interference_on(), loop_variant_list(), opkill_may_name(), opkill_must_name(), pvs_union_combinable_p(), references_may_conflict_p(), simple_pv_may_union(), simple_pv_must_union(), simple_pv_translate(), strict_constant_path_p(), and TestCoupleOfReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_dynamic_locations()

entity entity_all_module_dynamic_locations

(

entity

m

)

return m:*DYNAMIC**ANYWHERE

Definition at line 573 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations(m, DYNAMIC_AREA_LOCAL_NAME);
}

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_module_xxx_locations().

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_dynamic_locations_p()

bool entity_all_module_dynamic_locations_p

(

entity

e

)

test if an entity is the a dynamic area

Definition at line 579 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations_p(e, DYNAMIC_AREA_LOCAL_NAME);
}

References DYNAMIC_AREA_LOCAL_NAME, and entity_all_module_xxx_locations_p().

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_heap_locations()

entity entity_all_module_heap_locations

(

entity

m

)

return m:*HEAP**ANYWHERE

Definition at line 471 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations(m, HEAP_AREA_LOCAL_NAME);
}

References entity_all_module_xxx_locations(), and HEAP_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_heap_locations_p()

bool entity_all_module_heap_locations_p

(

entity

e

)

test if an entity is the a heap area

Definition at line 483 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations_p(e, HEAP_AREA_LOCAL_NAME);
}

References entity_all_module_xxx_locations_p(), and HEAP_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), entity_heap_location_p(), heap_intrinsic_to_post_pv(), reference_add_field_dimension(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_heap_locations_typed()

entity entity_all_module_heap_locations_typed	(	entity	m,
		type	t
	)

Definition at line 476 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations_typed(entity_local_name(m),
                                               HEAP_AREA_LOCAL_NAME, t);
}

References entity_all_module_xxx_locations_typed(), entity_local_name(), and HEAP_AREA_LOCAL_NAME.

Referenced by malloc_type_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_locations()

entity entity_all_module_locations

(

entity

m

)

return m:ANYWHERE Set of all memory locations related to one module.

FI: This may prove useless unless the compilation unit is taken into account.

Size and layout are unknown

FI: any_name?

Definition at line 265 of file anywhere_abstract_locations.c.

{
  entity anywhere = entity_undefined;
  const char* mn = entity_local_name(m);
 
  anywhere = FindEntity(mn,ANYWHERE_LOCATION);
  if(entity_undefined_p(anywhere)) {
    area a = make_area(0,NIL); /* Size and layout are unknown */
    type t = make_type_area(a);
    /* FI: any_name? */
    anywhere = CreateEntity(mn,ANYWHERE_LOCATION);
    entity_type(anywhere)=t;
    entity_storage(anywhere)=make_storage_rom();
    entity_initial(anywhere)=make_value_unknown();
    entity_kind(anywhere)=ABSTRACT_LOCATION;
  }
 
  return anywhere;
}

References ABSTRACT_LOCATION, ANYWHERE_LOCATION, CreateEntity(), entity_initial, entity_kind, entity_local_name(), entity_storage, entity_type, entity_undefined, entity_undefined_p, FindEntity(), make_area(), make_storage_rom(), make_type_area(), make_value_unknown(), and NIL.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_locations_p()

bool entity_all_module_locations_p

(

entity

e

)

test if an entity is the set of locations defined in a module

Definition at line 286 of file anywhere_abstract_locations.c.

{
 
  bool all_module_p;
  all_module_p = same_string_p(entity_local_name(e), ANYWHERE_LOCATION);
 
  return all_module_p;
}

References ANYWHERE_LOCATION, entity_local_name(), and same_string_p.

Referenced by apply_abstract_effect_to_transformer(), check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_stack_locations()

entity entity_all_module_stack_locations

(

entity

m

)

return m:*STACK**ANYWHERE

Definition at line 523 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations(m, STACK_AREA_LOCAL_NAME);
}

References entity_all_module_xxx_locations(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_stack_locations_p()

bool entity_all_module_stack_locations_p

(

entity

e

)

test if an entity is the a stack area

Definition at line 529 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations_p(e, STACK_AREA_LOCAL_NAME);
}

References entity_all_module_xxx_locations_p(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_static_locations()

entity entity_all_module_static_locations

(

entity

m

)

return m:*DYNAMIC**ANYWHERE

Definition at line 548 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations(m, STATIC_AREA_LOCAL_NAME);
}

References entity_all_module_xxx_locations(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_static_locations_p()

bool entity_all_module_static_locations_p

(

entity

e

)

test if an entity is the a static area

Definition at line 554 of file anywhere_abstract_locations.c.

{
  return entity_all_module_xxx_locations_p(e, STATIC_AREA_LOCAL_NAME);
}

References entity_all_module_xxx_locations_p(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_xxx_locations()

entity entity_all_module_xxx_locations	(	entity	m,
		const char *	xxx
	)

return m:xxx*ANYWHERE* Generic set of functions for all kinds of areas

Size and layout are unknown

I: more work to be done here...

Parameters

xxx

xx

Definition at line 299 of file anywhere_abstract_locations.c.

{
  entity dynamic = entity_undefined;
  string any_name;
  asprintf(&any_name, "%s" ANYWHERE_LOCATION, xxx);
 
  //dynamic = gen_find_tabulated(any_name, entity_domain);
  dynamic = FindOrCreateEntity(entity_local_name(m), any_name);
  if(storage_undefined_p(entity_storage(dynamic))) {
    area a = make_area(0,NIL); /* Size and layout are unknown */
    type t = make_type_area(a);
    /*FI: more work to be done here... */
    entity_type(dynamic) = t;
    entity_storage(dynamic) = make_storage_rom();
    entity_initial(dynamic) = make_value_unknown();
    entity_kind(dynamic)=ABSTRACT_LOCATION;
  }
  free(any_name);
 
  return dynamic;
}

References ABSTRACT_LOCATION, ANYWHERE_LOCATION, asprintf, entity_initial, entity_kind, entity_local_name(), entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), free(), make_area(), make_storage_rom(), make_type_area(), make_value_unknown(), NIL, and storage_undefined_p.

Referenced by entity_all_module_dynamic_locations(), entity_all_module_heap_locations(), entity_all_module_stack_locations(), entity_all_module_static_locations(), and variable_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_xxx_locations_p()

bool entity_all_module_xxx_locations_p	(	entity	e,
		string	xxx
	)

test if an entity is the set of all memory locations in the xxx area of a module.

The module is not checked, so it can be the set of all modules...

Parameters

xxx

xx

Definition at line 366 of file anywhere_abstract_locations.c.

{
  bool dynamic_p;
  string s = concatenate(xxx, ANYWHERE_LOCATION, NULL);
 
  pips_assert("e is defined", !entity_undefined_p(e));
 
  dynamic_p = same_string_p(entity_local_name(e), s);
 
  return dynamic_p;
}

References ANYWHERE_LOCATION, concatenate(), entity_local_name(), entity_undefined_p, pips_assert, and same_string_p.

Referenced by entity_all_module_dynamic_locations_p(), entity_all_module_heap_locations_p(), entity_all_module_stack_locations_p(), and entity_all_module_static_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_module_xxx_locations_typed()

entity entity_all_module_xxx_locations_typed	(	const char *	mn,
		const char *	xxx,
		type	t
	)

A new entity has been created

I: more work to be done here...

no aliasing

Parameters

mn	n
xxx	xx

Definition at line 321 of file anywhere_abstract_locations.c.

{
  entity e = entity_undefined;
  int count = 0;
  bool found_p = false; // a break could be used instead
 
  pips_assert("Type t is defined", !type_undefined_p(t));
 
  for(count = 0; !found_p; count++) {
 
    type ot = type_undefined;
    char * local_name;
 
    asprintf(&local_name, "%s_b%d", xxx,count);
    e = FindOrCreateEntity(mn,local_name);
    free(local_name);
    ot = entity_type(e);
    if(type_undefined_p(ot)) {
      /* A new entity has been created */
      //area a = make_area(0,NIL); /* Size and layout are unknown */
      //type t = make_type_area(a);
      /*FI: more work to be done here... */
      entity_type(e) = copy_type(t); /* no aliasing */
      entity_storage(e) = make_storage_rom();
      entity_initial(e) = make_value_unknown();
      found_p = true;
 
    }
    else if(type_equal_p(t, ot))
      found_p = true;
  }
 
  // FI: the debug message should be improved with full information
  // about the type... See get_symbol_table() and isolate the code
  // used to prettyprint the type. Too bad it uses the buffer type...
  pips_debug(8, "New abstract location entity \"%s\" found or created"
             " with type \"%s\"\n", entity_name(e), type_to_string(t));
 
  return e;
}

References asprintf, copy_type(), count, entity_initial, entity_name, entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), free(), local_name(), make_storage_rom(), make_value_unknown(), pips_assert, pips_debug, type_equal_p(), type_to_string(), type_undefined, and type_undefined_p.

Referenced by entity_all_module_heap_locations_typed(), and variable_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_stack_locations()

entity entity_all_stack_locations

(

void

)

return ANY_MODULE:STACK

Definition at line 535 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations(STACK_AREA_LOCAL_NAME);
}

References entity_all_xxx_locations(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_stack_locations_p()

bool entity_all_stack_locations_p

(

entity

e

)

test if an entity is the set of all stack locations

Definition at line 541 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations_p(e, STACK_AREA_LOCAL_NAME);
}

References entity_all_xxx_locations_p(), and STACK_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_static_locations()

entity entity_all_static_locations

(

void

)

return ANY_MODULE:STATIC

Definition at line 560 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations(STATIC_AREA_LOCAL_NAME);
}

References entity_all_xxx_locations(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_static_locations_p()

bool entity_all_static_locations_p

(

entity

e

)

test if an entity is the set of all static locations

Definition at line 566 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations_p(e, STATIC_AREA_LOCAL_NAME);
}

References entity_all_xxx_locations_p(), and STATIC_AREA_LOCAL_NAME.

Referenced by check_abstract_locations(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_xxx_locations()

entity entity_all_xxx_locations

(

string

xxx

)

return ANY_MODULE:xxx

I: more work to be done here...

FI: I'd like to make the type variable, overloaded,...

Parameters

xxx

xx

Definition at line 379 of file anywhere_abstract_locations.c.

{
  entity dynamic = entity_undefined;
  dynamic = FindOrCreateEntity(ANY_MODULE_NAME,xxx);
 
  if(type_undefined_p(entity_type(dynamic))) {
    //area a = make_area(0,NIL); /* Size and layout are unknown */
    //type t = make_type_area(a);
    /*FI: more work to be done here... */
    /* FI: I'd like to make the type variable, overloaded,... */
    // entity_type(dynamic) = make_type_unknown();
    basic b = make_basic_overloaded();
    variable v = make_variable(b, NIL, NIL);
    entity_type(dynamic) = make_type_variable(v);
    entity_storage(dynamic) = make_storage_rom();
    entity_initial(dynamic) = make_value_unknown();
    entity_kind(dynamic)=ABSTRACT_LOCATION;
    if(same_string_p(xxx,HEAP_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_HEAP_AREA;
    else if(same_string_p(xxx,STACK_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_STACK_AREA;
    else if(same_string_p(xxx,STATIC_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_STATIC_AREA;
    else if(same_string_p(xxx,DYNAMIC_AREA_LOCAL_NAME)) entity_kind(dynamic)|=ENTITY_DYNAMIC_AREA;
  }
 
  return dynamic;
}

References ABSTRACT_LOCATION, ANY_MODULE_NAME, DYNAMIC_AREA_LOCAL_NAME, ENTITY_DYNAMIC_AREA, ENTITY_HEAP_AREA, entity_initial, entity_kind, ENTITY_STACK_AREA, ENTITY_STATIC_AREA, entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), HEAP_AREA_LOCAL_NAME, make_basic_overloaded(), make_storage_rom(), make_type_variable(), make_value_unknown(), make_variable(), NIL, same_string_p, STACK_AREA_LOCAL_NAME, STATIC_AREA_LOCAL_NAME, and type_undefined_p.

Referenced by application_to_points_to_sinks(), entity_all_dynamic_locations(), entity_all_heap_locations(), entity_all_stack_locations(), entity_all_static_locations(), make_anywhere_reference(), make_nowhere_cell(), points_to_anywhere(), and user_call_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_xxx_locations_p()

bool entity_all_xxx_locations_p	(	entity	e,
		string	xxx
	)

test if an entity is the set of all memory locations in the xxx area of any module.

FI->AM: how come w generate HEAP and we check HEAP**ANYWHERE?

Parameters

xxx

xx

Definition at line 456 of file anywhere_abstract_locations.c.

{
  bool dynamic_p;
  string s = concatenate(xxx, ANYWHERE_LOCATION, NULL);
 
  dynamic_p = same_string_p(entity_local_name(e), s);
  dynamic_p = dynamic_p
    && same_string_p(entity_module_name(e), ANY_MODULE_NAME);
 
  return dynamic_p;
}

References ANY_MODULE_NAME, ANYWHERE_LOCATION, concatenate(), entity_local_name(), entity_module_name(), and same_string_p.

Referenced by entity_all_dynamic_locations_p(), entity_all_heap_locations_p(), entity_all_stack_locations_p(), and entity_all_static_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_all_xxx_locations_typed()

entity entity_all_xxx_locations_typed	(	string	xxx,
		type	t
	)

FI->AM: the predicate entity_all_xxx_locations_typed_p() is missing...

A new entity has been created

I: more work to be done here...

Parameters

xxx

xx

Definition at line 406 of file anywhere_abstract_locations.c.

{
  entity e = entity_undefined;
  int count = 0;
  bool found_p = false; // a break could be used instead
 
  pips_assert("Type t is defined", !type_undefined_p(t));
  pips_assert("Type t is not functional", !type_functional_p(t));
 
  for(count = 0; !found_p; count++) {
    string name = string_undefined;
    type ot = type_undefined;
 
    asprintf(&name, "%s_b%d", xxx, count);
    e = FindOrCreateEntity(ANY_MODULE_NAME, name);
    free(name);
    ot = entity_type(e);
    if(type_undefined_p(ot)) {
      /* A new entity has been created */
      //area a = make_area(0,NIL); /* Size and layout are unknown */
      //type t = make_type_area(a);
      /*FI: more work to be done here... */
      entity_type(e) = copy_type(t);
      entity_storage(e) = make_storage_rom();
      entity_initial(e) = make_value_unknown();
      entity_kind(e) = ABSTRACT_LOCATION;
      found_p = true;
    }
    else if(type_equal_p(t, ot)) // FI: do we want to relax this test?
      found_p = true;
  }
 
  // FI: the debug message should be improved with full information
  // about the type... See get_symbol_table() and isolate the code
  // used to prettyprint the type. Too bad it uses the buffer type...
  ifdebug(8) {
    pips_debug(8, "New abstract location entity \"%s\" found or created"
               " with type ", entity_name(e));
    print_type(t);
    fprintf(stderr, "\n");
  }
 
  return e;
}

References ABSTRACT_LOCATION, ANY_MODULE_NAME, asprintf, copy_type(), count, entity_initial, entity_kind, entity_name, entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), fprintf(), free(), ifdebug, make_storage_rom(), make_value_unknown(), pips_assert, pips_debug, print_type(), string_undefined, type_equal_p(), type_functional_p, type_undefined, and type_undefined_p.

Referenced by application_to_points_to_sinks(), entity_all_heap_locations_typed(), entity_typed_anywhere_locations(), entity_typed_nowhere_locations(), generic_entity_typed_anywhere_locations(), make_anywhere_points_to_cell(), make_anywhere_reference(), make_typed_nowhere_cell(), points_to_anywhere_typed(), and user_call_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_anywhere_locations()

entity entity_anywhere_locations

(

void

)

Definition at line 87 of file anywhere_abstract_locations.c.

{
  return entity_all_locations();
}

References entity_all_locations().

Referenced by abstract_locations_max(), anywhere_source_to_sinks(), remove_arcs_from_pt_map(), and source_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_anywhere_locations_p()

bool entity_anywhere_locations_p

(

entity

e

)

test if an entity is the bottom of the lattice

Definition at line 127 of file anywhere_abstract_locations.c.

{
    return same_entity_p(e, entity_all_locations());
}

References entity_all_locations(), and same_entity_p().

Referenced by entities_maymust_conflict_p(), generic_atomic_points_to_reference_p(), module_to_value_mappings(), points_to_cell_translation(), reference_add_field_dimension(), semantics_usable_points_to_reference_p(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_locations_dereference()

entity entity_locations_dereference

(

entity al

__attribute__(__unused__)

)

in case we need to evaluate sigma(al), i.e.

the locations pointed by al, return the top of the lattice. Of course, this function should be avoided as much as possible.

Definition at line 898 of file anywhere_abstract_locations.c.

{
  entity e = entity_undefined;
  e = entity_all_locations();
  return e;
}

References entity_all_locations(), and entity_undefined.

Here is the call graph for this function:

entity_locations_max()

entity entity_locations_max	(	entity	al1,
		entity	al2
	)

Here, entity al1 and entity al2 can be program variables.

Both al1 and al2 are abstract locations and they are different

al1 and al2 are assumed to be variables

Parameters

al1	l1
al2	l2

Definition at line 829 of file anywhere_abstract_locations.c.

{
  entity e = entity_undefined;
  //string ln1 = entity_local_name(al1);
  //string ln2 = entity_local_name(al2);
 
  if(al1==al2) {
    e = al1;
  }
  else {
    bool al1_abstract_location_p = entity_abstract_location_p(al1);
    bool al2_abstract_location_p = entity_abstract_location_p(al2);
    if(al1_abstract_location_p )
      if(al2_abstract_location_p ) {
        /* Both al1 and al2 are abstract locations and they are
           different */
        e = abstract_locations_max(al1, al2);
      }
      else {
        entity al = variable_to_abstract_location(al2);
        e = abstract_locations_max(al1, al);
      }
    else
      if(al2_abstract_location_p) {
        entity al = variable_to_abstract_location(al1);
        e = abstract_locations_max(al, al2);
      }
      else {
        /* al1 and al2 are assumed to be variables */
        storage s1 = entity_storage(al1);
        storage s2 = entity_storage(al2);
 
        if(storage_ram_p(s1) && storage_ram_p(s2)) {
          ram r1 = storage_ram(s1);
          ram r2 = storage_ram(s2);
          entity f1 = ram_function(r1);
          entity f2 = ram_function(r2);
          entity a1 = ram_section(r1);
          entity a2 = ram_section(r2);
          const char* mn ;
          const char* ln ;
 
          if(f1==f2)
            mn = entity_local_name(f1);
          else
            mn = ANY_MODULE_NAME;
 
          if(static_area_p(a1) && static_area_p(a2))
            ln = STATIC_AREA_LOCAL_NAME;
          else if(dynamic_area_p(a1) && dynamic_area_p(a2))
            ln = DYNAMIC_AREA_LOCAL_NAME;
          else if(stack_area_p(a1) && stack_area_p(a2))
            ln = STACK_AREA_LOCAL_NAME;
          else if(heap_area_p(a1) && heap_area_p(a2))
            ln = HEAP_AREA_LOCAL_NAME;
          else
            ln = ANYWHERE_LOCATION;
          e = FindEntity(mn, ln);
        }
        else
          pips_internal_error("not implemented");
      }
  }
  return e;
}

References abstract_locations_max(), ANY_MODULE_NAME, ANYWHERE_LOCATION, DYNAMIC_AREA_LOCAL_NAME, dynamic_area_p(), entity_abstract_location_p(), entity_local_name(), entity_storage, entity_undefined, f2(), FindEntity(), HEAP_AREA_LOCAL_NAME, heap_area_p(), pips_internal_error, ram_function, ram_section, s1, STACK_AREA_LOCAL_NAME, stack_area_p(), STATIC_AREA_LOCAL_NAME, static_area_p(), storage_ram, storage_ram_p, and variable_to_abstract_location().

Referenced by effect_may_union(), effect_must_union(), and region_union().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_nowhere_locations()

entity entity_nowhere_locations

(

void

)

return ANY_MODULE:NOWHERE

Size and layout are unknown

Definition at line 174 of file anywhere_abstract_locations.c.

{
  static entity nowhere = entity_undefined;
  static const char any_name [] = ANY_MODULE_NAME MODULE_SEP_STRING NOWHERE_LOCATION ;
  nowhere = gen_find_tabulated(any_name, entity_domain);
  if(entity_undefined_p(nowhere)) {
      area a = make_area(0,NIL); /* Size and layout are unknown */
      type t = make_type_area(a);
      nowhere = make_entity(strdup(any_name),
              t, make_storage_rom(), make_value_unknown());
      entity_kind(nowhere)=ABSTRACT_LOCATION;
      register_static_entity(&nowhere);
  }
 
   return nowhere;
}

References ABSTRACT_LOCATION, ANY_MODULE_NAME, entity_domain, entity_kind, entity_undefined, entity_undefined_p, gen_find_tabulated(), make_area(), make_entity, make_storage_rom(), make_type_area(), make_value_unknown(), MODULE_SEP_STRING, NIL, NOWHERE_LOCATION, register_static_entity(), and strdup().

Referenced by check_abstract_locations(), and entity_nowhere_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_nowhere_locations_p()

bool entity_nowhere_locations_p

(

entity

e

)

test if an entity is the bottom of the lattice

Should we care for the typed nowhere too?

Definition at line 200 of file anywhere_abstract_locations.c.

{
    return same_entity_p(e,entity_nowhere_locations());
}

References entity_nowhere_locations(), and same_entity_p().

Referenced by check_abstract_locations(), gen_may_set(), gen_must_set(), opkill_may_name(), opkill_must_name(), reference_add_field_dimension(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_null_locations()

entity entity_null_locations

(

void

)

return TOP-LEVEL:NULL_POINTER The NULL pointer should be a global variable, unique for all modules FI: why isn't it called entity_null_location()?

Since NULL is a constant, it should be declared as a function. But then it cold not be used in a reference for the points-to analysis. Too bad for the semantics analysis of pointers were a constant 0-ary function would make more sense.

Size and layout are unknown

Definition at line 223 of file anywhere_abstract_locations.c.

{
  static entity null_pointer = entity_undefined;
  if(entity_undefined_p(null_pointer)) {
    if(true) {
      const char null_name [] = TOP_LEVEL_MODULE_NAME MODULE_SEP_STRING NULL_POINTER_NAME;
      area a = make_area(0,NIL); /* Size and layout are unknown */
      type t = make_type_area(a);
      null_pointer = make_entity(strdup(null_name),
                                 t, make_storage_rom(), make_value_unknown());
      // FI: I do not see why NULL should be an abstract location; it
      // does not represent a set of locations, but a unique one
      // entity_kind(null_pointer) = ABSTRACT_LOCATION;
      entity_kind(null_pointer) = DEFAULT_ENTITY_KIND;
    }
    else {
      entity null_pointer = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME,
                                               NULL_POINTER_NAME);
      type rt = type_to_pointer_type(make_type_void(NIL));
      type ft = make_type_functional(make_functional(NIL, copy_type(rt)));
      entity_type(null_pointer) = ft;
      entity_storage(null_pointer) = make_storage_rom();
      entity_initial(null_pointer) = make_value_constant(make_constant_int(0));
    }
    register_static_entity(&null_pointer);
  }
 
  return null_pointer;
}

References copy_type(), DEFAULT_ENTITY_KIND, entity_initial, entity_kind, entity_storage, entity_type, entity_undefined, entity_undefined_p, FindOrCreateEntity(), make_area(), make_constant_int(), make_entity, make_functional(), make_storage_rom(), make_type_area(), make_type_functional(), make_type_void(), make_value_constant(), make_value_unknown(), MODULE_SEP_STRING, NIL, NULL_POINTER_NAME, register_static_entity(), strdup(), TOP_LEVEL_MODULE_NAME, and type_to_pointer_type().

Referenced by check_abstract_locations(), entity_null_locations_p(), make_null_cell(), null_pointer_value_entity(), and points_to_null_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_null_locations_p()

bool entity_null_locations_p

(

entity

e

)

test if an entity is the NULL POINTER

Definition at line 254 of file anywhere_abstract_locations.c.

{
    return same_entity_p(e,entity_null_locations());
}

References entity_null_locations(), and same_entity_p().

Referenced by any_basic_update_to_transformer(), any_update_to_transformer(), atomic_constant_path_p(), check_abstract_locations(), entities_maymust_conflict_p(), gen_may_set(), gen_must_set(), generic_atomic_points_to_reference_p(), generic_transform_sink_cells_from_matching_list(), null_cell_p(), null_pointer_value_entity_p(), opkill_may_name(), opkill_must_name(), points_to_unary_operation_to_transformer(), reference_add_field_dimension(), references_may_conflict_p(), semantics_usable_points_to_reference_p(), strict_constant_path_p(), transformer_internal_consistency_p(), and variable_to_abstract_location().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_stub_sink_p()

bool entity_stub_sink_p

(

entity

e

)

test if an entity is a stub sink for a formal parameter e.g.

f->_f_1, EXACT

Definition at line 599 of file anywhere_abstract_locations.c.

{
  bool stub_sink_p = false;
  bool dummy_target_p = false;
  const char * en = entity_local_name(e);
  storage s = entity_storage(e);
  if(storage_ram_p(s)) {
    // dummy_target_p = pointer_dummy_targets_area_p(ram_section(storage_ram(s)));
    dummy_target_p = formal_area_p(ram_section(storage_ram(s)));
  }
  char first = en[0];
  //char penultimate = en[strlen(en) - 2];
  int l = strlen(en);
  if(dummy_target_p && first == '_') {
    int i = 1;
    while('0' <=en[l-i] && en[l-i]<='9') {
      i++;
    }
    if(i>=2 && en[l-i]=='_')
      stub_sink_p = true;
  }
 
  return stub_sink_p;
}

References entity_local_name(), entity_storage, formal_area_p(), ram_section, storage_ram, and storage_ram_p.

Referenced by cell_out_of_scope_p(), create_stub_entity(), expand_points_to_domain(), generic_atomic_points_to_reference_p(), generic_points_to_set_to_stub_cell_list(), generic_remove_unreachable_vertices_in_points_to_graph(), generic_transformer_to_analyzed_locations(), reference_to_points_to(), source_to_sinks(), strict_constant_path_p(), stub_entity_of_module_p(), stub_points_to_cell_p(), subscript_to_points_to_sinks(), and transformer_general_consistency_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_typed_anywhere_locations()

entity entity_typed_anywhere_locations

(

type

t

)

Definition at line 111 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations_typed(ANYWHERE_LOCATION, t);
}

References ANYWHERE_LOCATION, and entity_all_xxx_locations_typed().

Referenced by abstract_locations_max(), binary_intrinsic_call_to_points_to_sinks(), cells_to_read_or_write_effects(), points_to_anywhere_sinks(), and reference_add_field_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_typed_anywhere_locations_p()

bool entity_typed_anywhere_locations_p

(

entity

e

)

Test if an entity is the bottom of the lattice.

Not really since it is typed...

The typed anywhere locations have names like ANYWHERE_LOCATION_bxxx

Beware, because the string ANYWHERE_LOCATION is also used for the heap, HEAP**ANYWHERE.

Also, this does not check for the module: is it ANYMODULE or a specific module?

Definition at line 160 of file anywhere_abstract_locations.c.

{
  bool typed_anywhere_p = false;
  string ln = (string) entity_local_name(e);
  string p = strstr(ln, ANYWHERE_LOCATION);
  if(p==ln) {
    // if the two strings are equal, we have the non-typed anywhere location
    typed_anywhere_p = strcmp(ln, ANYWHERE_LOCATION);
  }
  return typed_anywhere_p;
}

References ANYWHERE_LOCATION, and entity_local_name().

Referenced by analyzable_scalar_entity_p(), cells_to_read_or_write_effects(), effect_reference_dereferencing_p(), generic_anywhere_effect_p(), generic_atomic_points_to_reference_p(), module_to_value_mappings(), points_to_cell_translation(), reference_add_field_dimension(), reference_typed_anywhere_locations_p(), semantics_usable_points_to_reference_p(), source_to_sinks(), and strict_constant_path_p().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_typed_nowhere_locations()

entity entity_typed_nowhere_locations

(

type

t

)

Definition at line 191 of file anywhere_abstract_locations.c.

{
  return entity_all_xxx_locations_typed(NOWHERE_LOCATION, t);
}

References entity_all_xxx_locations_typed(), and NOWHERE_LOCATION.

Here is the call graph for this function:

entity_typed_nowhere_locations_p()

bool entity_typed_nowhere_locations_p

(

entity

e

)

test if an entity is the bottom of the lattice

Definition at line 206 of file anywhere_abstract_locations.c.

{
  string ln = (string) entity_local_name(e);
  string p = strstr(ln, NOWHERE_LOCATION);
  return p!=NULL;
}

References entity_local_name(), and NOWHERE_LOCATION.

Referenced by any_basic_update_to_transformer(), any_update_to_transformer(), gen_may_set(), gen_must_set(), generic_atomic_points_to_reference_p(), nowhere_cell_p(), points_to_unary_operation_to_transformer(), reference_add_field_dimension(), semantics_usable_points_to_reference_p(), strict_constant_path_p(), and text_points_to_relation().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_entity_typed_anywhere_locations()

entity generic_entity_typed_anywhere_locations

(

type

t

)

Definition at line 116 of file anywhere_abstract_locations.c.

{
  entity a = entity_undefined;
  if(get_bool_property("ALIASING_ACROSS_TYPES"))
    a = entity_all_locations();
  else
    a = entity_all_xxx_locations_typed(ANYWHERE_LOCATION, t);
  return a;
}

References ANYWHERE_LOCATION, entity_all_locations(), entity_all_xxx_locations_typed(), entity_undefined, and get_bool_property().

Here is the call graph for this function:

make_anywhere_cell()

cell make_anywhere_cell

(

type

t

)

Definition at line 1028 of file anywhere_abstract_locations.c.

{
  reference r = make_anywhere_reference(t);
  cell sc = make_cell_reference(r);
  return sc;
}

References make_anywhere_reference(), and make_cell_reference().

Referenced by binary_intrinsic_call_to_points_to_sinks(), generic_transform_sink_cells_from_matching_list(), k_limit_points_to(), sizeofexpression_to_points_to_sinks(), source_to_sinks(), struct_assignment_to_points_to(), struct_initialization_to_points_to(), unary_intrinsic_call_to_points_to_sinks(), and use_default_sink_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

make_anywhere_reference()

reference make_anywhere_reference

(

type

t

)

This function should be located somewhere in effect-util in or near abstract locations.

Definition at line 1016 of file anywhere_abstract_locations.c.

{
  bool type_sensitive_p = !get_bool_property("ALIASING_ACROSS_TYPES");
  entity anywhere = type_sensitive_p?
    entity_all_xxx_locations_typed(ANYWHERE_LOCATION, t)
    :
    entity_all_xxx_locations(ANYWHERE_LOCATION);
 
  reference r = make_reference(anywhere,NIL);
  return r;
}

References ANYWHERE_LOCATION, entity_all_xxx_locations(), entity_all_xxx_locations_typed(), get_bool_property(), make_reference(), and NIL.

Referenced by binary_intrinsic_call_to_points_to_sinks(), generic_eval_cell_with_points_to(), and make_anywhere_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_typed_anywhere_locations_p()

bool reference_typed_anywhere_locations_p

(

reference

r

)

test if a reference is the bottom of the lattice

Definition at line 141 of file anywhere_abstract_locations.c.

{
  entity e = reference_variable(r);
  bool anywhere_p = entity_typed_anywhere_locations_p(e);
  return anywhere_p;
}

References entity_typed_anywhere_locations_p(), and reference_variable.

Referenced by any_assign_to_transformer(), and cell_typed_anywhere_locations_p().

Here is the call graph for this function:

Here is the caller graph for this function:

stub_entity_of_module_p()

bool stub_entity_of_module_p	(	entity	s,
		entity	m
	)

There are several ways to decide if entity "s" is local to "m": its module name, its belonging to the declarations of m, its storage,... Let's avoir string comparisons and list scans...

Definition at line 624 of file anywhere_abstract_locations.c.

{
  bool stub_p = entity_stub_sink_p(s);
  if(stub_p) {
    /* There are several ways to decide if entity "s" is local to "m":
       its module name, its belonging to the declarations of m, its
       storage,... Let's avoir string comparisons and list scans... */
    storage ss = entity_storage(s);
    if(storage_ram_p(ss)) {
      ram rss = storage_ram(ss);
      entity f = ram_function(rss);
      stub_p = m==f;
    }
  }
  return stub_p;
}

References entity_storage, entity_stub_sink_p(), f(), ram_function, storage_ram, and storage_ram_p.

Referenced by clean_up_points_to_stubs(), compute_points_to_binded_set(), and generic_points_to_set_to_stub_cell_list().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_to_abstract_location()

entity variable_to_abstract_location

(

entity

v

)

returns the smallest abstract locations containing the location of variable v.

This does not work for formal parameters or, if it works, the caller module is not known and the resulting abstract location is very large. A large abstract location is returned.

No idea to model return values... even though they are located in the stack in real world.

If v cannot be converted into an abstract location, either the function aborts or an undefined entity is returned.

NULL is an abstract location

Definition at line 675 of file anywhere_abstract_locations.c.

{
  entity al = entity_undefined;
 
  if(entity_abstract_location_p(v))
    al = v;
  /* NULL is an abstract location  */
  else if(entity_null_locations_p(v))
    al = v;
  else if(entity_variable_p(v)
     && !dummy_parameter_entity_p(v)
     && !variable_return_p(v)) {
    bool typed_p = !get_bool_property("ALIASING_ACROSS_TYPES");
 
    // Too simplistic
    //al = FindOrCreateEntity(mn, ln);
 
    if(formal_parameter_p(v)) {
      const char * ln = FORMAL_AREA_LOCAL_NAME;
      type uvt = entity_basic_concrete_type(v);
      storage s = entity_storage(v);
      formal fs = storage_formal(s);
      entity f = formal_function(fs);
      if(typed_p) {
        const char* fn = entity_local_name(f);
        al = entity_all_module_xxx_locations_typed(fn, ln, uvt);
      }
      else
        al = entity_all_module_xxx_locations(f, ln);
      entity_kind(al)=ABSTRACT_LOCATION; // should it be a static/dynamic/stack/heap area too ? not according to static_area_p
    }
    else { // must be a standard variable, or a stub
      storage s = entity_storage(v);
      ram r = storage_ram(s);
      entity f = ram_function(r);
      entity a = ram_section(r);
      //string mn = entity_local_name(f);
      const char *ln = string_undefined;
      type uvt = entity_basic_concrete_type(v);
 
      if(static_area_p(a))
        ln = STATIC_AREA_LOCAL_NAME;
      else if(dynamic_area_p(a))
        ln = DYNAMIC_AREA_LOCAL_NAME;
      else if(stack_area_p(a))
        ln = STACK_AREA_LOCAL_NAME;
      else if(heap_area_p(a))
        ln = HEAP_AREA_LOCAL_NAME;
      else if(formal_area_p(a))
        ln = FORMAL_AREA_LOCAL_NAME;
      else
        pips_internal_error("Unexpected area\n");
 
      if(typed_p) {
        const char* fn = entity_local_name(f);
        al = entity_all_module_xxx_locations_typed(fn, ln, uvt);
      }
      else
        al = entity_all_module_xxx_locations(f, ln);
      entity_kind(al)=ABSTRACT_LOCATION; // should it be a static/dynamic/stack/heap area too ? not according to static_area_p
    }
  }
  else
    pips_internal_error("arg. not in definition domain");
 
  pips_assert("al is an abstract location entity",
              entity_abstract_location_p(al));
 
  return al;
}

References ABSTRACT_LOCATION, dummy_parameter_entity_p(), DYNAMIC_AREA_LOCAL_NAME, dynamic_area_p(), entity_abstract_location_p(), entity_all_module_xxx_locations(), entity_all_module_xxx_locations_typed(), entity_basic_concrete_type(), entity_kind, entity_local_name(), entity_null_locations_p(), entity_storage, entity_undefined, entity_variable_p, f(), FORMAL_AREA_LOCAL_NAME, formal_area_p(), formal_function, formal_parameter_p(), get_bool_property(), HEAP_AREA_LOCAL_NAME, heap_area_p(), pips_assert, pips_internal_error, ram_function, ram_section, STACK_AREA_LOCAL_NAME, stack_area_p(), STATIC_AREA_LOCAL_NAME, static_area_p(), storage_formal, storage_ram, string_undefined, and variable_return_p().

Referenced by add_conflicts(), entities_maymust_conflict_p(), entity_locations_max(), opkill_may_name(), and opkill_must_name().

Here is the call graph for this function:

Here is the caller graph for this function: