util.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "pipsdbm.h"
#include "properties.h"
#include "ri.h"
#include "ri-util.h"
#include "effects.h"
#include "effects-simple.h"

Include dependency graph for util.c:

Go to the source code of this file.

Data Structures
struct	flfl

Functions
static bool	filterout_statement (void *obj)
static bool	wipeout_entity (entity e)
	entities that match the following conditions are not cleaned from declarations: More...
static void	statement_clean_declarations_helper (list declarations, statement stmt)
	remove useless entities from declarations an entity is flagged useless when no reference is found in stmt and when it is not used by an entity found in stmt More...
static void	entity_generate_missing_declarations (entity module, statement s)
	check if all entities used in s and module are declared in module does not work as well as expected on c module because it does not fill the statement declaration More...
void	statement_clean_declarations (statement s)
	remove all the entity declared in s but never referenced it's a lower version of use-def-elim ! More...
void	entity_clean_declarations (entity module, statement s)
	remove all entities declared in module but never used in s More...
static bool	find_loop_from_label_walker (loop l, struct flfl *p)
statement	find_loop_from_label (statement s, entity label)
	hmmm... More...
static bool	clean_statement_label (statement st)
bool	clean_labels (const string mod_name)
int	get_processor_number (void)
int	get_vector_register_length (void)
int	get_vector_register_number (void)

Function Documentation

clean_labels()

bool clean_labels

(

const string

mod_name

)

Parameters

mod_name

od_name

Definition at line 238 of file util.c.

{
  statement mod_stmt = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
 
  set_current_module_entity(module_name_to_entity(mod_name));
  set_current_module_statement( mod_stmt);
 
  gen_recurse (mod_stmt, statement_domain, clean_statement_label, gen_null);
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE,
                             strdup(mod_name),
                             (char*) mod_stmt);
  
  reset_current_module_entity();
  reset_current_module_statement();
 
  return true;
}

References clean_statement_label(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, gen_null(), gen_recurse, module_name_to_entity(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_domain, and strdup().

Here is the call graph for this function:

clean_statement_label()

static bool clean_statement_label ( statement  st )

static

Definition at line 226 of file util.c.

{
  entity e = statement_label(st);
  const char* label_pattern = get_string_property("LABEL_EXCEPTION");
  bool exception = (*label_pattern!=0) && (strstr(entity_user_name(e),label_pattern)!=NULL);
  if(!entity_empty_label_p(e) &&  !exception) {
    gen_clear_tabulated_element((gen_chunk*)e);
    statement_label(st) = entity_empty_label();
  }
  return true;
}

References entity_empty_label(), entity_empty_label_p(), entity_user_name(), gen_clear_tabulated_element(), get_string_property(), and statement_label.

Referenced by clean_labels().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_clean_declarations()

void entity_clean_declarations	(	entity	module,
		statement	s
	)

remove all entities declared in module but never used in s

Parameters

module	module to check
s	statement where entites may be used

to keep backward compatibility with hpfc

Parameters

module

odule

Definition at line 177 of file util.c.

{
  entity curr = get_current_module_entity();
  if( ! same_entity_p(curr,module)) {
    reset_current_module_entity();
    set_current_module_entity(module);
  }
  else
    curr=entity_undefined;
 
  statement_clean_declarations_helper(entity_declarations(module),s);
  if(fortran_module_p(module)) /* to keep backward compatibility with hpfc*/
    entity_generate_missing_declarations(module,s);
 
  if(!entity_undefined_p(curr)){
    reset_current_module_entity();
    set_current_module_entity(curr);
  }
}

References entity_declarations, entity_generate_missing_declarations(), entity_undefined, entity_undefined_p, fortran_module_p(), get_current_module_entity(), module, reset_current_module_entity(), same_entity_p(), set_current_module_entity(), and statement_clean_declarations_helper().

Referenced by compile_module(), and module_clean_declarations().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_generate_missing_declarations()

static void entity_generate_missing_declarations ( entity  module, statement  s  )

static

check if all entities used in s and module are declared in module does not work as well as expected on c module because it does not fill the statement declaration

Parameters

module	module to check
s	statement where reference can be found

gather referenced entities

fill the declarations with missing entities (ohhhhh a nice 0(n²) algorithm

Definition at line 140 of file util.c.

{
  /* gather referenced entities */
  set referenced_entities = get_referenced_entities(s);
 
  /* fill the declarations with missing entities (ohhhhh a nice 0(n²) algorithm*/
  list new = NIL;
  SET_FOREACH(entity,e1,referenced_entities) {
    if(gen_chunk_undefined_p(gen_find_eq(e1,entity_declarations(module))))
      new=CONS(ENTITY,e1,new);
  }
 
  set_free(referenced_entities);
  sort_list_of_entities(new);
  entity_declarations(module)=gen_nconc(new,entity_declarations(module));
}

References CONS, ENTITY, entity_declarations, gen_chunk_undefined_p, gen_find_eq(), gen_nconc(), get_referenced_entities(), module, NIL, SET_FOREACH, set_free(), and sort_list_of_entities().

Referenced by entity_clean_declarations().

Here is the call graph for this function:

Here is the caller graph for this function:

filterout_statement()

static bool filterout_statement ( void *  obj )

static

Definition at line 48 of file util.c.

                                           {
  bool return_val = !INSTANCE_OF(statement,(gen_chunkp)obj);
  return return_val;
}

References INSTANCE_OF.

Referenced by statement_clean_declarations_helper().

Here is the caller graph for this function:

find_loop_from_label()

statement find_loop_from_label	(	statement	s,
		entity	label
	)

hmmm...

when all header files are not yet generated cproto may silently fail to generate these headers. this few declarations allow to generate headers without anything else. ri needed for statement_mapping in pipsdbm...

Parameters

label

abel

Definition at line 218 of file util.c.

{
  struct flfl ctx = { label, statement_undefined };
  gen_context_recurse(s, &ctx,
                      loop_domain, find_loop_from_label_walker, gen_null2);
  return ctx.found;
}

References find_loop_from_label_walker(), flfl::found, gen_context_recurse, gen_null2(), flfl::label, loop_domain, and statement_undefined.

Referenced by full_unroll(), get_loop_execution_parallel(), loop_auto_unroll(), loop_expansion(), loop_expansion_init(), loop_pragma(), module_loops(), print_loopnest_dependence_cone(), set_loop_execution_parallel(), simdizer_auto_tile(), symbolic_tiling(), and unroll().

Here is the call graph for this function:

Here is the caller graph for this function:

find_loop_from_label_walker()

static bool find_loop_from_label_walker ( loop  l, struct flfl *  p  )

static

Definition at line 204 of file util.c.

{
  statement s = (statement) gen_get_ancestor(statement_domain, l);
  entity
    do_lab_ent = loop_label(l),
    stmt_lab_ent = statement_label(s);
  if (gen_eq(p->label, do_lab_ent) || gen_eq(p->label, stmt_lab_ent) )
  {
    p->found = s;
    gen_recurse_stop(NULL);
  }
  return true;
}

References flfl::found, gen_eq(), gen_get_ancestor(), gen_recurse_stop(), flfl::label, loop_label, statement_domain, and statement_label.

Referenced by find_loop_from_label().

Here is the call graph for this function:

Here is the caller graph for this function:

get_processor_number()

int get_processor_number

(

void

)

Definition at line 261 of file util.c.

{
    return 16;
}

get_vector_register_length()

int get_vector_register_length

(

void

)

Definition at line 266 of file util.c.

{
    return 64;
}

get_vector_register_number()

int get_vector_register_number

(

void

)

Definition at line 271 of file util.c.

{
    return 8;
}

statement_clean_declarations()

void statement_clean_declarations

(

statement

s

)

remove all the entity declared in s but never referenced it's a lower version of use-def-elim !

cproto-generated files

Parameters

s	statement to check

Definition at line 164 of file util.c.

{
  if(statement_block_p(s)) {
    statement_clean_declarations_helper( statement_declarations(s),s);
  }
}

References statement_block_p, statement_clean_declarations_helper(), and statement_declarations.

Referenced by module_clean_declarations().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_clean_declarations_helper()

static void statement_clean_declarations_helper ( list  declarations, statement  stmt  )

static

remove useless entities from declarations an entity is flagged useless when no reference is found in stmt and when it is not used by an entity found in stmt

Parameters

declarations	list of entity to purge
stmt	statement where entities are used

look for entity that are used in the statement SG: we need to work on a copy of the declarations because of the RemoveLocalEntityFromDeclarations

filtered referenced entities are always used, some entity types listed in keep_entity cannot be wiped out

entities whose declaration have a side effect are always used too

one should check if dimensions do not have side effects either

do not keep the declaration, and remove it from any declaration_statement

Definition at line 80 of file util.c.

                    {
  set referenced_entities =
      get_referenced_entities_filtered(stmt,
          filterout_statement,
          wipeout_entity);
 
  /* look for entity that are used in the statement
   * SG: we need to work on  a copy of the declarations because of
   * the RemoveLocalEntityFromDeclarations
   */
  list decl_cpy = gen_copy_seq(declarations);
  FOREACH(ENTITY,e,decl_cpy) {
    /* filtered referenced entities are always used,
     * some entity types listed in keep_entity cannot be wiped out*/
    if(wipeout_entity(e) && !set_belong_p(referenced_entities, e)) {
      /* entities whose declaration have a side effect are always used too */
      bool has_side_effects_p = false;
      value v = entity_initial(e);
      list effects = NIL;
      if(value_expression_p(v))
        effects = gen_nconc(effects,
            expression_to_proper_effects(value_expression(v)));
      /* one should check if dimensions do not have side effects either */
      if(entity_variable_p(e)) {
        FOREACH(DIMENSION,dim,variable_dimensions(type_variable(entity_type(e))))
            {
          expression upper = dimension_upper(dim), lower = dimension_lower(dim);
          effects = gen_nconc(effects, expression_to_proper_effects(upper));
          effects = gen_nconc(effects, expression_to_proper_effects(lower));
            }
      }
      pips_debug(5,"Evaluating effects on %s\n",entity_name(e));
      FOREACH(EFFECT, eff, effects) {
        ifdebug(6) {
          print_effect(eff);
        }
        if(action_write_p(effect_action(eff)))
          has_side_effects_p = true;
      }
      gen_full_free_list(effects);
 
      /* do not keep the declaration, and remove it from any declaration_statement */
      if(!has_side_effects_p) {
        pips_debug(4,"Remove declaration for %s\n",entity_name(e));
        RemoveLocalEntityFromDeclarations(e, get_current_module_entity(), stmt);
      }
    }
  }
  gen_free_list(decl_cpy);
 
  set_free(referenced_entities);
}

References action_write_p, DIMENSION, dimension_lower, dimension_upper, EFFECT, effect_action, ENTITY, entity_initial, entity_name, entity_type, entity_variable_p, expression_to_proper_effects(), filterout_statement(), FOREACH, gen_copy_seq(), gen_free_list(), gen_full_free_list(), gen_nconc(), get_current_module_entity(), get_referenced_entities_filtered(), ifdebug, NIL, pips_debug, print_effect, RemoveLocalEntityFromDeclarations(), set_belong_p(), set_free(), type_variable, value_expression, value_expression_p, variable_dimensions, and wipeout_entity().

Referenced by entity_clean_declarations(), and statement_clean_declarations().

Here is the call graph for this function:

Here is the caller graph for this function:

wipeout_entity()

static bool wipeout_entity ( entity  e )

static

entities that match the following conditions are not cleaned from declarations:

Definition at line 56 of file util.c.

                                     {
  pips_debug(6,"Wipeout entity evaluating %s\n",entity_name(e));
  bool return_val = entity_not_constant_or_intrinsic_p(e) && // filters out constants and intrinsics
      !formal_parameter_p(e) &&
      !storage_return_p(entity_storage(e)) &&
      !entity_area_p(e)&&
      !entity_struct_p(e)&&
      !entity_union_p(e) &&
      !typedef_entity_p(e);
 
  pips_debug(6,"return %d\n",return_val);
 
  return return_val;
}

References entity_area_p(), entity_name, entity_not_constant_or_intrinsic_p(), entity_storage, entity_struct_p(), entity_union_p(), formal_parameter_p(), pips_debug, storage_return_p, and typedef_entity_p().

Referenced by statement_clean_declarations_helper().

Here is the call graph for this function:

Here is the caller graph for this function: