naming.c File Reference

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

Include dependency graph for naming.c:

Go to the source code of this file.

Functions
const char *	entity_module_unambiguous_user_name (entity e, entity m)
	Functions using simultaneously pipsdbm, which is based on strings, and ri-util, which contains basic methods for the objects of the internal representation. More...
const char *	entity_unambiguous_user_name (entity e)
static const char *	entity_more_or_less_minimal_name (entity e, bool strict_p)
	In interprocedural context, returns the shortest non-ambiguous name for a variable. More...
const char *	entity_minimal_name (entity e)
	Do preserve scope informations. More...
const char *	entity_minimal_user_name (entity e)
	Do not preserve scope information. More...
void	print_arguments (list args)
entity	string_to_entity (const char *s, entity module)
	very simple conversion from string to expression only handles entities and numeric values at the time being More...
list	string_to_entities (const char *str, const char *seed, entity module)
	split a string using seed as separator and call string_to_entity on each chunk More...

Function Documentation

entity_minimal_name()

const char* entity_minimal_name

(

entity

e

)

Do preserve scope informations.

This function does not allocate a new string, which implies to keep the scope information in the name of extraprocedural variables and functions.

Definition at line 214 of file naming.c.

{
  return entity_more_or_less_minimal_name(e, true);
}

References entity_more_or_less_minimal_name().

Referenced by DisplayDad(), effect_words_reference(), flint_check_uninitialized_variables_in_statement(), flint_initialize_statement_def_use_variables(), generic_value_name(), pips_region_user_name(), pips_user_value_name(), print_arguments(), print_value_mappings(), region_translation(), text_transformer(), and variable_local_name().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_minimal_user_name()

const char* entity_minimal_user_name

(

entity

e

)

Do not preserve scope information.

A new string is allocated.

Definition at line 223 of file naming.c.

{
  return entity_more_or_less_minimal_name(e, false);
}

References entity_more_or_less_minimal_name().

Referenced by equal_must_vreference(), is_entity_in_list(), opkill_may_vreference(), opkill_must_vreference(), points_to_compare_cell(), points_to_compare_cells(), points_to_compare_location(), points_to_compare_ptr_cell(), points_to_words_reference(), remove_from_effective_parameters(), and remove_from_formal_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_module_unambiguous_user_name()

const char* entity_module_unambiguous_user_name	(	entity	e,
		entity	m
	)

Functions using simultaneously pipsdbm, which is based on strings, and ri-util, which contains basic methods for the objects of the internal representation.

Warning! Do not modify this file that is automatically generated!

Based on entity_user_name, but preserves scoping information when needed to avoid ambiguity between two or more variables with the same name.

A variable or function name can be used for an external or static entity in the compilation unit, it can be used as function parameter, and then declared within the function at any scope level.

This function cannot directly be used in an interprocedural setting as it is only related to one module.

It is assumed that no new string is allocated, but a pointer to an existing string is returned.

The current implementation is extremely ineffective, especially for a very unlikely, although mystifying, problem.

FI: this function does not seem to be used in Libs or Passes. Its implementation is based on module_entities(), which is not in ri-util...

No problem in Fortran

Definition at line 68 of file naming.c.

{
  const char* uan = entity_user_name(e);
 
  /* No problem in Fortran */
  if(c_module_p(m)) {
    list conflicts = module_entities(m);
 
    FOREACH(ENTITY, v, conflicts){
        if(v!=e) {
          const char* vn = entity_user_name(v);
          if(same_string_p(uan,vn)) {
            uan = entity_local_name(e);
            break;
          }
        }
      }
    gen_free_list(conflicts);
  }
 
  return (uan);
}

References c_module_p(), ENTITY, entity_local_name(), entity_user_name(), FOREACH, gen_free_list(), module_entities(), and same_string_p.

Referenced by entity_unambiguous_user_name().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_more_or_less_minimal_name()

static const char* entity_more_or_less_minimal_name ( entity  e, bool  strict_p  )

static

In interprocedural context, returns the shortest non-ambiguous name for a variable.

If it is local to the current module, use the user name. If not return entity_name(), which is not fully satisfying for C variables because it includes scope information.

Note also that this function assumes the existence of a current module.

FI: why is this function in preprocessor and not in ri-util?

in pipsmake library...

gen_in_list_p() would/should be sufficient...

The variable is declared in the current module

The variable is declared in the compilation unit of the current module

The variable is a union or struct field. No need to disambiguate.

Formal parameters should always be unambiguous?

The variable is a dummy parameter entity, used in a function declaration

In analysis results, let's know when dummy parameters are used...

The variable is a ???

The variable is a PHI entity

The variable is a stub entity for formal and global pointers

must be used to prettyprint interprocedural information...

Definition at line 107 of file naming.c.

{
  entity m = get_current_module_entity();
  const char* mln = module_local_name(m);
  const char* emn = string_undefined;
  string cun = string_undefined; // compilation unit name
  entity cu = entity_undefined; // compilation unit
  list cudl = list_undefined; // compilation unit declaration list
  list mdl = code_declarations(value_code(entity_initial(m)));
 
  if(c_module_p(m) && !compilation_unit_p(mln)) {
    /* in pipsmake library...*/
    string compilation_unit_of_module(const char*);
    cun = compilation_unit_of_module(mln);
    cu = FindEntity(TOP_LEVEL_MODULE_NAME, cun);
    cudl = code_declarations(value_code(entity_initial(cu)));
    free(cun);
  }
 
  pips_assert("some current entity", !entity_undefined_p(m));
 
  /* gen_in_list_p() would/should be sufficient... */
  if (strcmp(mln, entity_module_name(e)) == 0
      || gen_in_list_p(e, mdl)) {
    /* The variable is declared in the current module */
    //return global_name_to_user_name(entity_name(e));
    if(strict_p)
      emn = entity_unambiguous_user_name(e);
    else
      emn = entity_user_name(e);
  }
  else if (!list_undefined_p(cudl) && gen_in_list_p(e, cudl)) {
    /* The variable is declared in the compilation unit of the current
       module */
    //return global_name_to_user_name(entity_name(e));
    if(strict_p)
      emn = entity_unambiguous_user_name(e);
    else
      emn = entity_user_name(e);
  }
  else if (entity_field_p(e)) {
    /* The variable is a union or struct field. No need to
       disambiguate. */
    if(strict_p)
      emn = entity_unambiguous_user_name(e);
    else
      emn = entity_user_name(e);
  }
  else if (entity_formal_p(e)) {
    /* Formal parameters should always be unambiguous? */
    if(strict_p)
      emn = entity_unambiguous_user_name(e);
    else
      emn = entity_user_name(e);
  }
  else if (strstr(entity_module_name(e), DUMMY_PARAMETER_PREFIX)) {
    /* The variable is a dummy parameter entity, used in a function
       declaration */
    if(strict_p)
      emn = entity_local_name(e);
    else {
      /* In analysis results, let's know when dummy parameters are
         used... */
      //emn = strdup(entity_local_name(e));
      emn = strdup(entity_name(e));
    }
  }
  else if (strcmp(TOP_LEVEL_MODULE_NAME, entity_module_name(e)) == 0) {
    /* The variable is a ??? */
    if(strict_p)
      emn = entity_local_name(e);
    else
      emn = strdup(entity_local_name(e));
  }
  else if (strcmp(REGIONS_MODULE_NAME, entity_module_name(e)) == 0) {
    /* The variable is a PHI entity */
    if(strict_p)
      emn = entity_local_name(e);
    else
      emn = strdup(entity_local_name(e));
  }
  else if (strcmp(POINTS_TO_MODULE_NAME, entity_module_name(e)) == 0) {
    /* The variable is a stub entity for formal and global pointers */
    if(strict_p)
      emn = entity_local_name(e);
    else
      emn = strdup(entity_local_name(e));
  }
  else {
    /* must be used to prettyprint interprocedural information... */
    //entity om = local_name_to_top_level_entity(mln);
    //emn = entity_interprocedural_unambiguous_user_name(e, om);
    if(strict_p)
      emn = entity_name(e);
    else
      emn = strdup(entity_name(e));
  }
 
  return emn;
}

References c_module_p(), code_declarations, compilation_unit_of_module(), compilation_unit_p(), DUMMY_PARAMETER_PREFIX, entity_field_p(), entity_formal_p(), entity_initial, entity_local_name(), entity_module_name(), entity_name, entity_unambiguous_user_name(), entity_undefined, entity_undefined_p, entity_user_name(), FindEntity(), free(), gen_in_list_p(), get_current_module_entity(), list_undefined, list_undefined_p, module_local_name(), pips_assert, POINTS_TO_MODULE_NAME, REGIONS_MODULE_NAME, strdup(), string_undefined, TOP_LEVEL_MODULE_NAME, and value_code.

Referenced by entity_minimal_name(), and entity_minimal_user_name().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_unambiguous_user_name()

const char* entity_unambiguous_user_name

(

entity

e

)

Definition at line 91 of file naming.c.

{
  entity m = get_current_module_entity();
 
  return entity_module_unambiguous_user_name(e, m);
}

References entity_module_unambiguous_user_name(), and get_current_module_entity().

Referenced by entity_more_or_less_minimal_name().

Here is the call graph for this function:

Here is the caller graph for this function:

print_arguments()

void print_arguments

(

list

args

)

Parameters

args

rgs

Definition at line 228 of file naming.c.

{
  print_homogeneous_arguments(args, entity_minimal_name);
}

References entity_minimal_name(), and print_homogeneous_arguments().

Referenced by ComputeAddresses(), fuse_sequences_in_unstructured(), MakeEntryCommon(), recompute_loop_transformer(), TestDependence(), and update_common_layout().

Here is the call graph for this function:

Here is the caller graph for this function:

string_to_entities()

list string_to_entities	(	const char *	str,
		const char *	seed,
		entity	module
	)

split a string using seed as separator and call string_to_entity on each chunk

Parameters

str	tr
seed	eed
module	odule

Definition at line 276 of file naming.c.

                                                                            {
    list strings = strsplit(str,seed);
    list entities = NIL;
    FOREACH(STRING,s,strings) {
        entity e = string_to_entity(s,module);
        if(!entity_undefined_p(e)) {
            entities = CONS(ENTITY,
                    e,
                    entities);
        }
    }
    gen_map(free,strings);
    gen_free_list(strings);
    return gen_nreverse(entities);
 
}

References CONS, ENTITY, entity_undefined_p, FOREACH, free(), gen_free_list(), gen_map(), gen_nreverse(), module, NIL, STRING, string_to_entity(), and strsplit().

Here is the call graph for this function:

string_to_entity()

entity string_to_entity	(	const char *	s,
		entity	module
	)

very simple conversion from string to expression only handles entities and numeric values at the time being

try float conversion

no negative integer entity in pips

first find all relevant entities

this an heuristic to find the one with a suiting scope error prone

try at the compilation unit level

try at top level

Parameters

module

odule

Definition at line 237 of file naming.c.

{
    if(empty_string_p(s)) return entity_undefined;
 
    /* try float conversion */
    string endptr;
    const char *module_name=module_local_name(module);
    long int l = strtol(s,&endptr,10);
    if(!*endptr) {
        if(l>=0)
            return int_to_entity(l);
        else /* no negative integer entity in pips */
            return entity_undefined;
    }
    float f = strtof(s,&endptr);
    if(!*endptr) return float_to_entity(f);
 
    entity candidate = entity_undefined;
    /* first find all relevant entities */
    FOREACH(ENTITY,e,entity_declarations(module))
    {
        /* this an heuristic to find the one with a suiting scope
         * error prone*/
        if(same_string_p(entity_user_name(e),s) )
            if(entity_undefined_p(candidate) ||
                    strlen(entity_name(candidate)) > strlen(entity_name(e)))
                candidate=e;
    }
    /* try at the compilation unit level */
    if(entity_undefined_p(candidate))
        candidate=FindEntity(compilation_unit_of_module(module_name),s);
    /* try at top level */
    if(entity_undefined_p(candidate))
        candidate=FindEntity(TOP_LEVEL_MODULE_NAME,s);
    return candidate;
}

References compilation_unit_of_module(), empty_string_p(), ENTITY, entity_declarations, entity_name, entity_undefined, entity_undefined_p, entity_user_name(), f(), FindEntity(), float_to_entity(), FOREACH, int_to_entity(), module, module_local_name(), module_name(), same_string_p, and TOP_LEVEL_MODULE_NAME.

Referenced by do_solve_hardware_constraints(), string_to_entities(), and string_to_expression().

Here is the call graph for this function:

Here is the caller graph for this function: