workspace-util.h File Reference

#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "text.h"
#include "cloning.h"
#include "newgen.h"
#include "naming.h"
#include "ri-util.h"
#include "pipsdbm.h"

Include dependency graph for workspace-util.h:

Go to the source code of this file.

Functions
const char *	entity_module_unambiguous_user_name (entity, entity)
	Warning! Do not modify this file that is automatically generated! More...
const char *	entity_unambiguous_user_name (entity)
const char *	entity_minimal_name (entity)
	Do preserve scope informations. More...
const char *	entity_minimal_user_name (entity)
	Do not preserve scope information. More...
void	print_arguments (list)
entity	string_to_entity (const char *, entity)
	very simple conversion from string to expression only handles entities and numeric values at the time being More...
list	string_to_entities (const char *, const char *, entity)
	split a string using seed as separator and call string_to_entity on each chunk More...
expression	string_to_expression (const char *, entity)
	expressions.c More...
list	string_to_expressions (const char *, const char *, entity)
	split a string using seed as separator and call string_to_expression on each chunk More...
list	base_to_list (Pbase)
	misc_paf_utils.c More...
Pbase	list_to_base (list)
	Pbase list_to_base(list l): returns the Pbase that contains the variables of list "l", of entities, in the same order. More...
expression	make_max_exp (entity, expression, expression)
	================================================================ More...
entity	make_nlc_entity (int *)
	================================================================ More...
entity	make_nsp_entity (void)
	entity make_nsp_entity() Makes a new NSP (for New Structural Parameter) . More...
entity	make_nub_entity (void)
	================================================================ More...
entity	current_module (entity)
	================================================================ More...
bool	undefined_statement_list_p (list)
	================================================================= More...
entity	expression_int_scalar (expression)
	================================================================ More...
entity	scalar_assign_call (call)
	entity scalar_assign_call((call) c) Detects if the call is an assignement and if the value assigned is a scalar. More...
void	scalar_written_in_call (call, list *, list *, list *)
	scalar_written_in_call((call) the_call) Detects and puts a scalar written in an assignement call, in the global list Gscalar_written_forward if Genclosing_loops or Genclosing_tests are not empty. More...
list	module_declarations (entity)
	module.c More...
list	current_module_declarations (void)
list	module_entities (entity)
	Return a list of all variables and functions accessible somewhere in a module. More...
entity	module_entity_to_compilation_unit_entity (entity)
	Retrieve the compilation unit containing a module definition. More...
bool	language_module_p (entity, string)
void	AddEntityToCompilationUnit (entity, entity)
	Add an entity to the current's module compilation unit declarations we have to generate its statement if none created before due to limitation of pipsmake, it is not always possible to make sure from pipsmake that this ressource is created. More...
void	RemoveEntityFromCompilationUnit (entity, entity)
	Remove an entity from the current's module compilation unit declarations. More...
void	AddEntityToModuleCompilationUnit (entity, entity)
list	module_to_all_declarations (entity)
string	compilation_unit_of_module (const char *)
	The output is undefined if the module is referenced but not defined in the workspace, for instance because its code should be synthesized. More...
string	module_name_to_input_file_name (const char *)
	To be checked for static functions... More...

Variables
int	Gcount_nsp
	================================================================ More...
int	Gcount_nub

Function Documentation

AddEntityToCompilationUnit()

void AddEntityToCompilationUnit	(	entity	e,
		entity	cu
	)

Add an entity to the current's module compilation unit declarations we have to generate its statement if none created before due to limitation of pipsmake, it is not always possible to make sure from pipsmake that this ressource is created.

For example in INLINING (!) we would like to tell pipsmake we need the CODE resource from all module callers.

Parameters

[in]	e	is the entity to add
[in]	cu	is the compilation unit

SG: when adding a new entity to compilation unit, one should check the entity is not already present but an entity with the same name may already be defined there so check this with a very costly test

Parameters

cu

u

Definition at line 198 of file module.c.

                                                      {
    statement s = statement_undefined;
    const char* cum = module_local_name(cu);
    if( c_module_p(cu) ) {
        if(!db_resource_required_or_available_p(DBR_PARSED_CODE,cum))
        {
            bool compilation_unit_parser(const char*);
            entity tmp = get_current_module_entity();
            statement stmt = get_current_module_statement();
            reset_current_module_entity();
            reset_current_module_statement();
            compilation_unit_parser(cum);
            if(!entity_undefined_p(tmp))
                set_current_module_entity(tmp);
            if(!statement_undefined_p(stmt))
                set_current_module_statement(stmt);
        }
        if(!db_resource_required_or_available_p(DBR_CODE,cum))
        {
            bool controlizer(const char*);
            entity tmp = get_current_module_entity();
            statement stmt = get_current_module_statement();
            reset_current_module_entity();
            reset_current_module_statement();
            controlizer(cum);
            if(!entity_undefined_p(tmp))
                set_current_module_entity(tmp);
            if(!statement_undefined_p(stmt))
                set_current_module_statement(stmt);
        }
        s=(statement)db_get_memory_resource(DBR_CODE,cum,true);
    }
    /* SG: when adding a new entity to compilation unit,
     * one should check the entity is not already present
     * but an entity with the same name may already be defined there
     * so check this with a very costly test*/
    list cu_entities = entity_declarations(cu);
    FOREACH(ENTITY,cue,cu_entities)
        if(same_string_p(entity_user_name(e),entity_user_name(cue)))
            return;
    AddLocalEntityToDeclarations(e,cu,s);
    if( c_module_p(cu) ) {
        module_reorder(s);
        db_put_or_update_memory_resource(DBR_CODE,cum,s,true);
        db_touch_resource(DBR_CODE,cum);
        if( typedef_entity_p(e) ) {
          //keyword_typedef_table = (hash_table)db_get_memory_resource(DBR_DECLARATIONS, cum, true);
          //put_new_typedef(entity_user_name(e));
          // FI: I do not see why the global variable of the parsers should be reused here
          // hash_table keyword_typedef_table = (hash_table)db_get_memory_resource(DBR_DECLARATIONS, cum, true);
          set_keyword_typedef_table((hash_table) db_get_memory_resource(DBR_DECLARATIONS, cum, true));
          //hash_put(keyword_typedef_table,strdup(cum),(void *) TK_NAMED_TYPE);
          // FI; temporary
          //hash_put(keyword_typedef_table,strdup(cum),(void *) 262);
          declare_new_typedef((string) entity_user_name(e));
          //SG: we have to do this behind the back of pipsmake. Not Good for serialization, but otherwise it forces the recompilation of the parsed_code of the associated modules, not good :(
          //DB_PUT_MEMORY_RESOURCE(DBR_DECLARATIONS, cum, keyword_typedef_table);
        }
 
    }
}

References AddLocalEntityToDeclarations(), c_module_p(), compilation_unit_parser(), controlizer(), db_get_memory_resource(), db_put_or_update_memory_resource(), db_resource_required_or_available_p(), db_touch_resource(), declare_new_typedef(), ENTITY, entity_declarations, entity_undefined_p, entity_user_name(), FOREACH, get_current_module_entity(), get_current_module_statement(), module_local_name(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), same_string_p, set_current_module_entity(), set_current_module_statement(), set_keyword_typedef_table(), statement_undefined, statement_undefined_p, and typedef_entity_p().

Referenced by AddEntityToModuleCompilationUnit(), outliner_independent_recursively(), and type_to_named_type().

Here is the call graph for this function:

Here is the caller graph for this function:

AddEntityToModuleCompilationUnit()

void AddEntityToModuleCompilationUnit	(	entity	e,
		entity	module
	)

Parameters

module

odule

Definition at line 301 of file module.c.

{
    list tse = type_supporting_entities(NIL,entity_type(e));
    entity cu = module_entity_to_compilation_unit_entity(module);
    FOREACH(ENTITY,se,tse) {
        const char * eln = entity_local_name(se);
        if(strstr(eln, DUMMY_STRUCT_PREFIX) || strstr(eln, DUMMY_UNION_PREFIX) ) {
            continue;
        }
        AddEntityToCompilationUnit(se,cu);
    }
    gen_free_list(tse);
    AddEntityToCompilationUnit(e,cu);
}

References AddEntityToCompilationUnit(), DUMMY_STRUCT_PREFIX, DUMMY_UNION_PREFIX, ENTITY, entity_local_name(), entity_type, FOREACH, gen_free_list(), module, module_entity_to_compilation_unit_entity(), NIL, and type_supporting_entities().

Referenced by dimensions_to_dma(), initialization_list_to_statements(), inline_expression_call(), make_dma_transfert(), outliner_file(), outliner_independent_recursively(), promote_local_entities(), step_parameter(), and wrap_argument().

Here is the call graph for this function:

Here is the caller graph for this function:

base_to_list()

list base_to_list

(

Pbase

b

)

misc_paf_utils.c

misc_paf_utils.c

Most includes are centralized here.

Definition at line 47 of file misc_paf_utils.c.

{
 list l = NIL;
 
 for( ; b != NULL; b = b->succ)
   l = gen_nconc(l, CONS(ENTITY, (entity) b->var, NIL));
 
 return(l);
}

compilation_unit_of_module()

string compilation_unit_of_module

(

const char *

module_name

)

The output is undefined if the module is referenced but not defined in the workspace, for instance because its code should be synthesized.

Fabien Coelho suggests to build a default compilation unit where all synthesized module codes would be located.

Parameters

module_name

odule_name

Definition at line 350 of file module.c.

{
  entity e = module_name_to_entity(module_name);
  pips_assert("only for C modules\n", entity_undefined_p(e) || c_module_p(e));
 
  // Should only be called for C modules.
  string compilation_unit_name = string_undefined;
 
  // The guard may not be sufficient...
  // and this may crash in db_get_memory_resource()
  if(db_resource_p(DBR_USER_FILE, module_name)) {
    string source_file_name =
      db_get_memory_resource(DBR_USER_FILE, module_name, true);
    string simpler_file_name = pips_basename(source_file_name, PP_C_ED);
 
    // It is not clear how robust it is going to be
    // when file name conflicts occur.
    (void) asprintf(&compilation_unit_name, "%s" FILE_SEP_STRING,
                    simpler_file_name);
    free(simpler_file_name);
  }
 
  return compilation_unit_name;
}

current_module()

entity current_module

(

entity

mod

)

================================================================

entity current_module(entity mod): returns the current module entity, that is the entity of the module in which we are working currently. If the entity "mod" is undefined, it returns the static entity already known; Else, the static entity is updated to the entity "mod".

Parameters

mod

od

Definition at line 250 of file misc_paf_utils.c.

{
    static entity current_mod;
 
    debug( 7, "current_module", "doing\n");
    if (mod != entity_undefined) {
        pips_assert("current_module_entity", entity_module_p(mod));
        current_mod = mod;
    }
    return(current_mod);
}

References current_mod, debug(), entity_module_p(), entity_undefined, and pips_assert.

Here is the call graph for this function:

current_module_declarations()

list current_module_declarations

(

void

)

Definition at line 78 of file module.c.

{
  entity m = get_current_module_entity();
  return module_declarations(m);
}

References get_current_module_entity(), and module_declarations().

Referenced by add_declaration_information(), and module_to_value_mappings().

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

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

Modify src/Libs/workspace-util/workspace-util-local.h instead, to add your own modifications. header file built by cproto workspace_util-local.h WORKSPACE-UTIL Library: Functions dealing with the internal representation at the workspace level, mixing calls to pipsdbm, naming-util and ri-util. cproto-generated files naming.c

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_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:

expression_int_scalar()

entity expression_int_scalar

(

expression

exp

)

================================================================

entity expression_int_scalar((expression) exp) Returns the scalar entity if this expression is a scalar.

Parameters

exp

xp

Definition at line 299 of file misc_paf_utils.c.

{
        syntax  s = expression_syntax( exp );
        tag     t = syntax_tag( s );
        entity  ent = entity_undefined;
 
        debug( 7, "expression_int_scalar", "doing \n");
        switch( t ) {
                case is_syntax_reference: {
                        entity local;
                        local = reference_variable(syntax_reference(s));
                        if (entity_integer_scalar_p(local)) ent = local;
                        break;
                }
                default: break;
        }
        debug( 7, "expression_int_scalar",
                 "returning : %s\n",
                 ((ent == entity_undefined)?"entity_undefined":
                        entity_local_name( ent )) );
        return( ent );
}

References debug(), entity_integer_scalar_p(), entity_local_name(), entity_undefined, exp, expression_syntax, is_syntax_reference, reference_variable, syntax_reference, and syntax_tag.

Referenced by get_sp_of_call_p(), scalar_assign_call(), and terapix_optimize_accumulator().

Here is the call graph for this function:

Here is the caller graph for this function:

language_module_p()

bool language_module_p	(	entity	m,
		string	lid
	)

FI: does not work with static functions

SG: must check if the ressource exist (not always the case)

SG: be positive ! (needed for Hpfc)

Parameters

lid

id

Definition at line 166 of file module.c.

{
  bool c_p = false;
 
  if(entity_module_p(m)) {
    /* FI: does not work with static functions */
    //string aufn = db_get_memory_resource(DBR_USER_FILE, entity_user_name(m), true);
    /* SG: must check if the ressource exist (not always the case) */
    const char* lname= module_local_name(m);
    if( db_resource_p(DBR_USER_FILE,lname) )
    {
        string aufn = db_get_memory_resource(DBR_USER_FILE, module_local_name(m), true);
        string n = strstr(aufn, lid);
 
        c_p = (n!=NULL);
    }
    else
        c_p = true; /* SG: be positive ! (needed for Hpfc)*/
  }
  return c_p;
}

References db_get_memory_resource(), db_resource_p(), entity_module_p(), lname(), and module_local_name().

Here is the call graph for this function:

list_to_base()

Pbase list_to_base

(

list

l

)

Pbase list_to_base(list l): returns the Pbase that contains the variables of list "l", of entities, in the same order.

Definition at line 60 of file misc_paf_utils.c.

{
 Pbase new_b = NULL;
 list el_l;
 
 for(el_l = l ; el_l != NIL; el_l = CDR(el_l))
   vect_add_elem((Pvecteur *) &new_b, (char *) ENTITY(CAR(el_l)), VALUE_ONE);
 
 new_b = base_reversal(new_b);
 return(new_b);
}

References base_reversal(), CAR, CDR, ENTITY, NIL, VALUE_ONE, and vect_add_elem().

Referenced by adg_dataflowgraph(), analyze_quast(), base_complete(), broadcast_conditions(), broadcast_of_dataflow(), clean_list_of_unk(), completer_base(), completer_n_base(), do_array_expansion(), do_solve_hardware_constraints_on_nb_proc(), extract_lattice(), include_time_in_base(), make_dual(), make_list_of_unk(), make_primal(), mapping_on_broadcast(), partial_broadcast_coefficients(), prepare_reindexing(), rectangularization_region(), search_scc_bdt(), stmt_bdt_directions(), system_inversion_restrict(), and valuer().

Here is the call graph for this function:

Here is the caller graph for this function:

make_max_exp()

expression make_max_exp	(	entity	ent,
		expression	exp1,
		expression	exp2
	)

================================================================

expression make_max_exp(entity ent, expression exp1, expression exp2) computes MAX( exp1, exp2 ) if exp1 and exp2 are constant expressions. If it is not the case, it returns MAX( exp1, exp2 )

pips_debug(7, "doing MAX( %s, %s ) \n",

expression_to_string(exp1),

expression_to_string(exp2) );

Parameters

ent	nt
exp1	xp1
exp2	xp2

Definition at line 78 of file misc_paf_utils.c.

{
        expression rexp;
 
        /* pips_debug(7, "doing MAX( %s, %s ) \n", */
        /*        expression_to_string(exp1), */
        /*        expression_to_string(exp2) ); */
        if (expression_constant_p( exp1 ) && expression_constant_p( exp2 )) {
                int val1 = expression_to_int( exp1 );
                int val2 = expression_to_int( exp2 );
                if (val1 > val2) rexp = int_to_expression(val1);
                else rexp = int_to_expression( val2 );
        }
        else rexp = MakeBinaryCall( ent, exp1, exp2 );
 
        return rexp ;
}

References expression_constant_p(), expression_to_int(), int_to_expression(), and MakeBinaryCall().

Referenced by loop_normalize_of_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

make_nlc_entity()

entity make_nlc_entity

(

int *

Gcount_nlc

)

================================================================

entity make_nlc_entity(int *Gcount_nlc):

Returns a new entity. Its local name is "NLC#", where '#' represents the value of "Gcount_nlc". This variable counts the number of NLCs variables.

These entities have a special full name. The first part of it is the concatenation of the define constant STATIC_CONTROLIZE_MODULE_NAME and the local name of the current module.

The type ("basic") of these variables is INTEGER.

These variables are local to the current module, so they have a "storage_ram" with DYNAMIC "area".

NLC means Normalized Loop Counter.

Parameters

Gcount_nlc

count_nlc

Definition at line 117 of file misc_paf_utils.c.

{
        entity  new_ent, mod_ent;
        char    *name, *num;
        entity  dynamic_area;
        ram     new_dynamic_ram;
        
 
        debug( 7, "make_nlc_entity", "doing\n");
        (*Gcount_nlc)++;
        (void) asprintf(&num, "%d", *Gcount_nlc);
 
        mod_ent = get_current_module_entity();
 
        name = strdup(concatenate(STATIC_CONTROLIZE_MODULE_NAME,
                          entity_local_name(mod_ent),
                          MODULE_SEP_STRING, NLC_PREFIX, num, (char *) NULL));
 
        new_ent = make_entity(name,
                      make_type(is_type_variable,
                          make_variable(make_basic(is_basic_int, UUINT(4)),
                                              NIL,NIL)),
                      make_storage(is_storage_ram, ram_undefined),
                      make_value(is_value_unknown, UU));
 
        dynamic_area = FindOrCreateEntity( module_local_name(mod_ent),
                                  DYNAMIC_AREA_LOCAL_NAME);
 
        new_dynamic_ram = make_ram(mod_ent,
                           dynamic_area,
                           current_offset_of_area(dynamic_area, new_ent),
                           NIL);
 
        storage_ram(entity_storage(new_ent)) = new_dynamic_ram;
 
        return(new_ent);
}

References asprintf, concatenate(), current_offset_of_area(), debug(), dynamic_area, DYNAMIC_AREA_LOCAL_NAME, entity_local_name(), entity_storage, FindOrCreateEntity(), Gcount_nlc, get_current_module_entity(), is_basic_int, is_storage_ram, is_type_variable, is_value_unknown, make_basic(), make_entity, make_ram(), make_storage(), make_type(), make_value(), make_variable(), mod_ent, module_local_name(), MODULE_SEP_STRING, NIL, NLC_PREFIX, num, ram_undefined, STATIC_CONTROLIZE_MODULE_NAME, storage_ram, strdup(), UU, and UUINT.

Referenced by loop_normalize_of_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

make_nsp_entity()

entity make_nsp_entity

(

void

)

entity make_nsp_entity() Makes a new NSP (for New Structural Parameter) .

Definition at line 165 of file misc_paf_utils.c.

{
        entity  new_ent, mod_ent;
        char    *name, *num;
        entity  dynamic_area;
        ram     new_dynamic_ram;
 
        debug( 7, "make_nsp_entity", "doing\n");
        Gcount_nsp++;
        (void) asprintf(&num, "%d", Gcount_nsp);
 
        mod_ent = get_current_module_entity();
 
        name = strdup(concatenate(STATIC_CONTROLIZE_MODULE_NAME,
                          entity_local_name(mod_ent),
                          MODULE_SEP_STRING, NSP_PREFIX, num, (char *) NULL));
 
        new_ent = make_entity(name,
                      make_type(is_type_variable,
                            make_variable(make_basic(is_basic_int, UUINT(4)),
                                              NIL,NIL)),
                      make_storage(is_storage_ram, ram_undefined),
                      make_value(is_value_unknown, UU));
 
        dynamic_area = FindOrCreateEntity( module_local_name(mod_ent),
                                  DYNAMIC_AREA_LOCAL_NAME);
 
        new_dynamic_ram = make_ram(mod_ent,
                           dynamic_area,
                           current_offset_of_area(dynamic_area, new_ent),
                           NIL);
 
        storage_ram(entity_storage(new_ent)) = new_dynamic_ram;
 
        return new_ent;
}

References asprintf, concatenate(), current_offset_of_area(), debug(), dynamic_area, DYNAMIC_AREA_LOCAL_NAME, entity_local_name(), entity_storage, FindOrCreateEntity(), Gcount_nsp, get_current_module_entity(), is_basic_int, is_storage_ram, is_type_variable, is_value_unknown, make_basic(), make_entity, make_ram(), make_storage(), make_type(), make_value(), make_variable(), mod_ent, module_local_name(), MODULE_SEP_STRING, NIL, NSP_PREFIX, num, ram_undefined, STATIC_CONTROLIZE_MODULE_NAME, storage_ram, strdup(), UU, and UUINT.

Referenced by get_sp_of_call_p().

Here is the call graph for this function:

Here is the caller graph for this function:

make_nub_entity()

entity make_nub_entity

(

void

)

================================================================

entity make_nub_entity() Makes a new NUB (for New Upper Bound) .

Definition at line 206 of file misc_paf_utils.c.

{
        entity  new_ent, mod_ent;
        char    *name, *num;
        entity  dynamic_area;
        ram     new_dynamic_ram;
 
 
        debug( 7, "make_nub_entity", "doing\n");
        Gcount_nub++;
        (void) asprintf(&num, "%d", Gcount_nub);
 
        mod_ent = get_current_module_entity();
 
        name = strdup(concatenate(STATIC_CONTROLIZE_MODULE_NAME,
                          entity_local_name(mod_ent),
                          MODULE_SEP_STRING, NUB_PREFIX, num, (char *) NULL));
 
        new_ent = make_entity(name,
                      make_type(is_type_variable,
                        make_variable(make_basic(is_basic_int, UUINT(4)),
                                              NIL,NIL)),
                      make_storage(is_storage_ram, ram_undefined),
                      make_value(is_value_unknown, UU));
 
        dynamic_area = FindOrCreateEntity( module_local_name(mod_ent),
                                  DYNAMIC_AREA_LOCAL_NAME);
 
        new_dynamic_ram = make_ram(mod_ent,
                           dynamic_area,
                           current_offset_of_area(dynamic_area, new_ent),
                           NIL);
 
        storage_ram(entity_storage(new_ent)) = new_dynamic_ram;
 
        return new_ent;
}

References asprintf, concatenate(), current_offset_of_area(), debug(), dynamic_area, DYNAMIC_AREA_LOCAL_NAME, entity_local_name(), entity_storage, FindOrCreateEntity(), Gcount_nub, get_current_module_entity(), is_basic_int, is_storage_ram, is_type_variable, is_value_unknown, make_basic(), make_entity, make_ram(), make_storage(), make_type(), make_value(), make_variable(), mod_ent, module_local_name(), MODULE_SEP_STRING, NIL, NUB_PREFIX, num, ram_undefined, STATIC_CONTROLIZE_MODULE_NAME, storage_ram, strdup(), UU, and UUINT.

Here is the call graph for this function:

module_declarations()

list module_declarations

(

entity

m

)

module.c

module.c

Retrieve all declarations linked to a module, but the local variables private to loops. Allocate and build a new list which will have to be freed by the caller.

This function has been implemented twice.

It may be useless because code_declarations() is supposed to contain all module declarations, regardless of where the declarations happens.

FI: maybe we should also look up the declarations in the compilation unit...

Definition at line 58 of file module.c.

{
  list dl = get_current_module_declarations();
  if (list_undefined_p(dl))
    {
      dl = code_declarations(value_code(entity_initial(m)));
      set_current_module_declarations(dl);
    }  
 
  /* FI: maybe we should also look up the declarations in the compilation unit... */
 
  ifdebug(9) {
    pips_debug(8, "Current module declarations:\n");
    print_entities(dl);
    fprintf(stderr, "\n");
  }
 
  return gen_copy_seq(dl);
}

References code_declarations, entity_initial, fprintf(), gen_copy_seq(), get_current_module_declarations(), ifdebug, list_undefined_p, pips_debug, print_entities(), set_current_module_declarations(), and value_code.

Referenced by add_parameter_variable_to_module(), add_private_variable_to_module(), create_parameter_for_new_module(), current_module_declarations(), and module_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

module_entities()

list module_entities

(

entity

m

)

Return a list of all variables and functions accessible somewhere in a module.

Make sure you only have entities in list cudl

Definition at line 85 of file module.c.

{
  entity cu = module_entity_to_compilation_unit_entity(m);
  list cudl = gen_copy_seq(code_declarations(value_code(entity_initial(cu))));
  list mdl = module_declarations(m);
 
  pips_assert("compilation unit is an entity list.",
              entity_list_p(code_declarations(value_code(entity_initial(cu)))));
  pips_assert("initial cudl is an entity list.", entity_list_p(cudl));
  pips_assert("mdl is an entity list.", entity_list_p(mdl));
 
  cudl = gen_nconc(cudl, mdl);
 
  /* Make sure you only have entities in list cudl */
  pips_assert("Final cudl is an entity list.", entity_list_p(cudl));
 
  return cudl;
}

References code_declarations, entity_initial, entity_list_p(), gen_copy_seq(), gen_nconc(), module_declarations(), module_entity_to_compilation_unit_entity(), pips_assert, and value_code.

Referenced by entity_module_unambiguous_user_name().

Here is the call graph for this function:

Here is the caller graph for this function:

module_entity_to_compilation_unit_entity()

entity module_entity_to_compilation_unit_entity

(

entity

m

)

Retrieve the compilation unit containing a module definition.

The implementation is clumsy.

It would be nice to memoize the information as with get_current_module_entity().

It would be much nicer to keep a resource like INPUT_FILE_NAME, say COMPILATION_UNIT_NAME.

The entity returned may be undefined.

The resource does not always exist.

For Fortran code to start with.

For synthesized code too: initializer, outliner... (although pass outline might build a compilation unit...

Let's assume that synthesized module "foo" has "foo!" a compilation unit name and it never is a static function.

Definition at line 116 of file module.c.

{
  entity cu = entity_undefined;
 
  if(compilation_unit_entity_p(m))
    cu = m;
  else if(!db_resource_p(DBR_USER_FILE, module_local_name(m))) {
    /* The resource does not always exist.
     *
     * For Fortran code to start with.
     *
     * For synthesized code too: initializer, outliner... (although
     * pass outline might build a compilation unit...
     *
     * Let's assume that synthesized module "foo" has "foo!" a
     * compilation unit name and it never is a static function.
     */
    string name = strdup(concatenate(entity_name(m), FILE_SEP_STRING, NULL));
    cu = gen_find_tabulated(name, entity_domain);
  }
  else {
    // string aufn = db_get_memory_resource(DBR_USER_FILE, entity_user_name(m), true);
    string aufn = db_get_memory_resource(DBR_USER_FILE, module_local_name(m), true);
    string lufn = strrchr(aufn, '/')+1;
 
    if(lufn!=NULL) {
      string n = strstr(lufn, PP_C_ED);
      int l = n-lufn;
      string cun = strndup(lufn, l);
 
      if(static_module_name_p(cun)) {
        string end = strrchr(cun, FILE_SEP_CHAR);
        *(end+1) = '\0';
        cu = local_name_to_top_level_entity(cun);
      }
      else {
        string ncun = strdup(concatenate(cun, FILE_SEP_STRING, NULL));
        cu = local_name_to_top_level_entity(ncun);
        free(ncun);
      }
      free(cun);
    }
    else
      pips_internal_error("Not implemented yet");
  }
  pips_assert("If defined, cu is a compilation unit",
              entity_undefined_p(cu) || compilation_unit_entity_p(cu));
  return cu;
}

References compilation_unit_entity_p(), concatenate(), db_get_memory_resource(), db_resource_p(), end, entity_domain, entity_name, entity_undefined, entity_undefined_p, FILE_SEP_CHAR, FILE_SEP_STRING, free(), gen_find_tabulated(), local_name_to_top_level_entity(), module_local_name(), pips_assert, pips_internal_error, static_module_name_p(), strdup(), and strndup().

Referenced by AddEntityToModuleCompilationUnit(), ensure_comment_consistency(), module_entities(), outliner_parameters(), promote_local_entities(), and update_unstructured_declarations().

Here is the call graph for this function:

Here is the caller graph for this function:

module_name_to_input_file_name()

string module_name_to_input_file_name

(

const char *

module_name

)

To be checked for static functions...

Parameters

module_name

odule_name

Definition at line 376 of file module.c.

{
  entity e = module_name_to_entity(module_name);
  pips_assert("only for C modules\n", entity_undefined_p(e) || c_module_p(e));
 
  // Should only be called for C modules.
  string input_file_name = string_undefined;
 
  // The guard may not be sufficient...
  // and this may crash in db_get_memory_resource()
  if(db_resource_p(DBR_USER_FILE, module_name)) {
    string source_file_name =
      db_get_memory_resource(DBR_USER_FILE, module_name, true);
    string simpler_file_name = pips_basename(source_file_name, PP_C_ED);
 
    // It is not clear how robust it is going to be
    // when file name conflicts occur.
    (void) asprintf(&input_file_name, "%s/" WORKSPACE_SRC_SPACE "/%s.c",
                    db_get_current_workspace_directory(), simpler_file_name);
    free(simpler_file_name);
  }
 
  return input_file_name;
}

References asprintf, c_module_p(), db_get_current_workspace_directory(), db_get_memory_resource(), db_resource_p(), entity_undefined_p, free(), module_name(), module_name_to_entity(), pips_assert, pips_basename(), string_undefined, and WORKSPACE_SRC_SPACE.

Here is the call graph for this function:

module_to_all_declarations()

list module_to_all_declarations

(

entity

m

)

Definition at line 323 of file module.c.

{
  list dl = CONS(ENTITY, m, gen_copy_seq(code_declarations(value_code(entity_initial(m)))));
  bool c_module_p(entity);
 
  if(c_module_p(m)) {
    //const char* module_name = entity_user_name(m);
    const char* module_name = entity_local_name(m);
    statement s = (statement) db_get_memory_resource(DBR_PARSED_CODE, module_name, true);
    list sdl = statement_to_declarations(s);
 
    FOREACH(ENTITY, e, sdl) {
      if(!entity_is_argument_p(e, dl))
        dl = gen_nconc(dl, CONS(ENTITY, e, NIL));
    }
    gen_free_list(sdl);
  }
 
  return dl;
}

References c_module_p(), code_declarations, CONS, db_get_memory_resource(), ENTITY, entity_initial, entity_is_argument_p(), entity_local_name(), FOREACH, gen_copy_seq(), gen_free_list(), gen_nconc(), module_name(), NIL, statement_to_declarations(), and value_code.

Referenced by all_data_to_precondition(), and generic_module_initial_pointer_values().

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:

RemoveEntityFromCompilationUnit()

void RemoveEntityFromCompilationUnit	(	entity	e,
		entity	cu
	)

Remove an entity from the current's module compilation unit declarations.

Parameters

[in]	e	is the entity to remove
[in]	cu	is the compilation unit

Parameters

cu

u

Definition at line 265 of file module.c.

                                                           {
    statement s = statement_undefined;
    const char* cum = module_local_name(cu);
    if( c_module_p(cu) ) {
        if(!db_resource_required_or_available_p(DBR_CODE,cum))
        {
            bool controlizer(const char*);
            entity tmp = get_current_module_entity();
            statement stmt = get_current_module_statement();
            reset_current_module_entity();
            reset_current_module_statement();
            controlizer(cum);
            if(!entity_undefined_p(tmp))
                set_current_module_entity(tmp);
            if(!statement_undefined_p(stmt))
                set_current_module_statement(stmt);
        }
        s=(statement)db_get_memory_resource(DBR_CODE,cum,true);
    }
 
    // Remove entity from global declaration lists
    gen_remove(&entity_declarations(cu),e);
    // FIXME : s is only defined for c_module !!
    gen_remove(&statement_declarations(s),e);
 
    remove_declaration_statement(s, e);
    if( c_module_p(cu) ) {
        module_reorder(s);
        db_put_or_update_memory_resource(DBR_CODE,cum,s,true);
        db_touch_resource(DBR_CODE,cum);
    }
}

References c_module_p(), controlizer(), db_get_memory_resource(), db_put_or_update_memory_resource(), db_resource_required_or_available_p(), db_touch_resource(), entity_declarations, entity_undefined_p, gen_remove(), get_current_module_entity(), get_current_module_statement(), module_local_name(), module_reorder(), remove_declaration_statement(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_declarations, statement_undefined, and statement_undefined_p.

Here is the call graph for this function:

scalar_assign_call()

entity scalar_assign_call

(

call

c

)

entity scalar_assign_call((call) c) Detects if the call is an assignement and if the value assigned is a scalar.

If it is so, it returns this scalar.

Definition at line 328 of file misc_paf_utils.c.

{
   entity ent = entity_undefined;
 
   debug( 7, "scalar_assign_call", "doing \n");
   if (ENTITY_ASSIGN_P(call_function(c)))
        {
        expression lhs;
 
        lhs = binary_call_lhs(c);
        ent = expression_int_scalar( lhs );
        }
   debug( 7, "scalar_assign_call", "returning : %s \n",
        ((ent == entity_undefined)?"entity_undefined":
                                entity_name(ent)) );
   return( ent );
}

References binary_call_lhs, call_function, debug(), ENTITY_ASSIGN_P, entity_name, entity_undefined, and expression_int_scalar().

Referenced by scalar_written_in_call(), and sp_feautrier_scalar_assign_call().

Here is the call graph for this function:

Here is the caller graph for this function:

scalar_written_in_call()

void scalar_written_in_call	(	call	the_call,
		list *	ell,
		list *	etl,
		list *	swfl
	)

scalar_written_in_call((call) the_call) Detects and puts a scalar written in an assignement call, in the global list Gscalar_written_forward if Genclosing_loops or Genclosing_tests are not empty.

Parameters

the_call	he_call
ell	ll
etl	tl
swfl	wfl

Definition at line 352 of file misc_paf_utils.c.

{
   entity ent;
 
   debug( 7, "scalar_written_in_call", "doing\n");
   if (    ((ent = scalar_assign_call(the_call)) != entity_undefined)
        && ( (*ell != NIL) || (*etl != NIL) )
        && entity_integer_scalar_p( ent ) )
 
        ADD_ELEMENT_TO_LIST(*swfl, ENTITY, ent);
}

References ADD_ELEMENT_TO_LIST, debug(), ENTITY, entity_integer_scalar_p(), entity_undefined, NIL, and scalar_assign_call().

Referenced by loop_normalize_of_statement().

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:

string_to_expression()

expression string_to_expression	(	const char *	s,
		entity	module
	)

expressions.c

expressions.c

try to parse s in the context of module module only simple expressions are found

try to find simple expression

unary operators

inary operators

Parameters

module

odule

Definition at line 50 of file expressions.c.

{
    entity e = string_to_entity(s,module);
    if(entity_undefined_p(e)) {
        /* try to find simple expression */
        /* unary operators */
        for(const char *iter = s ; *iter ; iter++) {
            if(isspace(*iter)) continue;
            if(*iter=='-') {
                expression etmp = string_to_expression(iter+1, module);
                if(!expression_undefined_p(etmp)) {
                    return MakeUnaryCall(entity_intrinsic(UNARY_MINUS_OPERATOR_NAME),
                            etmp);
                }
            }
        }
        
        /*binary operators*/
        static const char* seeds[] = {   PLUS_OPERATOR_NAME, MINUS_OPERATOR_NAME,MULTIPLY_OPERATOR_NAME, DIVIDE_OPERATOR_NAME};
        for(int i=0; i < (int) (sizeof(seeds)/sizeof(seeds[0])); i++) {
            char *where = strchr(s,seeds[i][0]);
            if(where) {
                char * head = strdup(s);
                char * tail = head + (where -s) +1 ;
                head[where-s]='\0';
                expression e0 = string_to_expression(head,module);
                expression e1 = string_to_expression(tail,module);
                free(head);
                if(!expression_undefined_p(e0) &&!expression_undefined_p(e1)) {
                    return MakeBinaryCall(
                            entity_intrinsic(seeds[i]),
                            e0,
                            e1
                            );
                }
                else {
                    free_expression(e0);
                    free_expression(e1);
                }
            }
        }
        return expression_undefined;
    }
    else
        return entity_to_expression(e);
}

References DIVIDE_OPERATOR_NAME, entity_intrinsic(), entity_to_expression(), entity_undefined_p, expression_undefined, expression_undefined_p, free(), free_expression(), int, MakeBinaryCall(), MakeUnaryCall(), MINUS_OPERATOR_NAME, module, MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, strdup(), string_to_entity(), and UNARY_MINUS_OPERATOR_NAME.

Referenced by loop_expansion(), loop_expansion_init(), maxima_simplify(), and string_to_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

string_to_expressions()

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

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

Parameters

str	tr
seed	eed
module	odule

Definition at line 98 of file expressions.c.

                                                                               {
    list strings = strsplit(str,seed);
    list expressions = NIL;
    FOREACH(STRING,s,strings) {
        expression expr = string_to_expression(s,module);
        if(!expression_undefined_p(expr)) {
            expressions = CONS(EXPRESSION,
                    expr,
                    expressions);
        }
    }
    gen_map(free,strings);
    gen_free_list(strings);
    return gen_nreverse(expressions);
}

References CONS, EXPRESSION, expression_undefined_p, FOREACH, free(), gen_free_list(), gen_map(), gen_nreverse(), module, NIL, STRING, string_to_expression(), and strsplit().

Referenced by symbolic_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

undefined_statement_list_p()

bool undefined_statement_list_p

(

list

l

)

=================================================================

bool undefined_statement_list_p( (list) l ) AL 04/93 Returns true if l is made of 2 undefined or continue statement.

Newgen does not support list of undefined objects

Definition at line 272 of file misc_paf_utils.c.

{
        bool            local_bool;
        statement       first, second;
 
        debug(7, "undefined_statement_list_p","doing\n");
        if ( (l == NIL) || (gen_length(l) != 2) )
                return( false );
 
        first = STATEMENT(CAR( l ));
        second = STATEMENT(CAR(CDR( l )));
        local_bool = ( first == statement_undefined )
                     && ( second == statement_undefined );
 
        /* Newgen does not support list of undefined objects */
        if(!local_bool) {
          local_bool = continue_statement_p(first) && continue_statement_p(second);
        }
 
        return( local_bool );
}

References CAR, CDR, continue_statement_p(), debug(), gen_length(), NIL, STATEMENT, and statement_undefined.

Referenced by loop_normalize_of_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

Gcount_nsp

int Gcount_nsp

extern

================================================================

Definition at line 158 of file misc_paf_utils.c.

Referenced by make_nsp_entity().

Gcount_nub

int Gcount_nub

extern

Definition at line 160 of file misc_paf_utils.c.

Referenced by make_nub_entity().