value.c File Reference

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

Include dependency graph for value.c:

Go to the source code of this file.

Functions
bool	hash_entity_to_values_undefined_p ()
	value.c More...
void	reset_value_counters ()
void	reset_temporary_value_counter ()
int	number_of_temporary_values ()
void	set_analyzed_types ()
void	reset_analyzed_types ()
bool	integer_analyzed_p ()
bool	boolean_analyzed_p ()
bool	string_analyzed_p ()
bool	float_analyzed_p ()
bool	complex_analyzed_p ()
bool	pointer_analyzed_p ()
bool	constant_path_analyzed_p ()
bool	analyzed_basic_p (basic b)
	The basic corresponds to one of the analyzed types. More...
bool	analyzed_type_p (type t)
	The type t is one of the analyzed types. More...
bool	analyzed_struct_p (entity s)
	Does struct s contain directly or indirectly a field that may be analyzable? More...
bool	analyzed_struct_type_p (type st)
bool	analyzed_array_p (entity a)
	Does array a contain directly or indirectly a field that may be analyzable? More...
bool	analyzed_array_type_p (type at)
bool	analyzed_entity_p (entity e)
bool	analyzable_scalar_entity_p (entity e)
	The entity type is one of the analyzed types. More...
bool	analyzed_constant_p (entity f)
	The constant may appear as a variable in the linear systems. More...
bool	analyzed_reference_p (reference r)
	FI: Nelson explains the motivation for can_be_constant_path_p() but I do not understand them. More...
static entity	make_local_value_entity (int n, int nature, type t)
	LOCAL VALUE ENTITY. More...
static entity	make_local_old_value_entity (type t)
static entity	make_local_intermediate_value_entity (type t)
entity	make_local_temporary_value_entity (type t)
entity	make_local_temporary_value_entity_with_basic (basic b)
entity	make_local_temporary_integer_value_entity ()
bool	local_old_value_entity_p (entity e)
	Return true if an entity is a local old value (such as "o#0" for a global value "i#init"...). More...
bool	local_intermediate_value_entity_p (entity e)
bool	local_temporary_value_entity_p (entity e)
static bool	non_local_temporary_value_entity_p (entity e)
bool	global_new_value_p (entity e)
	GLOBAL VALUES. More...
bool	global_old_value_p (entity e)
	Return true if an entity is a global old value (such as "i#init"...). More...
bool	global_intermediate_value_p (entity e)
entity	global_new_value_to_global_old_value (entity v_new)
const char *	global_value_name_to_user_name (const char *gn)
	HASH TABLE USE. More...
const char *	external_value_name (entity e)
const char *	pips_user_value_name (entity e)
	This function is called many times when the constraints and the system of constraints are sorted using lexicographic information based on this particular value name. More...
entity	entity_to_new_value (entity e)
entity	entity_to_old_value (entity e)
entity	entity_to_intermediate_value (entity e)
entity	reference_to_address_of_value (reference r)
entity	type_to_sizeof_value (type t)
bool	entity_has_values_p (entity e)
	This function could be made more robust by checking the storage of e. More...
bool	new_value_entity_p (entity e)
	the following three functions are directly or indirectly relative to the current module and its value hash tables. More...
bool	old_value_entity_p (entity e)
bool	intermediate_value_entity_p (entity e)
bool	address_of_value_entity_p (entity e)
bool	sizeof_value_entity_p (entity e)
bool	value_entity_p (entity e)
static string	string_identity (string s)
	used with hash_table_fprintf More...
void	print_value_mappings ()
static int	mapping_to_value_number (hash_table h)
static list	mapping_to_domain_list (hash_table h)
	Returns the list of entities in the mapping domain. More...
list	modified_variables_with_values ()
	Return the list of all analyzed variables which are modified in the current module. More...
void	test_mapping_entry_consistency ()
int	number_of_analyzed_values ()
int	aproximate_number_of_analyzed_variables ()
int	number_of_analyzed_variables ()
	FI: looks more like the number of values used. More...
void	allocate_value_mappings (int n, int o, int i)
static void	reset_value_mappings (void)
bool	hash_value_to_name_undefined_p ()
void	error_reset_value_mappings (void)
	To be called by error handler only. More...
void	free_value_mappings (void)
	Normal call to free the mappings. More...
void	error_free_value_mappings (void)
	To be called by an error handler. More...
static void	add_new_value_name (entity e)
	HASH TABLE INITIALIZATION. More...
entity	reference_to_address_entity (reference r)
	The address is the address of a variable or of a reference such as &a[5], not a of a value. More...
void	add_address_of_value (reference r, type t)
void	add_sizeof_value (type t)
	For a given architecture, sizeof(t) is a constant. More...
void	add_new_value (entity e)
void	add_new_alias_value (entity e, entity a)
entity	external_entity_to_new_value (entity e)
entity	external_entity_to_old_value (entity e)
void	add_old_value (entity e)
void	add_old_alias_value (entity e, entity a)
void	add_intermediate_value (entity e)
void	add_intermediate_alias_value (entity e, entity a)
void	add_local_old_value (entity e)
void	add_local_intermediate_value (entity e)
void	remove_entity_values (entity e, bool readonly)
void	add_synonym_values (entity e, entity eq, bool readonly)
entity	value_to_variable (entity val)
	Get the primitive variable associated to any value involved in a transformer. More...
entity	old_value_to_new_value (entity o_val)
entity	new_value_to_old_value (entity n_val)
entity	value_alias (entity e)
	Static aliasing. More...
Pvecteur	vect_variables_to_values (Pvecteur v)
	FI: not used, not debugged. More...
string	value_full_name (entity v)
	for debugging purposes More...
const char *	readable_value_name (entity v)
	For debugging purposes, we might have to print system with temporary values. More...

Variables
static hash_table	hash_entity_to_new_value = hash_table_undefined
	VARIABLE VALUE MANAGEMENT PACKAGE FOR TRANSFORMERS. More...
static hash_table	hash_entity_to_old_value = hash_table_undefined
static hash_table	hash_entity_to_intermediate_value = hash_table_undefined
static hash_table	hash_value_to_name = hash_table_undefined
static hash_table	hash_entity_to_user_value_name = hash_table_undefined
static hash_table	hash_reference_to_address_of_value = hash_table_undefined
static hash_table	hash_type_to_sizeof_value = hash_table_undefined
static int	local_intermediate_value_counter = 0
	Two counters used to assign meaningless value entities to local variables. More...
static int	local_old_value_counter = 0
static int	local_temporary_value_counter = 0
static bool	analyze_integer_scalar_entities = true
	TYPING. More...
static bool	analyze_boolean_scalar_entities = false
static bool	analyze_string_scalar_entities = false
static bool	analyze_float_scalar_entities = false
static bool	analyze_complex_scalar_entities = false
static bool	analyze_pointer_scalar_entities = false
static bool	analyze_constant_path = false

Function Documentation

add_address_of_value()

void add_address_of_value	(	reference	r,
		type	t
	)

add the couple (e, address_of_value)

add its name

Definition at line 1309 of file value.c.

{
  pips_internal_error("Obsolete function.\n");
  entity e = reference_variable(r);
  entity address_of_value;
  string address_of_value_name;
  string indice = strstr(reference_to_string(r), "[");
 
  if (indice != NULL)
  address_of_value_name = concatenate(
      entity_name(e), indice, ADDRESS_OF_SUFFIX, (char *) NULL);
  else
    address_of_value_name = concatenate(
        entity_name(e), ADDRESS_OF_SUFFIX, (char *) NULL);
 
 
  //address_of_value = gen_find_entity(address_of_value_name);
  address_of_value = gen_find_tabulated(address_of_value_name, entity_domain);
  //if (entity_undefined_p(address_of_value))
  if(address_of_value == entity_undefined)
    address_of_value = make_entity(strdup(address_of_value_name),
                                  copy_type(t),
                                  make_storage(is_storage_rom, UU),
                                  value_undefined);
 
  /* add the couple (e, address_of_value) */
  if(hash_get(hash_reference_to_address_of_value, (char *) r) == HASH_UNDEFINED_VALUE) {
    hash_put(hash_reference_to_address_of_value, (char *) r, (char *) address_of_value);
    /* add its name */
    hash_put(hash_value_to_name, (char *) address_of_value,
               strdup(entity_name(address_of_value)));
    // The next table be reset after the analysis, can't be reuse for the prettyprint, so useless to add in the table?
    entity v = value_to_variable(address_of_value);
    hash_put(hash_entity_to_user_value_name, (char *) address_of_value,
               strdup(concatenate("&", entity_user_name(v), indice, (char *) NULL)));
  }
}

References ADDRESS_OF_SUFFIX, concatenate(), copy_type(), entity_domain, entity_name, entity_undefined, entity_user_name(), gen_find_tabulated(), hash_entity_to_user_value_name, hash_get(), hash_put(), hash_reference_to_address_of_value, HASH_UNDEFINED_VALUE, hash_value_to_name, is_storage_rom, make_entity, make_storage(), pips_internal_error, reference_to_string(), reference_variable, strdup(), UU, value_to_variable(), and value_undefined.

Here is the call graph for this function:

add_intermediate_alias_value()

void add_intermediate_alias_value	(	entity	e,
		entity	a
	)

add_new_value_name(e);

Definition at line 1495 of file value.c.

{
  entity v = entity_undefined;
 
  pips_assert("add_intermediate_alias_valued",
              (hash_get(hash_entity_to_intermediate_value, (char *) e)
               == HASH_UNDEFINED_VALUE));
 
  v = entity_to_intermediate_value(a);
 
  hash_put(hash_entity_to_intermediate_value, (char *) e, (char *) v);
  /* add_new_value_name(e); */
}

References entity_to_intermediate_value(), entity_undefined, hash_entity_to_intermediate_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, and pips_assert.

Referenced by add_interprocedural_value_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_intermediate_value()

void add_intermediate_value

(

entity

e

)

get a new intermediate value, if necessary

add its (external) name

Definition at line 1476 of file value.c.

{
  entity intermediate_value;
 
  /* get a new intermediate value, if necessary */
  if((intermediate_value =
      (entity) hash_get(hash_entity_to_intermediate_value, (char *) e))
     == (entity) HASH_UNDEFINED_VALUE) {
    intermediate_value = make_local_intermediate_value_entity(entity_type(e));
    hash_put(hash_entity_to_intermediate_value, (char *) e,
             (char *) intermediate_value);
    /* add its (external) name */
    hash_put(hash_value_to_name, (char *) intermediate_value,
             strdup(concatenate(entity_name(e),
                                INTERMEDIATE_VALUE_SUFFIX,
                                (char *) NULL)));
  }
}

References concatenate(), entity_name, entity_type, hash_entity_to_intermediate_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, INTERMEDIATE_VALUE_SUFFIX, make_local_intermediate_value_entity(), and strdup().

Referenced by add_interprocedural_value_entities(), add_or_kill_equivalenced_variables(), convex_in_effect_loop_range_fix(), and interlaced_basic_workchunk_regions_p().

Here is the call graph for this function:

Here is the caller graph for this function:

add_local_intermediate_value()

void add_local_intermediate_value

(

entity

e

)

get a new intermediate value, if necessary

add its (external) name

Definition at line 1526 of file value.c.

{
  entity intermediate_value;
 
  /* get a new intermediate value, if necessary */
  if((intermediate_value =
      (entity) hash_get(hash_entity_to_intermediate_value, (char *) e))
     == (entity) HASH_UNDEFINED_VALUE) {
    intermediate_value = make_local_intermediate_value_entity(entity_type(e));
    hash_put(hash_entity_to_intermediate_value, (char *) e,
             (char *) intermediate_value);
    /* add its (external) name */
    hash_put(hash_value_to_name, (char *) intermediate_value,
             strdup(concatenate(entity_name(e),
                                INTERMEDIATE_VALUE_SUFFIX,
                                (char *) NULL)));
  }
}

References concatenate(), entity_name, entity_type, hash_entity_to_intermediate_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, INTERMEDIATE_VALUE_SUFFIX, make_local_intermediate_value_entity(), and strdup().

Referenced by add_intraprocedural_value_entities_unconditionally().

Here is the call graph for this function:

Here is the caller graph for this function:

add_local_old_value()

void add_local_old_value

(

entity

e

)

get a new old value, if necessary

add its (external) name

Definition at line 1509 of file value.c.

{
  entity old_value;
 
  /* get a new old value, if necessary */
  if((old_value =
      (entity) hash_get(hash_entity_to_old_value, (char *) e))
     == (entity) HASH_UNDEFINED_VALUE) {
    old_value = make_local_old_value_entity(entity_type(e));
    hash_put(hash_entity_to_old_value, (char *) e, (char *) old_value);
    /* add its (external) name */
    hash_put(hash_value_to_name, (char *) old_value,
             strdup(concatenate(entity_name(e), OLD_VALUE_SUFFIX,
                                (char *) NULL)));
  }
}

References concatenate(), entity_name, entity_type, hash_entity_to_old_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, make_local_old_value_entity(), OLD_VALUE_SUFFIX, and strdup().

Referenced by add_intraprocedural_value_entities_unconditionally().

Here is the call graph for this function:

Here is the caller graph for this function:

add_new_alias_value()

void add_new_alias_value	(	entity	e,
		entity	a
	)

add_new_value_name(e);

Definition at line 1396 of file value.c.

{
  entity v = entity_undefined;
  pips_debug(8, "begin: for %s and %s\n",
        entity_name(e),entity_name(a));
  pips_assert("hash_entity_to_new_value is defined",
              (hash_get(hash_entity_to_new_value, (char *) e)
               == HASH_UNDEFINED_VALUE));
 
  v = entity_to_new_value(a);
 
  hash_put(hash_entity_to_new_value, (char *) e, (char *) v);
  /* add_new_value_name(e); */
}

References entity_name, entity_to_new_value(), entity_undefined, hash_entity_to_new_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, pips_assert, and pips_debug.

Referenced by add_interprocedural_new_value_entity(), and add_interprocedural_value_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_new_value()

void add_new_value

(

entity

e

)

Definition at line 1386 of file value.c.

{
  pips_debug(8,"begin: for %s\n", entity_name(e));
  if(hash_get(hash_entity_to_new_value, (char *) e)
     == HASH_UNDEFINED_VALUE) {
    hash_put(hash_entity_to_new_value, (char *) e, (char *) e);
    add_new_value_name(e);
  }
}

References add_new_value_name(), entity_name, hash_entity_to_new_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, and pips_debug.

Referenced by add_interprocedural_new_value_entity(), add_interprocedural_value_entities(), add_intraprocedural_value_entities_unconditionally(), and add_or_kill_equivalenced_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

add_new_value_name()

static void add_new_value_name ( entity  e )

static

HASH TABLE INITIALIZATION.

void add_new_value_name(entity e): add a new value name for entity e

Definition at line 1254 of file value.c.

{
  string new_value_name =
    strdup(concatenate(entity_name(e), NEW_VALUE_SUFFIX,
                       (char *) NULL));
  pips_debug(8,"begin: for %s\n", entity_name(e));
  if(hash_get(hash_value_to_name, (char *) e) == HASH_UNDEFINED_VALUE)
    hash_put(hash_value_to_name, (char *) e, (char *) new_value_name);
  else
    free(new_value_name);
}

References concatenate(), entity_name, free(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, NEW_VALUE_SUFFIX, pips_debug, and strdup().

Referenced by add_new_value().

Here is the call graph for this function:

Here is the caller graph for this function:

add_old_alias_value()

void add_old_alias_value	(	entity	e,
		entity	a
	)

add_new_value_name(e);

Definition at line 1463 of file value.c.

{
  entity v = entity_undefined;
 
  pips_assert("add_old_alias_valued", (hash_get(hash_entity_to_old_value, (char *) e)
                                       == HASH_UNDEFINED_VALUE));
 
  v = entity_to_old_value(a);
 
  hash_put(hash_entity_to_old_value, (char *) e, (char *) v);
  /* add_new_value_name(e); */
}

References entity_to_old_value(), entity_undefined, hash_entity_to_old_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, and pips_assert.

Referenced by add_interprocedural_value_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_old_value()

void add_old_value

(

entity

e

)

find the old value entity if possible, else, generate it

add the couple (e, old_value)

add its name

Definition at line 1440 of file value.c.

{
  entity old_value;
  string old_value_name;
 
  /* find the old value entity if possible, else, generate it */
  old_value_name = concatenate(entity_name(e),OLD_VALUE_SUFFIX,
                               (char *) NULL);
  old_value = gen_find_tabulated(old_value_name, entity_domain);
  if(old_value == entity_undefined)
    old_value = make_entity(strdup(old_value_name),
                            copy_type(entity_type(e)),
                            make_storage(is_storage_rom, UU),
                            value_undefined);
  /* add the couple (e, old_value) */
  if(hash_get(hash_entity_to_old_value, (char *) e) == HASH_UNDEFINED_VALUE) {
    hash_put(hash_entity_to_old_value, (char *) e, (char *) old_value);
    /* add its name */
    hash_put(hash_value_to_name, (char *) old_value,
             strdup(entity_name(old_value)));
  }
}

References concatenate(), copy_type(), entity_domain, entity_name, entity_type, entity_undefined, gen_find_tabulated(), hash_entity_to_old_value, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, hash_value_to_name, is_storage_rom, make_entity, make_storage(), OLD_VALUE_SUFFIX, strdup(), UU, and value_undefined.

Referenced by add_interprocedural_value_entities(), add_or_kill_equivalenced_variables(), and add_synonym_values().

Here is the call graph for this function:

Here is the caller graph for this function:

add_sizeof_value()

void add_sizeof_value

(

type

t

)

For a given architecture, sizeof(t) is a constant.

It has no old value, no new value, it is a value.

Constants are encoded as 0-ary functions, not as values.

find the sizeof entity if possible, else, generate it

add the couple (e, old_value)

add its name

Definition at line 1352 of file value.c.

{
  entity sizeof_value;
  string sizeof_value_name;
 
  // improvement create the entity with the name of type
  // issue because of value_to_variable
  /* find the sizeof entity if possible, else, generate it */
  sizeof_value_name =
      concatenate(
          TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING,
          type_to_full_string_definition(t), SIZEOF_SUFFIX, (char *) NULL);
  sizeof_value = gen_find_tabulated(sizeof_value_name, entity_domain);
  if(sizeof_value == entity_undefined)
    sizeof_value =
        make_entity(strdup(sizeof_value_name),
            //make_type(is_type_variable,
            //    make_variable(make_basic(is_basic_int, (void*)sizeof(int)),NIL,NIL)),
            copy_type(t),
            make_storage(is_storage_rom, UU),
            value_undefined);
  /* add the couple (e, old_value) */
  if(hash_get(hash_type_to_sizeof_value, (char *) t) == HASH_UNDEFINED_VALUE) {
    hash_put(hash_type_to_sizeof_value, (char *) t, (char *) sizeof_value);
    /* add its name */
    hash_put(hash_value_to_name, (char *) sizeof_value,
        strdup(entity_name(sizeof_value)));
    hash_put(hash_entity_to_new_value, (char *) sizeof_value,
        (char *) sizeof_value);
    hash_put(hash_entity_to_user_value_name, (char *) sizeof_value,
        concatenate("sizeof(", type_to_full_string_definition(t), ")", (char *) NULL));
  }
}

References concatenate(), copy_type(), entity_domain, entity_name, entity_undefined, gen_find_tabulated(), hash_entity_to_new_value, hash_entity_to_user_value_name, hash_get(), hash_put(), hash_type_to_sizeof_value, HASH_UNDEFINED_VALUE, hash_value_to_name, is_storage_rom, make_entity, make_storage(), MODULE_SEP_STRING, SIZEOF_SUFFIX, strdup(), TOP_LEVEL_MODULE_NAME, type_to_full_string_definition(), UU, and value_undefined.

Referenced by expression_multiply_sizeof_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

add_synonym_values()

void add_synonym_values	(	entity	e,
		entity	eq,
		bool	readonly
	)

e and eq are entities whose values are always equal because they share the exact same memory location (i.e. they are alias). Values for e have already been declared. Values for eq have to be declared.

hash_put(hash_value_to_name, (char *) old_value_eq, entity_name(old_value_eq));

The name does not change. It is not used until the equivalence equations are added

Parameters

eq	q
readonly	eadonly

Definition at line 1578 of file value.c.

{
  /* e and eq are entities whose values are always equal because they
   * share the exact same memory location (i.e. they are alias). Values
   * for e have already been declared. Values for eq have to be
   * declared. */
  entity new_value = entity_to_new_value(e);
  entity intermediate_value;
 
  pips_debug(8, "Begin for registered variable %s"
             " equivalenced with new variable %s"
             " with status %s\n",
             entity_local_name(e), entity_local_name(eq),
             readonly? "readonly" : "read/write");
 
  hash_put(hash_entity_to_new_value, (char *) eq,
           (char *) new_value);
  if(!readonly) {
    entity old_value = entity_to_old_value(e);
    intermediate_value = entity_to_intermediate_value(e);
    add_old_value(eq);
    hash_put(hash_entity_to_intermediate_value, (char *) eq,
             (char *) intermediate_value);
    hash_update(hash_entity_to_old_value, (char *) eq, 
                (char *) old_value);
    /* hash_put(hash_value_to_name, (char *) old_value_eq, entity_name(old_value_eq)); */
  }
  /* The name does not change. It is not used until the equivalence
     equations are added */
  hash_put(hash_value_to_name, (char *) eq,
           strdup(concatenate(entity_name(eq),
                              NEW_VALUE_SUFFIX, (char *) NULL)));
 
  pips_debug(8, "End\n");
}

References add_old_value(), concatenate(), entity_local_name(), entity_name, entity_to_intermediate_value(), entity_to_new_value(), entity_to_old_value(), eq, hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_put(), hash_update(), hash_value_to_name, NEW_VALUE_SUFFIX, pips_debug, and strdup().

Referenced by add_equivalenced_values().

Here is the call graph for this function:

Here is the caller graph for this function:

address_of_value_entity_p()

bool address_of_value_entity_p

(

entity

e

)

Definition at line 962 of file value.c.

{
  string s = strstr(entity_local_name(e), ADDRESS_OF_SUFFIX);
 
  return s!=NULL;
}

References ADDRESS_OF_SUFFIX, and entity_local_name().

Referenced by pips_user_value_name(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_value_mappings()

void allocate_value_mappings	(	int	n,
		int	o,
		int	i
	)

hash_warn_on_redefinition();

Definition at line 1165 of file value.c.

{
  pips_assert("undefined mappings for allocation",
              hash_table_undefined_p(hash_entity_to_new_value) &&
              hash_table_undefined_p(hash_entity_to_old_value) &&
              hash_table_undefined_p(hash_entity_to_intermediate_value) &&
              hash_table_undefined_p(hash_reference_to_address_of_value) &&
              hash_table_undefined_p(hash_type_to_sizeof_value) &&
              hash_table_undefined_p(hash_value_to_name));
 
  /* hash_warn_on_redefinition(); */
  hash_entity_to_new_value = hash_table_make(hash_pointer, n);
  hash_entity_to_old_value = hash_table_make(hash_pointer, o);
  hash_entity_to_intermediate_value =
    hash_table_make(hash_pointer, i);
  hash_value_to_name =
    hash_table_make(hash_pointer, n + o + i + n); // The last +n for the pointer
  hash_entity_to_user_value_name =
    hash_table_make(hash_pointer, n + o + i + n); // The last +n for the pointer
  hash_reference_to_address_of_value = hash_table_make(hash_pointer, n);
  hash_type_to_sizeof_value = hash_table_make(hash_pointer, n);
}

References hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_entity_to_user_value_name, hash_pointer, hash_reference_to_address_of_value, hash_table_make(), hash_table_undefined_p, hash_type_to_sizeof_value, hash_value_to_name, and pips_assert.

Referenced by allocate_module_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzable_scalar_entity_p()

bool analyzable_scalar_entity_p

(

entity

e

)

The entity type is one of the analyzed types.

Definition at line 471 of file value.c.

{
  bool result = false;
 
  if(!abstract_state_variable_p(e) // for packages such as IO or RAND
     && !typedef_entity_p(e)
     && !entity_typed_anywhere_locations_p(e)
     && !entity_heap_location_p(e)
     && !place_holder_variable_p(e)) { // Because enum are analyzed
    type bct = entity_basic_concrete_type(e);
    result = analyzed_type_p(bct);
  }
  return result;
}

References abstract_state_variable_p(), analyzed_type_p(), entity_basic_concrete_type(), entity_heap_location_p(), entity_typed_anywhere_locations_p(), place_holder_variable_p(), and typedef_entity_p().

Referenced by add_implicit_interprocedural_write_effects(), add_or_kill_equivalenced_variables(), any_user_call_site_to_transformer(), c_return_to_transformer(), external_entity_to_new_value(), generic_reference_to_transformer(), module_to_formal_analyzable_parameters(), module_to_value_mappings(), precondition_intra_to_inter(), and same_analyzable_type_scalar_entity_list_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_array_p()

bool analyzed_array_p

(

entity

a

)

Does array a contain directly or indirectly a field that may be analyzable?

Definition at line 434 of file value.c.

{
  bool analyzed_p = false;
  type at = entity_basic_concrete_type(a);
  type et = array_type_to_element_type(at);
  if(analyzed_type_p(et))
    analyzed_p = true;
  else if(struct_type_p(et))
    analyzed_p = analyzed_struct_type_p(et);
  return analyzed_p;
}

References analyzed_struct_type_p(), analyzed_type_p(), array_type_to_element_type(), entity_basic_concrete_type(), and struct_type_p().

Here is the call graph for this function:

analyzed_array_type_p()

bool analyzed_array_type_p

(

type

at

)

Parameters

at

t

Definition at line 446 of file value.c.

{
  bool analyzed_p = false;
  type et = array_type_to_element_type(at);
  if(analyzed_type_p(et))
    analyzed_p = true;
  else if(struct_type_p(et))
    analyzed_p = analyzed_struct_type_p(et);
  return analyzed_p;
}

References analyzed_struct_type_p(), analyzed_type_p(), array_type_to_element_type(), and struct_type_p().

Referenced by analyzed_entity_p(), and analyzed_struct_type_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_basic_p()

bool analyzed_basic_p

(

basic

b

)

The basic corresponds to one of the analyzed types.

Definition at line 337 of file value.c.

{
  bool analyzed_p = false;
 
  if(analyze_integer_scalar_entities && basic_int_p(b))
    analyzed_p = true;
  else if(analyze_string_scalar_entities && basic_string_p(b))
    analyzed_p = true;
  else if(analyze_boolean_scalar_entities && basic_logical_p(b))
    analyzed_p = true;
  else if(analyze_float_scalar_entities && basic_float_p(b))
    analyzed_p = true;
  else if(analyze_pointer_scalar_entities && basic_pointer_p(b)) {
    pips_debug(9,"pointer type : %s\n", type_to_string(basic_pointer(b)));
    analyzed_p = true;
  }
  else if(analyze_complex_scalar_entities && basic_complex_p(b))
    analyzed_p = true;
  else if(analyze_integer_scalar_entities && basic_derived_p(b)) {
    entity de = basic_derived(b);
    type dt = entity_basic_concrete_type(de);
    analyzed_p = type_enum_p(dt);
  }
  else
    analyzed_p = false;
 
  return analyzed_p;
}

References analyze_boolean_scalar_entities, analyze_complex_scalar_entities, analyze_float_scalar_entities, analyze_integer_scalar_entities, analyze_pointer_scalar_entities, analyze_string_scalar_entities, basic_complex_p, basic_derived, basic_derived_p, basic_float_p, basic_int_p, basic_logical_p, basic_pointer, basic_pointer_p, basic_string_p, entity_basic_concrete_type(), pips_debug, type_enum_p, and type_to_string().

Referenced by analyzed_type_p(), and condition_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_constant_p()

bool analyzed_constant_p

(

entity

f

)

The constant may appear as a variable in the linear systems.

is f a 0-ary function, i.e. a constant of proper type?

integer and logical constants are handled explicitly

Definition at line 487 of file value.c.

{
  /* is f a 0-ary function, i.e. a constant of proper type? */
  if(entity_constant_p(f)) {
    basic b = variable_basic(type_variable
      (functional_result(type_functional(entity_type(f)))));
 
    /* integer and logical constants are handled explicitly */
 
    if(basic_string_p(b) && analyze_string_scalar_entities)
      return true;
    if(basic_float_p(b) && analyze_float_scalar_entities)
      return true;
    if(basic_complex_p(b) && analyze_complex_scalar_entities)
      return true;
    if(basic_pointer_p(b) && analyze_pointer_scalar_entities)
      return true;
  }
  return false;
}

References analyze_complex_scalar_entities, analyze_float_scalar_entities, analyze_pointer_scalar_entities, analyze_string_scalar_entities, basic_complex_p, basic_float_p, basic_pointer_p, basic_string_p, entity_constant_p, entity_type, f(), functional_result, type_functional, type_variable, and variable_basic.

Referenced by value_mappings_compatible_vector_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_entity_p()

bool analyzed_entity_p

(

entity

e

)

Definition at line 457 of file value.c.

{
  bool analyzed_p = false;
  type et = entity_basic_concrete_type(e);
  if(analyzed_type_p(et))
    analyzed_p = true;
  else if(struct_type_p(et))
    analyzed_p = analyzed_struct_type_p(et);
  else if(array_type_p(et))
    analyzed_p = analyzed_array_type_p(et);
  return analyzed_p;
}

References analyzed_array_type_p(), analyzed_struct_type_p(), analyzed_type_p(), array_type_p(), entity_basic_concrete_type(), and struct_type_p().

Referenced by generic_substitute_formal_array_elements_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_reference_p()

bool analyzed_reference_p

(

reference

r

)

FI: Nelson explains the motivation for can_be_constant_path_p() but I do not understand them.

He also explains the motivation for strict_constant_path_p() and I do not understand them either.

Stricly speaking, this funtion should be called analyzed_points_to_reference_p()

Definition at line 518 of file value.c.

{
  pips_debug(7, "analyzed_reference_p, ref : %s\n", reference_to_string(r));
  bool result = false;
  entity v = reference_variable(r);
 
  if (store_independent_points_to_reference_p(r)
      //&& atomic_points_to_reference_p(r)) {
      && generic_atomic_points_to_reference_p(r, false)
      && !effects_package_entity_p(v)) {
    type t = points_to_reference_to_concrete_type(r);
    result = analyzed_type_p(t);
  }
  else {
    // e.g. a[i]
    result = false;
  }
 
  pips_debug(7, "analyzed_reference_p result : %i\n", result);
  return result;
}

References analyzed_type_p(), effects_package_entity_p(), generic_atomic_points_to_reference_p(), pips_debug, points_to_reference_to_concrete_type(), reference_to_string(), reference_variable, and store_independent_points_to_reference_p().

Referenced by any_assign_to_transformer(), any_basic_update_to_transformer(), any_update_to_transformer(), assign_rhs_to_reflhs_to_transformer(), generic_apply_effect_to_transformer(), lhs_expression_to_transformer(), module_to_value_mappings(), points_to_unary_operation_to_transformer(), and substitute_stubs_in_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_struct_p()

bool analyzed_struct_p

(

entity

s

)

Does struct s contain directly or indirectly a field that may be analyzable?

Definition at line 387 of file value.c.

{
  bool analyzed_p = false;
  list fl = struct_variable_to_fields(s);
  FOREACH(ENTITY, f, fl) {
    type ft = entity_basic_concrete_type(f);
    if(analyzed_type_p(ft)) {
      analyzed_p = true;
      break;
    }
    else if(struct_type_p(ft)) {
      analyzed_p = analyzed_struct_p(f);
      if(analyzed_p)
        break;
    }
  }
  return analyzed_p;
}

References analyzed_struct_p(), analyzed_type_p(), ENTITY, entity_basic_concrete_type(), f(), FOREACH, struct_type_p(), and struct_variable_to_fields().

Referenced by analyzed_struct_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_struct_type_p()

bool analyzed_struct_type_p

(

type

st

)

Parameters

st

t

Definition at line 406 of file value.c.

{
  bool analyzed_p = false;
  list fl = struct_type_to_fields(st);
  FOREACH(ENTITY, f, fl) {
    // FI: might be shorter an safer to call entity_analyzed_p(f)
    type ft = entity_basic_concrete_type(f);
    if(analyzed_type_p(ft)) {
      analyzed_p = true;
      break;
    }
    else if(struct_type_p(ft)) {
      analyzed_p = analyzed_struct_type_p(ft);
      if(analyzed_p)
        break;
    }
    else if(array_type_p(ft)) {
      analyzed_p = analyzed_array_type_p(ft);
      if(analyzed_p)
        break;
    }
  }
  return analyzed_p;
}

References analyzed_array_type_p(), analyzed_struct_type_p(), analyzed_type_p(), array_type_p(), ENTITY, entity_basic_concrete_type(), f(), FOREACH, struct_type_p(), and struct_type_to_fields().

Referenced by analyzed_array_p(), analyzed_array_type_p(), analyzed_entity_p(), and analyzed_struct_type_p().

Here is the call graph for this function:

Here is the caller graph for this function:

analyzed_type_p()

bool analyzed_type_p

(

type

t

)

The type t is one of the analyzed types.

Definition at line 367 of file value.c.

{
  bool result = false;
  type bct = compute_basic_concrete_type(t);
 
  if(type_variable_p(bct)) {
    variable v = type_variable(bct);
    if (!volatile_variable_p(v)
        && ENDP(variable_dimensions(v))           //NL : for checking the dimension instead of entity_scalar_p which filter pointer type
    ) {
      result = analyzed_basic_p(variable_basic(v));
    }
  }
 
  return result;
}

References analyzed_basic_p(), compute_basic_concrete_type(), ENDP, type_variable, type_variable_p, variable_basic, variable_dimensions, and volatile_variable_p().

Referenced by add_inter_or_intraprocedural_field_entities(), analyzable_scalar_entity_p(), analyzed_array_p(), analyzed_array_type_p(), analyzed_entity_p(), analyzed_reference_p(), analyzed_struct_p(), analyzed_struct_type_p(), assign_rhs_to_reflhs_to_transformer(), call_to_transformer(), create_values_for_simple_effect(), expression_to_transformer(), generic_reference_to_transformer(), generic_substitute_formal_array_elements_in_transformer(), make_local_temporary_value_entity(), module_to_value_mappings(), perform_array_element_substitutions_in_transformer(), semantics_usable_points_to_reference_p(), substitute_struct_stub_in_transformer(), and transformer_apply_field_assignments_or_equalities().

Here is the call graph for this function:

Here is the caller graph for this function:

aproximate_number_of_analyzed_variables()

int aproximate_number_of_analyzed_variables

(

void

)

FI: I do not know if equivalenced variables are well taken into account

Definition at line 1153 of file value.c.

{
  /* FI: I do not know if equivalenced variables are well taken into account*/
  return hash_table_entry_count(hash_entity_to_new_value);
}

References hash_entity_to_new_value, and hash_table_entry_count().

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

boolean_analyzed_p()

bool boolean_analyzed_p

(

void

)

Definition at line 305 of file value.c.

{
  return analyze_boolean_scalar_entities;
}

References analyze_boolean_scalar_entities.

Referenced by any_expression_to_transformer(), and fortran_data_to_prec_for_variables().

Here is the caller graph for this function:

complex_analyzed_p()

bool complex_analyzed_p

(

void

)

Definition at line 320 of file value.c.

{
  return analyze_complex_scalar_entities;
}

References analyze_complex_scalar_entities.

constant_path_analyzed_p()

bool constant_path_analyzed_p

(

void

)

Definition at line 330 of file value.c.

{
  return analyze_constant_path;
}

References analyze_constant_path.

Referenced by any_assign_to_transformer(), assign_rhs_to_reflhs_to_transformer(), basic_update_reflhs_with_rhs_to_transformer(), generic_apply_effect_to_transformer(), integer_call_expression_to_transformer(), lhs_expression_to_transformer(), module_to_value_mappings(), process_call_for_summary_precondition(), and update_reflhs_with_rhs_to_transformer().

Here is the caller graph for this function:

entity_has_values_p()

bool entity_has_values_p

(

entity

e

)

This function could be made more robust by checking the storage of e.

Formal parameters of analyzed type always have values.

is e a variable whose value(s) (already) are analyzed?

Definition at line 911 of file value.c.

{
  /* is e a variable whose value(s) (already) are analyzed?
   */
  pips_assert("value hash table is defined",
              !hash_table_undefined_p(hash_entity_to_new_value));
  bool has_values_p = hash_defined_p(hash_entity_to_new_value, (char *) e);
  return has_values_p;
}

References hash_defined_p(), hash_entity_to_new_value, hash_table_undefined_p, and pips_assert.

Referenced by add_index_range_conditions(), add_inter_or_intraprocedural_field_entities(), add_interprocedural_new_value_entity(), add_interprocedural_value_entities(), add_intraprocedural_value_entities(), add_loop_index_exit_value(), add_or_kill_equivalenced_variables(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), apply_abstract_effect_to_transformer(), assign_operation_to_transformer(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), c_data_to_prec_for_variables(), declaration_to_transformer(), declaration_to_transformer_list(), dynamic_variables_to_values(), effects_to_arguments(), filter_transformer(), fortran_data_to_prec_for_variables(), fortran_user_call_to_transformer(), generic_apply_effect_to_transformer(), generic_reference_to_transformer(), generic_unary_operation_to_transformer(), integer_assign_to_transformer(), integer_assign_to_transformer_list(), logical_reference_to_transformer(), loop_bound_evaluation_to_transformer(), module_to_value_mappings(), noms_var(), pips_user_value_name(), pointer_unary_operation_to_transformer(), safe_assigned_expression_to_transformer(), safe_assigned_expression_to_transformer_list(), string_expression_to_transformer(), substitute_scalar_stub_in_transformer(), substitute_stubs_in_transformer(), transformer_add_condition_information_updown(), transformer_add_loop_index_incrementation(), transformer_add_loop_index_initialization(), transformer_add_modified_variable_entity(), transformer_add_variable_type_information(), transformer_filter_subsumed_variables(), transformer_general_consistency_p(), transformer_projection_with_redundancy_elimination_and_check(), transformer_variables_filter(), value_mappings_compatible_vector_p(), variable_to_values(), and variables_to_values().

Here is the call graph for this function:

entity_to_intermediate_value()

entity entity_to_intermediate_value

(

entity

e

)

Definition at line 879 of file value.c.

{
  entity i;
  if((i = (entity) hash_get(hash_entity_to_intermediate_value, (char *) e))
     == entity_undefined)
    pips_internal_error("unbounded entity %s",
                        entity_name(e));
  return i;
}

References entity_name, entity_undefined, hash_entity_to_intermediate_value, hash_get(), and pips_internal_error.

Referenced by add_intermediate_alias_value(), add_synonym_values(), convex_in_effect_loop_range_fix(), external_value_name(), interlaced_basic_workchunk_regions_p(), remove_entity_values(), transformer_combine(), transformer_derivative_constraints(), transformer_derivative_fix_point(), and transformer_list_generic_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_new_value()

entity entity_to_new_value

(

entity

e

)

Definition at line 859 of file value.c.

{
  entity n;
  if((n = (entity) hash_get(hash_entity_to_new_value, (char *) e))
     == entity_undefined)
    pips_internal_error("unbounded entity %s",
                        entity_name(e));
  return n;
}

References entity_name, entity_undefined, hash_entity_to_new_value, hash_get(), and pips_internal_error.

Referenced by add_affine_bound_conditions(), add_loop_index_exit_value(), add_new_alias_value(), add_synonym_values(), affine_to_transformer(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), args_to_transformer(), assign_operation_to_transformer(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), comp_regions_of_implied_do(), dynamic_variables_to_values(), external_value_name(), filter_transformer(), fortran_user_call_to_transformer(), generic_reference_to_transformer(), logical_reference_to_transformer(), loop_bound_evaluation_to_transformer(), old_value_to_new_value(), remove_entity_values(), string_expression_to_transformer(), substitute_scalar_stub_in_transformer(), substitute_stubs_in_transformer_with_translation_binding(), transformer_add_condition_information_updown(), transformer_add_identity(), transformer_add_loop_index_incrementation(), transformer_add_modified_variable_entity(), transformer_add_value_update(), transformer_add_variable_incrementation(), transformer_add_variable_type_information(), transformer_add_variable_update(), transformer_argument_general_consistency_p(), transformer_arguments_projection(), transformer_convex_hulls(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_domain_intersection(), transformer_internal_consistency_p(), transformer_list_generic_transitive_closure(), transformer_to_domain(), transformer_variables_filter(), update_cp_with_rhs_to_transformer(), value_mappings_compatible_vector_p(), value_passing_summary_transformer(), variable_to_values(), variables_to_new_values(), variables_to_values(), and vect_variables_to_values().

Here is the call graph for this function:

entity_to_old_value()

entity entity_to_old_value

(

entity

e

)

Definition at line 869 of file value.c.

{
  entity o;
  if((o = (entity) hash_get(hash_entity_to_old_value, (char *) e))
     == entity_undefined)
    pips_internal_error("unbounded entity %s",
                        entity_name(e));
  return o;
}

References entity_name, entity_undefined, hash_entity_to_old_value, hash_get(), and pips_internal_error.

Referenced by add_old_alias_value(), add_synonym_values(), add_type_information(), affine_to_transformer(), any_assign_operation_to_transformer(), any_basic_update_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), dynamic_variables_to_values(), external_value_name(), fortran_user_call_to_transformer(), new_value_to_old_value(), perform_array_element_substitutions_in_transformer(), precondition_intra_to_inter(), remove_entity_values(), safe_transformer_projection(), statement_to_postcondition(), statement_to_total_precondition(), substitute_scalar_stub_in_transformer(), substitute_stubs_in_transformer_with_translation_binding(), transformer_add_identity(), transformer_add_loop_index_incrementation(), transformer_add_loop_index_initialization(), transformer_add_modified_variable_entity(), transformer_add_value_update(), transformer_add_variable_incrementation(), transformer_add_variable_update(), transformer_arguments_projection(), transformer_combine(), transformer_convex_hulls(), transformer_domain_intersection(), transformer_intersect_range_with_domain(), transformer_list_safe_variables_projection(), transformer_projection_with_redundancy_elimination_and_check(), transformer_range(), transformer_to_domain(), transformer_variables_filter(), update_cp_with_rhs_to_transformer(), value_passing_summary_transformer(), variable_to_values(), variables_to_old_values(), and variables_to_values().

Here is the call graph for this function:

Here is the caller graph for this function:

error_free_value_mappings()

void error_free_value_mappings

(

void

)

To be called by an error handler.

free previous hash tables, desallocate names; this implies ALL value names were malloced and were not pointer to a ri part

the three tables are assumed to be allocated all together

free names in hash_value_to_name; the other two hash tables contain pointers to the entity tabulated domain and thus need no value freeing

k is discovered unused by lint; it is syntaxically necessary

free the three tables themselves

Definition at line 1222 of file value.c.

{
  /* free previous hash tables, desallocate names; this implies ALL
     value names were malloced and were not pointer to a ri part */
 
  /* the three tables are assumed to be allocated all together */
 
  /* free names in hash_value_to_name; the other two hash tables
     contain pointers to the entity tabulated domain and thus need
     no value freeing */
  /* k is discovered unused by lint; it is syntaxically necessary */
  HASH_MAP(k, v, {free(v);}, hash_value_to_name);
  // Do not deallocate the names: they are pointers towards parts of
  // entity names
  //HASH_MAP(k, v, {free(v);}, hash_entity_to_user_value_name);
  /* free the three tables themselves */
  hash_table_free(hash_entity_to_new_value);
  hash_table_free(hash_entity_to_old_value);
  hash_table_free(hash_entity_to_intermediate_value);
  hash_table_free(hash_value_to_name);
  hash_table_free(hash_entity_to_user_value_name);
  hash_table_free(hash_reference_to_address_of_value);
  hash_table_free(hash_type_to_sizeof_value);
 
  reset_value_mappings();
  reset_temporary_value_counter();
  reset_analyzed_types();
}

References free(), hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_entity_to_user_value_name, HASH_MAP, hash_reference_to_address_of_value, hash_table_free(), hash_type_to_sizeof_value, hash_value_to_name, reset_analyzed_types(), reset_temporary_value_counter(), and reset_value_mappings().

Referenced by free_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

error_reset_value_mappings()

void error_reset_value_mappings

(

void

)

To be called by error handler only.

Potential memory leak.

Definition at line 1205 of file value.c.

{
  reset_value_mappings();
}

References reset_value_mappings().

Referenced by free_value_mappings(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

external_entity_to_new_value()

entity external_entity_to_new_value

(

entity

e

)

there is no decisive test here; a necessary condition is used instead

Definition at line 1411 of file value.c.

{
  /* there is no decisive test here; a necessary condition is used instead */
 
  entity e_new;
 
  pips_assert("e must be a type analyzable scalar variable", analyzable_scalar_entity_p(e));
  e_new = e;
  return e_new;
}

References analyzable_scalar_entity_p(), and pips_assert.

Referenced by add_formal_to_actual_bindings(), formal_and_actual_parameters_association(), fortran_user_call_to_transformer(), generic_reference_to_transformer(), logical_reference_to_transformer(), and substitute_stubs_in_transformer_with_translation_binding().

Here is the call graph for this function:

Here is the caller graph for this function:

external_entity_to_old_value()

entity external_entity_to_old_value

(

entity

e

)

find the old value entity if possible or abort I should never have to call this function on an local entity (local entities include static local variables)

Definition at line 1422 of file value.c.

{
  /* find the old value entity if possible or abort
     I should never have to call this function on an local entity
     (local entities include static local variables) */
 
  entity old_value;
  string old_value_name;
 
  old_value_name = concatenate(entity_name(e),OLD_VALUE_SUFFIX,
                               (char *) NULL);
  old_value = gen_find_tabulated(old_value_name, entity_domain);
 
  pips_assert("external_entity_to_old_value", old_value!=entity_undefined);
 
  return old_value;
}

References concatenate(), entity_domain, entity_name, entity_undefined, gen_find_tabulated(), OLD_VALUE_SUFFIX, and pips_assert.

Referenced by fortran_user_call_to_transformer(), perform_array_element_substitutions_in_transformer(), and substitute_stubs_in_transformer_with_translation_binding().

Here is the call graph for this function:

Here is the caller graph for this function:

external_value_name()

const char* external_value_name

(

entity

e

)

This should never occur. Please core dump!

Definition at line 753 of file value.c.

{
  const char* s = string_undefined;
  if(entity_constant_p(e)) {
    // Used for floating point and string constants? Why entity name?
    s = entity_local_name(e);
  }
  else if(entity_symbolic_p(e)) {
    // Used for locations, i.e. constant memory access paths
    s = entity_local_name(e);
  }
  else if(null_pointer_value_entity_p(e)) {
    s = entity_name(e);
  }
  else {
    // it must be one of the values attached to a user variable
    entity m = get_current_module_entity();
    s = hash_get(hash_value_to_name, (char *) e);
    // type t = entity_type(e);
 
    if(s==HASH_UNDEFINED_VALUE
       //&& type_variable_p(t)
       && !variable_in_module_p(e,m)) {
      if(global_new_value_p(e)) {
        entity a = entity_to_new_value(e);
        s = hash_get(hash_value_to_name, (char *) a);
      }
      else if(global_old_value_p(e)) {
        entity a = entity_to_old_value(e);
        s = hash_get(hash_value_to_name, (char *) a);
      }
      else if(global_intermediate_value_p(e)) {
        entity a = entity_to_intermediate_value(e);
        s = hash_get(hash_value_to_name, (char *) a);
      }
      else {
        /* This should never occur. Please core dump! */
        pips_internal_error("\nUnexpected value \"%s\""
                            " for current module \"%s\"",
                            entity_name(e),
                            module_local_name(get_current_module_entity()));
      }
    }
 
    pips_assert("A value name must be defined",
                s != HASH_UNDEFINED_VALUE);
 
    if(strcmp(module_local_name(m), module_name(s)) == 0
       ||strcmp(TOP_LEVEL_MODULE_NAME, module_name(s)) == 0) {
      //s = local_name(s);
      s = global_value_name_to_user_name(s);
    }
  }
 
  return s;
}

References entity_constant_p, entity_local_name(), entity_name, entity_symbolic_p, entity_to_intermediate_value(), entity_to_new_value(), entity_to_old_value(), get_current_module_entity(), global_intermediate_value_p(), global_new_value_p(), global_old_value_p(), global_value_name_to_user_name(), hash_get(), HASH_UNDEFINED_VALUE, hash_value_to_name, module_local_name(), module_name(), null_pointer_value_entity_p(), pips_assert, pips_internal_error, string_undefined, TOP_LEVEL_MODULE_NAME, and variable_in_module_p().

Referenced by __attribute__(), add_loop_skip_condition(), build_transfer_equations(), complete_loop_transformer(), complete_loop_transformer_list(), intermediate_value_entity_p(), invariant_vector_p(), loop_to_transformer(), noms_var(), old_complete_whileloop_transformer(), pips_user_value_name(), print_transformer(), print_transformers(), print_value_mappings(), readable_value_name(), recompute_loop_transformer(), remove_entity_values(), standard_whileloop_to_transformer(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_equality_fix_point(), transformer_list_generic_transitive_closure(), transformer_normalize(), and transformer_pattern_fix_point().

Here is the call graph for this function:

Here is the caller graph for this function:

float_analyzed_p()

bool float_analyzed_p

(

void

)

Definition at line 315 of file value.c.

{
  return analyze_float_scalar_entities;
}

References analyze_float_scalar_entities.

Referenced by any_expression_to_transformer(), fortran_data_to_prec_for_variables(), parametric_transformer_empty_p(), and transformer_normalize().

Here is the caller graph for this function:

free_value_mappings()

void free_value_mappings

(

void

)

Normal call to free the mappings.

Definition at line 1212 of file value.c.

{
  reset_hooks_unregister(error_reset_value_mappings);
  pips_assert("no free of undefined mappings",
              !hash_table_undefined_p(hash_entity_to_old_value));
  error_free_value_mappings();
}

References error_free_value_mappings(), error_reset_value_mappings(), hash_entity_to_old_value, hash_table_undefined_p, pips_assert, and reset_hooks_unregister().

Referenced by add_alias_pairs_for_this_caller(), alias_classes(), alias_lists(), alias_pairs(), aliases_text(), any_complexities(), array_expansion(), bdsc_code_instrumentation(), call_site_to_module_precondition_text(), continuation_conditions(), dsc_code_parallelization(), generic_module_name_to_transformers(), generic_print_xml_application(), get_continuation_condition_text(), get_semantic_text(), hbdsc_parallelization(), initial_precondition(), isolate_statement(), kernel_data_mapping(), kernel_load_store_engine(), module_name_to_preconditions(), module_name_to_total_preconditions(), out_regions_from_caller_to_callee(), partial_eval(), phrase_comEngine_distributor(), phrase_distributor(), phrase_distributor_control_code(), pragma_outliner(), print_initial_precondition(), print_program_precondition(), program_precondition(), reset_convex_in_out_regions(), reset_convex_rw_regions(), reset_convex_summary_in_out_regions(), reset_convex_summary_rw_regions(), safescale_distributor(), safescale_module_analysis(), sequence_dependence_graph(), solve_hardware_constraints(), spire_distributed_unstructured_to_structured(), summary_precondition(), summary_total_postcondition(), and update_precondition_with_call_site_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

global_intermediate_value_p()

bool global_intermediate_value_p

(

entity

e

)

this is not a general test; it will only work for GLOBAL values

Definition at line 703 of file value.c.

{
  /* this is not a general test; it will only work for GLOBAL values */
  string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);
  bool intermediate = false;
 
  if(suf!=NULL)
    intermediate = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 &&
      strcmp(suf, INTERMEDIATE_VALUE_SUFFIX) == 0;
 
  return intermediate;
}

References entity_local_name(), entity_module_name(), INTERMEDIATE_VALUE_SUFFIX, SEMANTICS_MODULE_NAME, and SEMANTICS_SEPARATOR.

Referenced by external_value_name().

Here is the call graph for this function:

Here is the caller graph for this function:

global_new_value_p()

bool global_new_value_p

(

entity

e

)

GLOBAL VALUES.

this is not a general test; it will only work for GLOBAL values

this function should always return false because new value = variable (FI)

=> suf == NULL string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);

pips_assert("global_new_value", suf != NULL);

new = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 && strcmp(suf, NEW_VALUE_SUFFIX) == 0;

Definition at line 667 of file value.c.

{
  bool new = false;
  /* this is not a general test; it will only work for GLOBAL values */
 
  /* this function should always return false because new value = variable (FI) */
 
  /* => suf == NULL
     string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);
 
     pips_assert("global_new_value", suf != NULL);
 
     new = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 &&
     strcmp(suf, NEW_VALUE_SUFFIX) == 0;
  */
 
  pips_assert("global_new_value", new == false && e==e);
 
  return new;
}

References pips_assert.

Referenced by external_value_name().

Here is the caller graph for this function:

global_new_value_to_global_old_value()

entity global_new_value_to_global_old_value

(

entity

v_new

)

There is no real test for global new values

Parameters

v_new

_new

Definition at line 716 of file value.c.

{
  entity v_old = entity_undefined;
 
  /* There is no real test for global new values */
 
  pips_assert("new value must be a real variable entity, denoting the new value",
              strcmp(entity_module_name(v_new), SEMANTICS_MODULE_NAME) != 0);
 
  string v_old_name = concatenate(entity_name(v_new), OLD_VALUE_SUFFIX, NULL);
  v_old = (entity) gen_find_tabulated(v_old_name, entity_domain);
  if(v_old==NULL) v_old = entity_undefined;
 
  return v_old;
}

References concatenate(), entity_domain, entity_module_name(), entity_name, entity_undefined, gen_find_tabulated(), OLD_VALUE_SUFFIX, pips_assert, and SEMANTICS_MODULE_NAME.

Referenced by c_user_function_call_to_transformer(), fortran_user_function_call_to_transformer(), substitute_scalar_stub_in_transformer(), transformer_projection_with_redundancy_elimination_and_check(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

global_old_value_p()

bool global_old_value_p

(

entity

e

)

Return true if an entity is a global old value (such as "i#init"...).

this is not a general test; it will only work for GLOBAL values

Definition at line 690 of file value.c.

{
  /* this is not a general test; it will only work for GLOBAL values */
  string suf = strchr(entity_local_name(e), SEMANTICS_SEPARATOR);
  bool old = false;
 
  if(suf!=NULL)
    old = strcmp(entity_module_name(e), SEMANTICS_MODULE_NAME) != 0 &&
      strcmp(suf, OLD_VALUE_SUFFIX) == 0;
 
  return old;
}

References entity_local_name(), entity_module_name(), OLD_VALUE_SUFFIX, SEMANTICS_MODULE_NAME, and SEMANTICS_SEPARATOR.

Referenced by external_value_name(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

global_value_name_to_user_name()

const char* global_value_name_to_user_name

(

const char *

gn

)

HASH TABLE USE.

Return a variable value name or map a variable to its different variable values. the '#' character used in value naming conflicts with the reserved character for struct naming

Parameters

gn

n

Definition at line 741 of file value.c.

{
  const char* un = strrchr(gn, BLOCK_SEP_CHAR);
 
  if(un==NULL)
    un = local_name(gn);
  else
    un++;
 
  return un;
}

References BLOCK_SEP_CHAR, and local_name().

Referenced by external_value_name().

Here is the call graph for this function:

Here is the caller graph for this function:

hash_entity_to_values_undefined_p()

bool hash_entity_to_values_undefined_p

(

void

)

value.c

Definition at line 229 of file value.c.

{
  return (hash_table_undefined_p(hash_entity_to_new_value));
}

References hash_entity_to_new_value, and hash_table_undefined_p.

hash_value_to_name_undefined_p()

bool hash_value_to_name_undefined_p

(

void

)

Definition at line 1199 of file value.c.

{
  return hash_table_undefined_p(hash_value_to_name);
}

References hash_table_undefined_p, and hash_value_to_name.

Referenced by generic_value_name().

Here is the caller graph for this function:

integer_analyzed_p()

bool integer_analyzed_p

(

void

)

Definition at line 300 of file value.c.

{
  return analyze_integer_scalar_entities;
}

References analyze_integer_scalar_entities.

Referenced by any_expression_to_transformer().

Here is the caller graph for this function:

intermediate_value_entity_p()

bool intermediate_value_entity_p

(

entity

e

)

Definition at line 955 of file value.c.

{
  string s = strstr(external_value_name(e), INTERMEDIATE_VALUE_SUFFIX);
 
  return s!=NULL;
}

References external_value_name(), and INTERMEDIATE_VALUE_SUFFIX.

Referenced by transformer_internal_consistency_p(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

local_intermediate_value_entity_p()

bool local_intermediate_value_entity_p

(

entity

e

)

this is not a general test; it will only work for LOCAL values

Definition at line 648 of file value.c.

{
  /* this is not a general test; it will only work for LOCAL values */
  return strncmp(entity_local_name(e), INTERMEDIATE_VALUE_PREFIX, 2) == 0;
}

References entity_local_name(), and INTERMEDIATE_VALUE_PREFIX.

Here is the call graph for this function:

local_old_value_entity_p()

bool local_old_value_entity_p

(

entity

e

)

Return true if an entity is a local old value (such as "o#0" for a global value "i#init"...).

This is not a general test; it will only work for LOCAL values

Definition at line 642 of file value.c.

{
  /* This is not a general test; it will only work for LOCAL values */
  return strncmp(entity_local_name(e), OLD_VALUE_PREFIX, 2) == 0;
}

References entity_local_name(), and OLD_VALUE_PREFIX.

Referenced by add_type_information(), and regions_transformer_apply().

Here is the call graph for this function:

Here is the caller graph for this function:

local_temporary_value_entity_p()

bool local_temporary_value_entity_p

(

entity

e

)

this is not a general test; it will only work for LOCAL values

Definition at line 654 of file value.c.

{
  /* this is not a general test; it will only work for LOCAL values */
  return strncmp(entity_local_name(e), TEMPORARY_VALUE_PREFIX, 2) == 0;
}

References entity_local_name(), and TEMPORARY_VALUE_PREFIX.

Referenced by generic_transformer_to_analyzed_locations(), generic_value_name(), non_local_temporary_value_entity_p(), old_value_entity_p(), readable_value_name(), transformer_add_sign_information(), transformer_projection_with_redundancy_elimination_and_check(), transformer_temporary_value_projection(), transformer_to_potential_stub_translation(), transformer_with_temporary_values_p(), and value_mappings_compatible_vector_p().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_intermediate_value_entity()

static entity make_local_intermediate_value_entity ( type  t )

static

Definition at line 600 of file value.c.

{
  return make_local_value_entity(local_intermediate_value_counter++, 1, t);
}

References local_intermediate_value_counter, and make_local_value_entity().

Referenced by add_intermediate_value(), and add_local_intermediate_value().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_old_value_entity()

static entity make_local_old_value_entity ( type  t )

static

Definition at line 595 of file value.c.

{
  return make_local_value_entity(local_old_value_counter++, 0, t);
}

References local_old_value_counter, and make_local_value_entity().

Referenced by add_local_old_value().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_temporary_integer_value_entity()

entity make_local_temporary_integer_value_entity

(

void

)

Definition at line 629 of file value.c.

{
  basic b = make_basic(is_basic_int, (void *) 4);
  type t = make_type(is_type_variable, make_variable(b, NIL,NIL));
  entity tmp = make_local_value_entity(local_temporary_value_counter++, 2, t);
 
  free_type(t);
  return tmp;
}

References free_type(), is_basic_int, is_type_variable, local_temporary_value_counter, make_basic(), make_local_value_entity(), make_type(), make_variable(), and NIL.

Referenced by add_type_information(), bitwise_xor_to_transformer(), logical_not_to_transformer(), modulo_to_transformer(), transformer_add_condition_information_updown(), transformer_derivative_fix_point(), and transformer_list_generic_transitive_closure().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_temporary_value_entity()

entity make_local_temporary_value_entity

(

type

t

)

FI: is it easier to admit value of type void than to make a special case? Let see if it works... No, it's not a good idea because value are assumed of type variable in many places.

Definition at line 605 of file value.c.

{
  entity tv = entity_undefined;
 
  /* FI: is it easier to admit value of type void than to make a
     special case? Let see if it works... No, it's not a good idea
     because value are assumed of type variable in many places. */
  if(analyzed_type_p(t))
    tv = make_local_value_entity(local_temporary_value_counter++, 2, t);
  else
    pips_internal_error("Request for a temporary value with a non analyzed type.\n");
 
  return tv;
}

References analyzed_type_p(), entity_undefined, local_temporary_value_counter, make_local_value_entity(), and pips_internal_error.

Referenced by add_formal_to_actual_bindings(), add_index_bound_conditions(), add_type_information(), addition_operation_to_transformer(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), assigned_expression_to_transformer(), assigned_expression_to_transformer_list(), call_to_transformer(), expression_multiply_sizeof_to_transformer(), expression_to_transformer(), generic_abs_to_transformer(), generic_minmax_to_transformer(), iabs_to_transformer(), integer_binary_operation_to_transformer(), integer_expression_and_precondition_to_integer_interval(), integer_left_shift_to_transformer(), integer_minmax_to_transformer(), integer_multiply_to_transformer(), logical_binary_operation_to_transformer(), logical_unary_operation_to_transformer(), loop_bound_evaluation_to_transformer(), loop_to_enter_transformer(), unary_minus_operation_to_transformer(), update_cp_with_rhs_to_transformer(), update_operation_to_transformer(), and value_passing_summary_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_temporary_value_entity_with_basic()

entity make_local_temporary_value_entity_with_basic

(

basic

b

)

Definition at line 620 of file value.c.

{
  type t = make_type(is_type_variable, make_variable(copy_basic(b), NIL,NIL));
  entity tmp = make_local_value_entity(local_temporary_value_counter++, 2, t);
 
  free_type(t);
  return tmp;
}

References copy_basic(), free_type(), is_type_variable, local_temporary_value_counter, make_local_value_entity(), make_type(), make_variable(), and NIL.

Referenced by condition_to_transformer(), precondition_minmax_of_expression(), and transformer_add_any_relation_information().

Here is the call graph for this function:

Here is the caller graph for this function:

make_local_value_entity()

static entity make_local_value_entity ( int  n, int  nature, type  t  )

static

LOCAL VALUE ENTITY.

static entity make_local_value_entity(int n, bool old): find or generate an entity representing an old or an intermediate value of number n

13 is a magic number that can accommodate 2 prefix characters, 10 digits and a null character

find entity or define it

Another option might be to undefine types when counters are reset?

It is likely to take longer to compare types than to free one and allocate one...

Well, type_equal_p() replaces typedefs types by the underlying type which leads to disasters; see suppress_dead_code04.c

The previous test always returns true for strings

Definition at line 547 of file value.c.

{
  entity v;
  /* 13 is a magic number that can accommodate 2 prefix characters,
     10 digits and a null character */
  char value_name[13];
  char * s;
 
  if(nature==0)
    (void) strcpy(value_name, OLD_VALUE_PREFIX);
  else if(nature==1)
    (void) strcpy(value_name, INTERMEDIATE_VALUE_PREFIX);
  else
    (void) strcpy(value_name, TEMPORARY_VALUE_PREFIX);
  (void) sprintf(value_name+2,"%d",n);
  pips_debug(8,"value name: %s\n",value_name);
  s = strdup(concatenate(SEMANTICS_MODULE_NAME,
                         MODULE_SEP_STRING, value_name, (char *) NULL));
 
  /* find entity or define it */
  v = gen_find_tabulated(s, entity_domain);
  if(v==entity_undefined)
    v = make_entity(s,
          copy_type(t),
          make_storage(is_storage_rom, UU),
          value_undefined);
  else {
    free(s);
    /* Another option might be to undefine types when counters are
       reset? */
    /* It is likely to take longer to compare types than to free one and
       allocate one... */
    /* Well, type_equal_p() replaces typedefs types by the underlying
       type which leads to disasters; see suppress_dead_code04.c */
    if(true || type_equal_p(entity_type(v), t)) {
      free_type(entity_type(v));
      entity_type(v) = copy_type(t);
    }
    else if(basic_string_p(variable_basic(type_variable(entity_type(v))))) {
      /* The previous test always returns true for strings */
      free_type(entity_type(v));
      entity_type(v) = copy_type(t);
    }
  }
 
  return v;
}

References basic_string_p, concatenate(), copy_type(), entity_domain, entity_type, entity_undefined, free(), free_type(), gen_find_tabulated(), INTERMEDIATE_VALUE_PREFIX, is_storage_rom, make_entity, make_storage(), MODULE_SEP_STRING, OLD_VALUE_PREFIX, pips_debug, SEMANTICS_MODULE_NAME, strdup(), TEMPORARY_VALUE_PREFIX, type_equal_p(), type_variable, UU, value_undefined, and variable_basic.

Referenced by make_local_intermediate_value_entity(), make_local_old_value_entity(), make_local_temporary_integer_value_entity(), make_local_temporary_value_entity(), and make_local_temporary_value_entity_with_basic().

Here is the call graph for this function:

Here is the caller graph for this function:

mapping_to_domain_list()

static list mapping_to_domain_list ( hash_table  h )

static

Returns the list of entities in the mapping domain.

Could be more efficient to return a set.

Note: this is a copy of mapping_to_value_number()

Definition at line 1048 of file value.c.

{
  size_t count = 0;
  list values = NIL;
 
  HASH_MAP(var, val, {
    if(!gen_in_list_p((entity) val, values)) {
      values = CONS(ENTITY,(entity) var, values);
      count++;
    }
  }, h);
 
  pips_assert("The number of insertions is equal to the list length",
              count == gen_length(values));
 
  return values;
}

References CONS, count, ENTITY, gen_in_list_p(), gen_length(), HASH_MAP, NIL, and pips_assert.

Referenced by modified_variables_with_values().

Here is the call graph for this function:

Here is the caller graph for this function:

mapping_to_value_number()

static int mapping_to_value_number ( hash_table  h )

static

Definition at line 1024 of file value.c.

{
  size_t count = 0;
  list values = NIL;
 
  HASH_MAP(var, val, {
    if(!gen_in_list_p((entity) val, values)) {
      values = CONS(ENTITY,(entity) val, values);
      count++;
    }
  }, h);
 
  pips_assert("The number of insertions is equal to the list length",
              count == gen_length(values));
  gen_free_list(values);
  return count;
}

References CONS, count, ENTITY, gen_free_list(), gen_in_list_p(), gen_length(), HASH_MAP, NIL, and pips_assert.

Referenced by test_mapping_entry_consistency().

Here is the call graph for this function:

Here is the caller graph for this function:

modified_variables_with_values()

list modified_variables_with_values

(

void

)

Return the list of all analyzed variables which are modified in the current module.

If they are modified, they must have old values.

The intermediate values could be used as well

Definition at line 1094 of file value.c.

{
  /* The intermediate values could be used as well */
  /*
  list ivl = mapping_to_domain_list(hash_entity_to_old_value); // initial
                                                               // value list
  list wvl = NIL; // written variable list
 
  FOREACH(ENTITY, e, ivl) {
    entity wv = new_value_to_variable(e);
    ivl = CONS(ENTITY, wv, ivl);
  }
 
  gen_reverse(wvl);
  */
  list wvl = mapping_to_domain_list(hash_entity_to_old_value);
  return wvl;
}

References hash_entity_to_old_value, and mapping_to_domain_list().

Referenced by apply_abstract_effect_to_transformer(), generic_reference_to_transformer(), and transformer_combine().

Here is the call graph for this function:

Here is the caller graph for this function:

new_value_entity_p()

bool new_value_entity_p

(

entity

e

)

the following three functions are directly or indirectly relative to the current module and its value hash tables.

since new values are always variable entities, hash_entity_to_new_value can be used for this test

Definition at line 925 of file value.c.

{
  /* since new values are always variable entities, hash_entity_to_new_value
     can be used for this test */
 
  pips_assert("new_value_entity_p",e != entity_undefined);
 
  return (entity) hash_get(hash_entity_to_new_value, (char *) e)
    == e;
}

References entity_undefined, hash_entity_to_new_value, hash_get(), and pips_assert.

Referenced by build_transfer_matrix(), equations_to_bases(), invariant_vector_p(), look_for_the_best_counter(), new_value_in_transfer_equation(), transfer_equation_p(), transformer_internal_consistency_p(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

new_value_to_old_value()

entity new_value_to_old_value

(

entity

n_val

)

FI: correct code entity var = entity_undefined;

var = value_to_variable(n_val); o_val = entity_to_old_value(var);

FI: faster code

Parameters

n_val

_val

Definition at line 1710 of file value.c.

{
  entity o_val = entity_undefined;
 
  /* FI: correct code
     entity var = entity_undefined;
 
     var = value_to_variable(n_val);
     o_val = entity_to_old_value(var);
  */
 
  /* FI: faster code */
  o_val = entity_to_old_value(n_val);
 
  return o_val;
}

References entity_to_old_value(), and entity_undefined.

Referenced by transformer_equality_fix_point(), and upwards_vect_rename().

Here is the call graph for this function:

Here is the caller graph for this function:

non_local_temporary_value_entity_p()

static bool non_local_temporary_value_entity_p ( entity  e )

static

Definition at line 660 of file value.c.

{
  return !local_temporary_value_entity_p(e);
}

References local_temporary_value_entity_p().

Referenced by vect_variables_to_values().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_analyzed_values()

int number_of_analyzed_values

(

void

)

Definition at line 1148 of file value.c.

{
  return hash_table_entry_count(hash_value_to_name);
}

References hash_table_entry_count(), and hash_value_to_name.

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_analyzed_variables()

int number_of_analyzed_variables

(

void

)

FI: looks more like the number of values used.

Definition at line 1160 of file value.c.

{
  return hash_table_entry_count(hash_value_to_name);
}

References hash_table_entry_count(), and hash_value_to_name.

Here is the call graph for this function:

number_of_temporary_values()

int number_of_temporary_values

(

void

)

Definition at line 255 of file value.c.

{
  return local_temporary_value_counter;
}

References local_temporary_value_counter.

Referenced by transformer_temporary_value_projection(), and transformer_with_temporary_values_p().

Here is the caller graph for this function:

old_value_entity_p()

bool old_value_entity_p

(

entity

e

)

Temporary values do not have an external name.

OLD_VALUE_PREFIX is not used for global old values

string s = strstr(external_value_name(e), OLD_VALUE_SUFFIX);

string s = strstr(entity_local_name(e), OLD_VALUE_PREFIX);

Definition at line 936 of file value.c.

{
  /* Temporary values do not have an external name. */
  /* OLD_VALUE_PREFIX is not used for global old values */
  /* string s = strstr(external_value_name(e), OLD_VALUE_SUFFIX); */
  /* string s = strstr(entity_local_name(e), OLD_VALUE_PREFIX); */
 
  if(!local_temporary_value_entity_p(e)) {
    string s1 = strstr(entity_local_name(e), OLD_VALUE_SUFFIX);
    // Need to remake the search for OLD_VALUE_PREFIX
    // bug for toto#...
    string s2 = strstr(entity_local_name(e), OLD_VALUE_PREFIX);
    // s2==entity_local_name(e) : for the case toto#...
    return s1!=NULL || (s2!=NULL && s2==entity_local_name(e));
  }
  else
    return false;
}

References entity_local_name(), local_temporary_value_entity_p(), OLD_VALUE_PREFIX, OLD_VALUE_SUFFIX, and s1.

Referenced by expression_less_than_in_context(), invariant_vector_p(), look_for_the_best_counter(), my_system_remove_variables(), precondition_filter_old_values(), print_call_precondition(), remove_temporal_variables_from_system(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_general_consistency_p(), transformer_internal_consistency_p(), transformer_list_generic_transitive_closure(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

old_value_to_new_value()

entity old_value_to_new_value

(

entity

o_val

)

o_val = variable_to_old_value(var);

Parameters

o_val

_val

Definition at line 1698 of file value.c.

{
  entity var = entity_undefined;
  entity n_val = entity_undefined;
 
  var = value_to_variable(o_val);
  /* o_val = variable_to_old_value(var); */
  n_val = entity_to_new_value(var);
 
  return n_val;
}

References entity_to_new_value(), entity_undefined, and value_to_variable().

Referenced by build_transfer_matrix(), and equations_to_bases().

Here is the call graph for this function:

Here is the caller graph for this function:

pips_user_value_name()

const char* pips_user_value_name

(

entity

e

)

This function is called many times when the constraints and the system of constraints are sorted using lexicographic information based on this particular value name.

See for instance Semantics-New/freia_52.c. Hence it is memorized.

Definition at line 815 of file value.c.

{
  pips_debug(9, "start with entity : %s\n", entity_name(e));
  const char* uvn = string_undefined;
 
  if(e == (entity) TCST) {
    uvn = "";
  }
  else {
    // To check the execution speed, uncomment the next line
    // return entity_name(e);
    uvn = hash_get(hash_entity_to_user_value_name, (char *) e);
 
    if(uvn==HASH_UNDEFINED_VALUE) {
      // Need to discriminate the case of an address_of value
      // because the hash table are reset between each pass
      if (address_of_value_entity_p(e)) {
        entity v = value_to_variable(e);
        string temp = strdup(entity_name(e));
        string indice = strstr(temp, "[");
        if (indice != NULL)
          *(indice+strlen(indice)-strlen(ADDRESS_OF_SUFFIX)) = '\0';
        uvn = strdup(concatenate("&", entity_user_name(v), indice, (char *) NULL));
        free(temp);
      }
      else if (null_pointer_value_entity_p(e)) {
        uvn = strdup("NULL");
      }
      else if (sizeof_value_entity_p(e)) {
        type t = entity_type(e);
        uvn = strdup(concatenate("sizeof(", type_to_full_string_definition(t), ")", (char *) NULL));
      }
      else {
        (void) gen_check((gen_chunk *) e, entity_domain);
        uvn = entity_has_values_p(e)? (string)entity_minimal_name(e) :
            external_value_name(e);
      }
        hash_put(hash_entity_to_user_value_name, (char *) e, uvn);
    }
  }
  pips_debug(9, "end with string : %s\n", uvn);
  return uvn;
}

References ADDRESS_OF_SUFFIX, address_of_value_entity_p(), concatenate(), entity_domain, entity_has_values_p(), entity_minimal_name(), entity_name, entity_type, entity_user_name(), external_value_name(), free(), gen_check(), hash_entity_to_user_value_name, hash_get(), hash_put(), HASH_UNDEFINED_VALUE, null_pointer_value_entity_p(), pips_debug, sizeof_value_entity_p(), strdup(), string_undefined, TCST, type_to_full_string_definition(), and value_to_variable().

Referenced by generic_value_name(), is_inferior_pvarval(), semantics_is_inferior_pvarval(), text_continuation(), and text_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

pointer_analyzed_p()

bool pointer_analyzed_p

(

void

)

Definition at line 325 of file value.c.

{
  return analyze_pointer_scalar_entities;
}

References analyze_pointer_scalar_entities.

Referenced by any_expression_to_transformer().

Here is the caller graph for this function:

print_value_mappings()

void print_value_mappings

(

void

)

Definition at line 993 of file value.c.

{
  (void) fprintf(stderr,"\nhash table value to name:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)dump_value_name, (gen_string_func_t)string_identity,
                     hash_value_to_name);
 
  (void) fprintf(stderr,"\nhash table entity to new value:\n");
  /*
    hash_table_fprintf(stderr, entity_local_name, external_value_name,
    hash_entity_to_new_value);
  */
  hash_table_fprintf(stderr, (gen_string_func_t)entity_minimal_name, (gen_string_func_t)entity_minimal_name,
                     hash_entity_to_new_value);
 
  (void) fprintf(stderr,"\nhash table entity to old value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)entity_minimal_name, (gen_string_func_t)external_value_name,
                     hash_entity_to_old_value);
 
  (void) fprintf(stderr, "\nhash table entity to intermediate value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)entity_minimal_name, (gen_string_func_t)external_value_name,
                         hash_entity_to_intermediate_value);
 
  (void) fprintf(stderr, "\nhash table reference to address_of value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)reference_to_string, (gen_string_func_t)external_value_name,
                         hash_reference_to_address_of_value);
 
  (void) fprintf(stderr, "\nhash table entity to sizeof value:\n");
  hash_table_fprintf(stderr, (gen_string_func_t)type_to_full_string_definition, (gen_string_func_t)external_value_name,
                         hash_type_to_sizeof_value);
}

References dump_value_name(), entity_minimal_name(), external_value_name(), fprintf(), hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_reference_to_address_of_value, hash_table_fprintf(), hash_type_to_sizeof_value, hash_value_to_name, reference_to_string(), string_identity(), and type_to_full_string_definition().

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

readable_value_name()

const char* readable_value_name

(

entity

v

)

For debugging purposes, we might have to print system with temporary values.

Definition at line 1769 of file value.c.

{
  const char* n ;
 
  if(local_temporary_value_entity_p(v)) {
    n = entity_local_name(v);
  }
  else {
    n = external_value_name(v);
  }
 
  return n;
}

References entity_local_name(), external_value_name(), and local_temporary_value_entity_p().

Referenced by generic_module_name_to_transformers(), module_name_to_preconditions(), and module_name_to_total_preconditions().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_to_address_entity()

entity reference_to_address_entity

(

reference

r

)

The address is the address of a variable or of a reference such as &a[5], not a of a value.

The reference must be a constant memory access path. It does not have to be atomic, as struct are not considered atomic, following Pierre Jouvelot's view point since partial updates are possible.

An address is a constant within a C user function.

As a constant, it must be encoded as a 0-ary function, just like 1.0 or true.

We use the user representation as entity name, namey &a[5].

We do not use array names as constant pointers because they alreay are entities with types and storage. So the address of array a is &a[0].

References can be points-to references, i.e. fields can be encoded as indices.

trict_constant_path_p(r)

Should this local constant be added to the module declarations ?

Definition at line 1285 of file value.c.

{
  entity a = entity_undefined;
  // if(can_be_constant_path_p(r) /*strict_constant_path_p(r)*/) {
  /*strict_constant_path_p(r)*/
  if(store_independent_points_to_reference_p(r)) {
    entity v = reference_variable(r);
    /* Should this local constant be added to the module declarations ? */
    string mn = (string) entity_module_name(v);
    string ln = strdup(concatenate("&", reference_to_string(r), NULL));
    type t = points_to_reference_to_concrete_type(r);
    type ft = make_type_functional(make_functional(NIL, copy_type(t)));
    a = FindOrCreateEntity(mn, ln);
    entity_type(a) = ft;
    entity_storage(a) = make_storage_rom();
    expression re = reference_to_expression(copy_reference(r));
    expression i = unary_intrinsic_expression(ADDRESS_OF_OPERATOR_NAME, re);
    symbolic s = make_symbolic(i, make_constant_unknown());
    entity_initial(a) = make_value_symbolic(s);
    entity_kind(a) = DEFAULT_ENTITY_KIND;
  }
  return a;
}

References ADDRESS_OF_OPERATOR_NAME, concatenate(), copy_reference(), copy_type(), DEFAULT_ENTITY_KIND, entity_initial, entity_kind, entity_module_name(), entity_storage, entity_type, entity_undefined, FindOrCreateEntity(), make_constant_unknown(), make_functional(), make_storage_rom(), make_symbolic(), make_type_functional(), make_value_symbolic(), NIL, points_to_reference_to_concrete_type(), reference_to_expression(), reference_to_string(), reference_variable, store_independent_points_to_reference_p(), strdup(), and unary_intrinsic_expression.

Here is the call graph for this function:

reference_to_address_of_value()

entity reference_to_address_of_value

(

reference

r

)

Definition at line 889 of file value.c.

{
  entity n;
  if((n = (entity) hash_get(hash_reference_to_address_of_value, (char *) r))
      == entity_undefined)
    pips_internal_error("unbounded reference %s",
        reference_to_string(r));
  return n;
}

References entity_undefined, hash_get(), hash_reference_to_address_of_value, pips_internal_error, and reference_to_string().

Here is the call graph for this function:

remove_entity_values()

void remove_entity_values	(	entity	e,
		bool	readonly
	)

pips_assert("remove_entity_values", e != entity_undefined);

Parameters

readonly

eadonly

Definition at line 1545 of file value.c.

{
  entity new_value = entity_to_new_value(e);
  const char* s;
 
  /* pips_assert("remove_entity_values", e != entity_undefined); */
  pips_assert("remove_entity_values", new_value != entity_undefined);
 
  s = external_value_name(new_value);
  pips_assert("remove_entity_values", s != (char *) NULL);
  (void) hash_del(hash_value_to_name, (char *) new_value);
  (void) hash_del(hash_entity_to_new_value, (char *) e);
 
  if(!readonly) {
    entity old_value = entity_to_old_value(e);
    entity intermediate_value = entity_to_intermediate_value(e);
 
    pips_assert("remove_entity_values", old_value != entity_undefined);
    pips_assert("remove_entity_values",
                intermediate_value!=entity_undefined);
 
    s = external_value_name(old_value);
    pips_assert("remove_entity_values", s != (char *) NULL);
    (void) hash_del(hash_value_to_name, (char *) old_value);
    s = external_value_name(intermediate_value);
    pips_assert("remove_entity_values", s != (char *) NULL);
    (void) hash_del(hash_value_to_name, (char *) intermediate_value);
 
    (void) hash_del(hash_entity_to_old_value, (char *) e);
    (void) hash_del(hash_entity_to_intermediate_value, (char *) e);
  }
}

References entity_to_intermediate_value(), entity_to_new_value(), entity_to_old_value(), entity_undefined, external_value_name(), hash_del(), hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_value_to_name, and pips_assert.

Referenced by add_or_kill_equivalenced_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_analyzed_types()

void reset_analyzed_types

(

void

)

Definition at line 289 of file value.c.

{
  analyze_integer_scalar_entities = true;
  analyze_boolean_scalar_entities = false;
  analyze_string_scalar_entities = false;
  analyze_float_scalar_entities = false;
  analyze_complex_scalar_entities = false;
  analyze_pointer_scalar_entities = false;
  analyze_constant_path = false;
}

References analyze_boolean_scalar_entities, analyze_complex_scalar_entities, analyze_constant_path, analyze_float_scalar_entities, analyze_integer_scalar_entities, analyze_pointer_scalar_entities, and analyze_string_scalar_entities.

Referenced by error_free_value_mappings(), and eval_linear_expression().

Here is the caller graph for this function:

reset_temporary_value_counter()

void reset_temporary_value_counter

(

void

)

Definition at line 250 of file value.c.

{
  local_temporary_value_counter = 0;
}

References local_temporary_value_counter.

Referenced by add_index_bound_conditions(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), call_to_transformer(), error_free_value_mappings(), loop_bound_evaluation_to_transformer(), module_to_value_mappings(), precondition_add_condition_information(), test_to_transformer(), test_to_transformer_list(), and transformer_add_condition_information().

Here is the caller graph for this function:

reset_value_counters()

void reset_value_counters

(

void

)

Definition at line 244 of file value.c.

{
  local_old_value_counter = 0;
  local_intermediate_value_counter = 0;
}

References local_intermediate_value_counter, and local_old_value_counter.

Referenced by module_to_value_mappings().

Here is the caller graph for this function:

reset_value_mappings()

static void reset_value_mappings ( void  )

static

Definition at line 1188 of file value.c.

{
  hash_entity_to_new_value = hash_table_undefined;
  hash_entity_to_old_value = hash_table_undefined;
  hash_entity_to_intermediate_value = hash_table_undefined;
  hash_value_to_name = hash_table_undefined;
  hash_entity_to_user_value_name = hash_table_undefined;
  hash_reference_to_address_of_value = hash_table_undefined;
  hash_type_to_sizeof_value = hash_table_undefined;
}

References hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_entity_to_user_value_name, hash_reference_to_address_of_value, hash_table_undefined, hash_type_to_sizeof_value, and hash_value_to_name.

Referenced by error_free_value_mappings(), and error_reset_value_mappings().

Here is the caller graph for this function:

set_analyzed_types()

void set_analyzed_types

(

void

)

Definition at line 271 of file value.c.

{
  analyze_integer_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_INTEGER_VARIABLES");
  analyze_boolean_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_BOOLEAN_VARIABLES");
  analyze_string_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_STRING_VARIABLES");
  analyze_float_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_FLOAT_VARIABLES");
  analyze_complex_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_COMPLEX_VARIABLES");
  analyze_pointer_scalar_entities =
    get_bool_property("SEMANTICS_ANALYZE_SCALAR_POINTER_VARIABLES");
  analyze_constant_path =
    get_bool_property("SEMANTICS_ANALYZE_CONSTANT_PATH");
}

References analyze_boolean_scalar_entities, analyze_complex_scalar_entities, analyze_constant_path, analyze_float_scalar_entities, analyze_integer_scalar_entities, analyze_pointer_scalar_entities, analyze_string_scalar_entities, and get_bool_property().

Referenced by eval_linear_expression(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

sizeof_value_entity_p()

bool sizeof_value_entity_p

(

entity

e

)

Definition at line 969 of file value.c.

{
  string s = strstr(entity_local_name(e), SIZEOF_SUFFIX);
 
  return s!=NULL;
}

References entity_local_name(), and SIZEOF_SUFFIX.

Referenced by have_sizeof_value_in_multiply_pointer_expression_p(), pips_user_value_name(), and value_to_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

string_analyzed_p()

bool string_analyzed_p

(

void

)

Definition at line 310 of file value.c.

{
  return analyze_string_scalar_entities;
}

References analyze_string_scalar_entities.

Referenced by any_expression_to_transformer(), fortran_data_to_prec_for_variables(), and parametric_transformer_empty_p().

Here is the caller graph for this function:

string_identity()

static string string_identity ( string  s )

static

used with hash_table_fprintf

Definition at line 990 of file value.c.

{ return s;}

Referenced by print_value_mappings().

Here is the caller graph for this function:

test_mapping_entry_consistency()

void test_mapping_entry_consistency

(

void

)

This second assert is too strong when some analyzable variables are equivalenced together. The number of values required is smaller since two (or more) different variables share the same value: the number of entries in the tables is greater than the number of values. We must compute the number of values in each table.

Why greater instead of equal? Because the equivalence variable appears in the equivalence equations although it should never appear in regular constraints, except under its canonical name.

Definition at line 1113 of file value.c.

{
  int nbo = 0;
  int nbi = 0;
  int nbn = 0;
 
  pips_assert("The number of old values is equal to the number of intermediate values",
              ((nbo= hash_table_entry_count(hash_entity_to_old_value))
               == (nbi= hash_table_entry_count(hash_entity_to_intermediate_value))));
  /* This second assert is too strong when some analyzable variables are
     equivalenced together. The number of values required is smaller
     since two (or more) different variables share the same value: the
     number of entries in the tables is greater than the number of
     values. We must compute the number of values in each table.
  */
  /*
    pips_assert("The number of values is greater than the number"
    " of new, old and intermediate values",
    hash_table_entry_count(hash_value_to_name) >=
    hash_table_entry_count(hash_entity_to_new_value)
    + nbo + nbi);
  */
  nbo = mapping_to_value_number(hash_entity_to_old_value);
  nbi = mapping_to_value_number(hash_entity_to_intermediate_value);
  nbn = mapping_to_value_number(hash_entity_to_new_value);
 
  /* Why greater instead of equal? Because the equivalence variable
     appears in the equivalence equations although it should never
     appear in regular constraints, except under its canonical name. */
  pips_assert("The number of values with a name is greater than the number"
              " of new, old and intermediate values",
              hash_table_entry_count(hash_value_to_name) >=
              nbn + nbo + nbi);
}

References hash_entity_to_intermediate_value, hash_entity_to_new_value, hash_entity_to_old_value, hash_table_entry_count(), hash_value_to_name, mapping_to_value_number(), and pips_assert.

Referenced by module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

type_to_sizeof_value()

entity type_to_sizeof_value

(

type

t

)

Definition at line 899 of file value.c.

{
  entity i;
  if((i = (entity) hash_get(hash_type_to_sizeof_value, (char *) t))
      == entity_undefined)
    pips_internal_error("unbounded type %s : %s",
        type_to_string(t), type_to_full_string_definition(t));
  return i;
}

References entity_undefined, hash_get(), hash_type_to_sizeof_value, pips_internal_error, type_to_full_string_definition(), and type_to_string().

Referenced by expression_multiply_sizeof_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

value_alias()

entity value_alias

(

entity

e

)

Static aliasing.

useful for Fortran, useless for C. When no alias is found, an undefined entity must be returned.

lookup the current value name mapping and return an arbitrary "representant" of the interprocedural alias set of e; the equivalence relation is "has same location"

Definition at line 1729 of file value.c.

{
  entity a = entity_undefined;
 
  pips_debug(8,"begin: for %s\n", entity_name(e));
 
  /* lookup the current value name mapping and return an arbitrary "representant"
     of the interprocedural alias set of e; the equivalence relation is "has
     same location" */
  HASH_FOREACH(entity, var, string, val, hash_value_to_name) {
    if(variable_entity_p(var)
       && entities_may_conflict_p(var, e)) {
      a = var;
      break;
    }
  }
 
  if(a==entity_undefined)
    pips_debug(8, "return: %s\n", "entity_undefined");
  else
    pips_debug(8, "return: %s\n", entity_name(a));
 
  return a;
}

References entities_may_conflict_p(), entity_name, entity_undefined, HASH_FOREACH, hash_value_to_name, pips_debug, and variable_entity_p().

Referenced by add_interprocedural_new_value_entity(), add_interprocedural_value_entities(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

value_entity_p()

bool value_entity_p

(

entity

e

)

tells if e is seen as a variable value in the current module

Definition at line 976 of file value.c.

{
  /* tells if e is seen as a variable value in the current module */
  string s = hash_get(hash_value_to_name, (char *) e);
 
  if(s == (char*) HASH_UNDEFINED_VALUE) {
    return false;
  }
  else {
    return true;
  }
}

References hash_get(), HASH_UNDEFINED_VALUE, and hash_value_to_name.

Referenced by generic_value_name(), transformer_add_sign_information(), transformer_filter_subsumed_variables(), and translate_global_value().

Here is the call graph for this function:

Here is the caller graph for this function:

value_full_name()

string value_full_name

(

entity

v

)

for debugging purposes

Definition at line 1762 of file value.c.

{
  return entity_name(v);
}

References entity_name.

Referenced by parametric_transformer_empty_p().

Here is the caller graph for this function:

value_to_variable()

entity value_to_variable

(

entity

val

)

Get the primitive variable associated to any value involved in a transformer.

For example can associate values such as "o#0" to "i" (via "i#init").

This function used to be restricted to values seen by the current module. It was extended to values in general to cope with translation issues.

for gcc only!

pips_assert("value_to_variable", s != HASH_UNDEFINED_VALUE);

pips_assert("value_to_variable", strchr(entity_name(val), (int) SEMANTICS_SEPARATOR) != NULL);

this may be a value, but it is unknown in the current module

new values in fact have no suffixes...

It can be an equivalenced variable... Additional testing should be performed!

Parameters

val

al

Definition at line 1624 of file value.c.

{
  entity var = entity_undefined;
  int l_suffix = -1; /* for gcc only! */
  string s = hash_get(hash_value_to_name, (char *) val);
  string var_name;
 
  /* pips_assert("value_to_variable", s != HASH_UNDEFINED_VALUE); */
 
  /* pips_assert("value_to_variable",
     strchr(entity_name(val), (int) SEMANTICS_SEPARATOR) != NULL); */
 
  // TODO : Maybe redesign the search of suffix/prefix
  //        Can bug if the variable name is/begin/end with
  //        o, i, t, new, init, int, address_of see SUFFIX and PREFIX in transformer.h
  if(s == HASH_UNDEFINED_VALUE) {
    /* this may be a value, but it is unknown in the current module */
    string val_name = entity_name(val);
 
    if(strstr(val_name, NEW_VALUE_SUFFIX) != NULL)
      l_suffix = strlen(NEW_VALUE_SUFFIX);
    else if(strstr(val_name, OLD_VALUE_SUFFIX) != NULL)
      l_suffix = strlen(OLD_VALUE_SUFFIX);
    else if(strstr(val_name, INTERMEDIATE_VALUE_SUFFIX) != NULL)
      l_suffix = strlen(INTERMEDIATE_VALUE_SUFFIX);
    else if(strstr(val_name, ADDRESS_OF_SUFFIX) != NULL)
      l_suffix = strlen(ADDRESS_OF_SUFFIX);
    else if(strstr(val_name, SIZEOF_SUFFIX) != NULL)
      l_suffix = 0;
    else if(strchr(val_name, (int) SEMANTICS_SEPARATOR) == NULL) {
      /* new values in fact have no suffixes... */
      l_suffix = 0;
    }
    else
      pips_internal_error("%s is not a non-local value", entity_name(val));
 
    s = val_name;
  }
  else {
    if(sizeof_value_entity_p(val))
      l_suffix = 0;
    else if(new_value_entity_p(val))
      l_suffix = strlen(NEW_VALUE_SUFFIX);
    else if(old_value_entity_p(val))
      l_suffix = strlen(OLD_VALUE_SUFFIX);
    else if(intermediate_value_entity_p(val))
      l_suffix = strlen(INTERMEDIATE_VALUE_SUFFIX);
    else if(address_of_value_entity_p(val))
      l_suffix = strlen(ADDRESS_OF_SUFFIX);
    else
      /* It can be an equivalenced variable... Additional testing
         should be performed! */
      pips_internal_error("%s is not a locally visible value",
                          entity_name(val));
  }
 
  var_name = strdup(s);
  *(var_name+strlen(var_name)-l_suffix) = '\0';
  if(address_of_value_entity_p(val)) {
    string temp = strstr(var_name, "[");
    if(temp != NULL)
      *temp = '\0';
  }
 
  var = gen_find_tabulated(var_name, entity_domain);
  free(var_name);
 
  if( var == entity_undefined )
    pips_internal_error("no related variable for val=%s",
                        entity_name(val));
 
  return var;
}

References ADDRESS_OF_SUFFIX, address_of_value_entity_p(), entity_domain, entity_name, entity_undefined, free(), gen_find_tabulated(), hash_get(), HASH_UNDEFINED_VALUE, hash_value_to_name, intermediate_value_entity_p(), INTERMEDIATE_VALUE_SUFFIX, new_value_entity_p(), NEW_VALUE_SUFFIX, old_value_entity_p(), OLD_VALUE_SUFFIX, pips_internal_error, SEMANTICS_SEPARATOR, SIZEOF_SUFFIX, sizeof_value_entity_p(), and strdup().

Referenced by add_address_of_value(), add_loop_index_exit_value(), add_type_information(), any_assign_operation_to_transformer(), any_scalar_assign_to_transformer_list(), any_scalar_assign_to_transformer_without_effect(), fortran_user_call_to_transformer(), generic_transformer_intra_to_inter(), generic_transformer_to_analyzed_locations(), invariant_vector_p(), look_for_the_best_counter(), old_value_to_new_value(), pips_user_value_name(), print_call_precondition(), transformer_add_variable_incrementation(), transformer_add_variable_update(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_formal_parameter_projection(), transformer_general_consistency_p(), transformer_list_generic_transitive_closure(), transformer_projection_with_redundancy_elimination_and_check(), transformer_return_value_projection(), transformer_to_analyzed_arrays(), transformer_to_local_values(), transformer_to_potential_stub_translation(), and value_passing_summary_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_variables_to_values()

Pvecteur vect_variables_to_values

(

Pvecteur

v

)

FI: not used, not debugged.

Definition at line 1755 of file value.c.

{
  v = vect_rename_variables(v, (bool (*)(Variable)) non_local_temporary_value_entity_p, (Variable (*)(Variable)) entity_to_new_value);
  return v;
}

References entity_to_new_value(), non_local_temporary_value_entity_p(), and vect_rename_variables().

Here is the call graph for this function:

Variable Documentation

analyze_boolean_scalar_entities

bool analyze_boolean_scalar_entities = false

static

Definition at line 263 of file value.c.

Referenced by analyzed_basic_p(), boolean_analyzed_p(), reset_analyzed_types(), and set_analyzed_types().

analyze_complex_scalar_entities

bool analyze_complex_scalar_entities = false

static

Definition at line 266 of file value.c.

Referenced by analyzed_basic_p(), analyzed_constant_p(), complex_analyzed_p(), reset_analyzed_types(), and set_analyzed_types().

analyze_constant_path

bool analyze_constant_path = false

static

Definition at line 269 of file value.c.

Referenced by constant_path_analyzed_p(), reset_analyzed_types(), and set_analyzed_types().

analyze_float_scalar_entities

bool analyze_float_scalar_entities = false

static

Definition at line 265 of file value.c.

Referenced by analyzed_basic_p(), analyzed_constant_p(), float_analyzed_p(), reset_analyzed_types(), and set_analyzed_types().

analyze_integer_scalar_entities

bool analyze_integer_scalar_entities = true

static

TYPING.

Definition at line 262 of file value.c.

Referenced by analyzed_basic_p(), integer_analyzed_p(), reset_analyzed_types(), and set_analyzed_types().

analyze_pointer_scalar_entities

bool analyze_pointer_scalar_entities = false

static

Definition at line 267 of file value.c.

Referenced by analyzed_basic_p(), analyzed_constant_p(), pointer_analyzed_p(), reset_analyzed_types(), and set_analyzed_types().

analyze_string_scalar_entities

bool analyze_string_scalar_entities = false

static

Definition at line 264 of file value.c.

Referenced by analyzed_basic_p(), analyzed_constant_p(), reset_analyzed_types(), set_analyzed_types(), and string_analyzed_p().

hash_entity_to_intermediate_value

hash_table hash_entity_to_intermediate_value = hash_table_undefined

static

Definition at line 221 of file value.c.

Referenced by add_intermediate_alias_value(), add_intermediate_value(), add_local_intermediate_value(), add_synonym_values(), allocate_value_mappings(), entity_to_intermediate_value(), error_free_value_mappings(), print_value_mappings(), remove_entity_values(), reset_value_mappings(), and test_mapping_entry_consistency().

hash_entity_to_new_value

hash_table hash_entity_to_new_value = hash_table_undefined

static

VARIABLE VALUE MANAGEMENT PACKAGE FOR TRANSFORMERS.

Values of variables could be a new data structure or a special kind of entities. To avoid an increase in data structure declarations and an increased size for the implicit array of entities, values are often entities with special names. Their meaning is defined with respect to an environment defined at the module level and so, constant during the analysis of a module.

Constant values may be used as values. They are 0-ary functions. They are used to encode character strings. They are not dealt with by this package. It is possible to handle scalar floating point constants in the same way.

Temporary values may be used to denote expression values. These temporary values have no names. They are read only. They must be eliminated from long lasting data structures as their semantics is local to a single expression, usually a right hand side. Only the most basic entity printing routine can be used for such values.

Only scalar variables are analyzed.

Properties are used to select the variables types that are to be analyzed among integer, boolean, string, float and/or complex. Any combination of types is legal. Scalar variables of an analyzed type are said to be analyzable but they may be not analyzed because of some static aliasing (EQUIVALENCE).

Three different kind of variable values are used: new, old and intermediate. New values are used in post-condition predicates. Old values are used in pre-condition predicates. New and old values are also used in predicate transformers. Intermediate values are used to combine transformers.

New values are directly referenced by the corresponding scalar variable, a regular entity, with types integer, boolean, float, complex or string. However they are printed with a different name to avoid confusion between variables and values. The value name is the variable name, suffixed by "#new".

Old values and intermediate values are referenced via special entities, distinguished by their names made of a specific prefix followed by a number (see OLD_VALUE_PREFIX and INTERMEDIATE_VALUE_PREFIX in transformer.h).

The type of a value is the type of the associated entity. Equivalenced variables are handled only if they all have the same type.

Pre-values, a.k.a. old values, for local dynamic entities are named "o#XX", where "XX" is a number. A pre-value is associated to an entity via a hash table used by the function entity_to_old_value(). Static aliasing (i.e. EQUIVALENCEs) is dealed with by associating the same value entity to the two aliased variable entities.

Pre-values, a.k.a. old values, for analyzed scalar formal parameters and analyzed scalar global variables are represented by special entities named from the relevant variable entity, by suffixing its name by "#init". These values have to be represented by specific entities to let us consider parameter values at entry point and to let us perform interprocedural semantics analysis.

Intermediate values are referenced by special entities named "i#XX", which are reused from procedure to procedure. Within a procedure, each variable is linked to one intermediate value entity.

These conventions are used by value_to_name(e) to generate EXTERNAL names I::new, I::old and I::tmp and to print readable debug information.

To accelerate conversions between new, old and intermediate value entities, four hash tables must set up for each module before semantics analysis is started or used:

• hash_entity_to_new_value associates an entity representing a new value to each scalar variable with an analyzed type; this value entity is most of the time the variable entity itself and thus this hash table almost represents an identity function; however, perfectly equivalenced variables are represented by one of them only and some eligible analyzable scalar variables are not mapped to anything because they are equivalenced to an array
• hash_entity_to_old_value associates an entity representing an old value to each scalar analyzable variable
• hash_entity_to_intermediate_value
• hash_value_to_name: associates user-readable names to value entity; used for debugging and display purposes.

Francois Irigoin, December 1989 (updated June 2001,... August 2009)

Modifications:

• only integer variables used to be analyzed; the analysis is extended to strings, bool and floating point scalar variables (Francois Irigoin, 14 June 2001).
• temporary values are added to deal with subexpressions and to analyze non-linear expressions (Francois Irigoin, 14 June 2001).
• the three mappings between variable entities and value entities were done differently for each transformer and based on the arguments field; efficiency was limited because the mappings were based on lists and because transformers had to be renamed before they could be combined; aliasis information had to be computed at each step instead of being factored out at hashing time (Francois Irigoin, April 90)

*** assigments to array or to non integer scalar can now affect transformer on integer scalar variables (Francois Irigoin, April 90)*** no longer true - such integer scalar variables are just ignored; however, it would be easy to do slightly better (21 April 1990)

• old value suffix is now "#init" because it's nicer in prettyprinting predicates; it's also worse for transformer but they are less interesting for the users (Francois Irigoin, 18 April 1990)
• fourth hash_table entity->new_value added to handle EQUIVALENCEs (Francois Irigoin, 18 April 1990)
• only analyzable scalar variables that are not aliased or that are aliased to another scalar variable with same type are analyzed; dubious interest but April 24th is close (Francois Irigoin, 21 April 1990)

Bugs/Features:

• once the hash tables are lost, intraprocedural transformers are useless while they were still interpretable when mappings were based on arguments; they could be translated into the previous representation when their computation is completed (Francois Irigoin, April 1990)

hash tables are static; recursion is not possible for interprocedural analysis; topographical order will have to be used for it (Francois Irigoin, April 1990)

Assumptions:

• all variable values and only variable values used in a module have names in value_to_name(); however, constants, which also are values, do not appear in this mapping;
• all variables whose values may be imported have entries in the three mappings entity_to_xxx_value() if they are defined within the current module, directly or indirectly thru calls; the information is derived interprocedurally from the memory effects which do not take aliasing into account; aliasing is handled using these three mappings; several exactly aliased variables are represented by the variable that appears first in the module effects, or by default, if none of these variables is in the scope of the current module, by any of them, probably the first one in the interprocedural effects; variables that are only read, i.e. used, are mapped only in entity_to_new_value();
• a summary_transformer imported for a callee may be difficult to print before it is translated in the current module frame;
• there is no absolute frame to express summary_preconditions for the time being (maybe, this has been fixed!)

Francois Irigoin, 13 January 1994 STATIC VARIABLES Four global hash tables used to map scalar analyzable variable entities onto the different kind of value entities and to map value entities onto their external names.

They prevent recursive calls.

Definition at line 219 of file value.c.

Referenced by add_new_alias_value(), add_new_value(), add_sizeof_value(), add_synonym_values(), allocate_value_mappings(), aproximate_number_of_analyzed_variables(), entity_has_values_p(), entity_to_new_value(), error_free_value_mappings(), hash_entity_to_values_undefined_p(), new_value_entity_p(), print_value_mappings(), remove_entity_values(), reset_value_mappings(), and test_mapping_entry_consistency().

hash_entity_to_old_value

hash_table hash_entity_to_old_value = hash_table_undefined

static

Definition at line 220 of file value.c.

Referenced by add_local_old_value(), add_old_alias_value(), add_old_value(), add_synonym_values(), allocate_value_mappings(), entity_to_old_value(), error_free_value_mappings(), free_value_mappings(), modified_variables_with_values(), print_value_mappings(), remove_entity_values(), reset_value_mappings(), and test_mapping_entry_consistency().

hash_entity_to_user_value_name

hash_table hash_entity_to_user_value_name = hash_table_undefined

static

Definition at line 223 of file value.c.

Referenced by add_address_of_value(), add_sizeof_value(), allocate_value_mappings(), error_free_value_mappings(), pips_user_value_name(), and reset_value_mappings().

hash_reference_to_address_of_value

hash_table hash_reference_to_address_of_value = hash_table_undefined

static

Definition at line 225 of file value.c.

Referenced by add_address_of_value(), allocate_value_mappings(), error_free_value_mappings(), print_value_mappings(), reference_to_address_of_value(), and reset_value_mappings().

hash_type_to_sizeof_value

hash_table hash_type_to_sizeof_value = hash_table_undefined

static

Definition at line 227 of file value.c.

Referenced by add_sizeof_value(), allocate_value_mappings(), error_free_value_mappings(), print_value_mappings(), reset_value_mappings(), and type_to_sizeof_value().

hash_value_to_name

hash_table hash_value_to_name = hash_table_undefined

static

Definition at line 222 of file value.c.

Referenced by add_address_of_value(), add_intermediate_value(), add_local_intermediate_value(), add_local_old_value(), add_new_value_name(), add_old_value(), add_sizeof_value(), add_synonym_values(), allocate_value_mappings(), error_free_value_mappings(), external_value_name(), hash_value_to_name_undefined_p(), number_of_analyzed_values(), number_of_analyzed_variables(), print_value_mappings(), remove_entity_values(), reset_value_mappings(), test_mapping_entry_consistency(), value_alias(), value_entity_p(), and value_to_variable().

local_intermediate_value_counter

int local_intermediate_value_counter = 0

static

Two counters used to assign meaningless value entities to local variables.

A special global prefix, SEMANTICS_MODULE_NAME, and two special local prefixes, OLD_VALUE_PREFIX and INTERMEDIATE_VALUE_PREFIX, are also used

Definition at line 240 of file value.c.

Referenced by make_local_intermediate_value_entity(), and reset_value_counters().

local_old_value_counter

int local_old_value_counter = 0

static

Definition at line 241 of file value.c.

Referenced by make_local_old_value_entity(), and reset_value_counters().

local_temporary_value_counter

int local_temporary_value_counter = 0

static

Definition at line 242 of file value.c.

Referenced by make_local_temporary_integer_value_entity(), make_local_temporary_value_entity(), make_local_temporary_value_entity_with_basic(), number_of_temporary_values(), and reset_temporary_value_counter().