module.c File Reference

#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "text.h"
#include "constants.h"
#include "text-util.h"
#include "misc.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "pipsdbm.h"
#include "workspace-util.h"

Include dependency graph for module.c:

Go to the source code of this file.

Functions
list	module_declarations (entity m)
	High-level functions about modules, using pipsdbm and ri-util and some global variables assumed properly set. More...
list	current_module_declarations ()
list	module_entities (entity m)
	Return a list of all variables and functions accessible somewhere in a module. More...
entity	module_entity_to_compilation_unit_entity (entity m)
	Retrieve the compilation unit containing a module definition. More...
bool	language_module_p (entity m, string lid)
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. More...
void	RemoveEntityFromCompilationUnit (entity e, entity cu)
	Remove an entity from the current's module compilation unit declarations. More...
void	AddEntityToModuleCompilationUnit (entity e, entity module)
list	module_to_all_declarations (entity m)
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. More...
string	module_name_to_input_file_name (const char *module_name)
	To be checked for static functions... More...

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:

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;
}

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

Referenced by actual_c_parser(), add_new_module_from_text(), build_real_resources(), cast_STEP_ARG(), create_module_with_statement(), entity_from_user_name(), entity_more_or_less_minimal_name(), freia_data2d_field(), generic_initializer(), inline_expression_call(), linearize_array_generic(), normalize_microcode(), outliner_file(), outliner_scan(), simd_memory_packing(), sort_parameters(), step_compile_generated_module(), step_parameter(), string_to_entity(), and update_referenced_entities().

Here is the call graph for this function:

Here is the caller 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:

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:

module_declarations()

list module_declarations

(

entity

m

)

High-level functions about modules, using pipsdbm and ri-util and some global variables assumed properly set.

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:

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: