transformations.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef enum dead_test	dead_test

Enumerations
enum	dead_test {   nothing_about_test , then_is_dead , else_is_dead , nothing_about_test ,   then_is_dead , else_is_dead }
	Warning! Do not modify this file that is automatically generated! More...

Functions
void	statement_clean_declarations (statement)
	cproto-generated files More...
void	entity_clean_declarations (entity, statement)
	remove all entities declared in module but never used in s More...
statement	find_loop_from_label (statement, entity)
bool	clean_labels (const string)
int	get_processor_number (void)
int	get_vector_register_length (void)
int	get_vector_register_number (void)
void	do_loop_unroll (statement, int, void(*)(statement))
	loop_unroll.c More...
void	loop_unroll (statement, int)
	fallbacks on do_loop_unroll without statement post processing More...
bool	loop_fully_unrollable_p (loop)
void	full_loop_unroll (statement)
	get rid of the loop by body replication; More...
bool	unroll (const string)
	Top-level functions. More...
bool	full_unroll (const string)
bool	full_unroll_pragma (const string)
bool	print_parallelizedcray_code (char *)
	prettyprintcray.c More...
statement	loop_strip_mine (statement, int, int)
	strip_mine.c More...
bool	strip_mine (const string)
	Top-level function. More...
bool	selected_loop_p (statement)
bool	interactive_loop_transformation (const char *, statement(*)(list, bool(*)(statement)))
bool	print_loops (const string)
bool	flag_loops (const string)
	put a label on each doloop without label More...
char *	loop_pragma (const char *, const char *)
char *	module_loops (const char *, const char *)
	gather the list of enclosing loops expect flag_loops has been called before More...
void	loop_normalize_statement (statement)
	loop_normalize.c More...
bool	loop_normalize (const string)
bool	linearize_loop_range (const char *)
statement	interchange_inner_outermost_loops (list, bool(*)(statement))
	interchange.c More...
statement	interchange_two_loops (list, int, int)
bool	loop_interchange (const string)
bool	nest_parallelization (const char *)
	nest_parallelization.c More...
bool	coarse_grain_parallelization (const string)
	coarse_grain_parallelization.c More...
bool	coarse_grain_parallelization_with_reduction (const string)
bool	dead_code_elimination_on_module (char *, bool)
	dead_code_elimination.c More...
bool	dead_code_elimination (char *)
bool	dead_code_elimination_with_out_regions (char *)
bool	use_def_elimination (char *)
bool	suppress_trivial_test (const string)
	trivial_test_elimination.c More...
bool	privatize_module (const string)
	privatize.c More...
bool	privatize_module_even_globals (const string)
bool	localize_declaration (const string)
bool	array_privatizer (const string)
	array_privatization.c More...
bool	array_section_privatizer (const string)
bool	print_code_privatized_regions (const string)
bool	declarations_privatizer (const string)
bool	stf (const string)
	standardize_structure.c More...
bool	simplify_control (const string)
	simplify_control.c More...
bool	simplify_control_directly (const string)
bool	suppress_dead_code (const string)
bool	remove_useless_label (const string)
void	module_clean_declarations (entity, statement)
	declarations.c More...
bool	clean_declarations (const string)
	A phase to remove the declaration of useless variables. More...
bool	clean_unused_dynamic_variables (string)
	dynamic_declarations.c More...
bool	transformation_test (const string)
	transformation_test.c More...
bool	freeze_variables (char *)
	freeze_variables.c More...
bool	array_resizing_bottom_up (char *)
	array_resizing_bottom_up.c More...
bool	array_resizing_full_bottom_up (char *)
bool	array_resizing_top_down (const char *)
	array_resizing_top_down.c More...
bool	array_resizing_statistic (const string)
	array_resizing_statistic.c More...
bool	partial_redundancy_elimination (const string)
	partial_redundancy_elimination.c More...
bool	variable_expansion (const char *)
	variable_expansion.c More...
bool	reduction_variable_expansion (const char *)
bool	internalize_parallel_code (const string)
	internalize_parallel_code.c More...
bool	index_set_splitting (const string)
	index_set_splitting.c More...
bool	force_loop_fusion (const string)
bool	recover_for_loop (const string)
	for_loop_recovering.c More...
bool	scalarization (const string)
	scalarization.c More...
bool	constant_array_scalarization (const string)
bool	quick_scalarization (const string)
bool	statement_flatten_declarations (entity, statement)
	flatten_code.c More...
bool	flatten_code (const string)
	Pipsmake 'flatten_code' phase. More...
void	statement_split_initializations (statement)
	Recurse through the statements of s and split local declarations. More...
bool	split_initializations (const char *)
	Pipsmake 'split_initializations' phase. More...
void	split_update_call (call)
bool	split_update_operator (const char *)
bool	induction_substitution (const string)
	induction_substitution.c More...
bool	strength_reduction (const string)
	strength_reduction.c More...
bool	loop_fusion (char *)
	loop_fusion.c More...
bool	loop_fusion_with_regions (char *)
bool	set_return_type_as_typedef (const string)
	set_return_type.c More...
bool	cast_at_call_sites (const string)
	cast_at_call_sites.c More...
bool	limit_nested_parallelism (const string)
	manage_parallel_loops.c More...
bool	limit_parallelism_using_complexity (const string)
bool	force_register_declarations (const char *)
	registers.c More...
bool	identity_elimination (const char *)
	identity_elimination.c More...
bool	identity_elimination_with_points_to (const char *)
bool	loop_bound_minimization_with_out_regions_on_statement (statement)
	loop_bound_minimization.c More...
bool	loop_bound_minimization_with_out_regions (const char *)
bool	print_interface (const char *)
	cprettyprinter.c More...
bool	print_crough (const char *)
bool	print_c_code (const char *)
	C indentation thru indent. More...
bool	check_initialize_vla_with_preconditions (const string)
	initialized_vla.c More...
bool	check_initialize_vla_with_effects (const string)
bool	check_initialize_vla_with_regions (const string)
bool	initialize_vla_with_preconditions (const char *)
bool	initialize_vla_with_effects (const char *)
bool	initialize_vla_with_regions (const char *)

Variables
entity	selected_label
	interactive_loop_transformation.c More...

Typedef Documentation

dead_test

typedef enum dead_test dead_test

Definition at line 1 of file transformations.h.

Enumeration Type Documentation

dead_test

enum dead_test

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

Modify src/Libs/transformations/transformations-local.h instead, to add your own modifications. header file built by cproto transformations-local.h What is returned by dead_test_filter :

Enumerator
nothing_about_test
then_is_dead
else_is_dead
nothing_about_test
then_is_dead
else_is_dead

Definition at line 35 of file transformations.h.

{ nothing_about_test, then_is_dead, else_is_dead };

Function Documentation

array_privatizer()

bool array_privatizer

(

const

string

)

array_privatization.c

Parameters

string

odule_name

array_resizing_bottom_up()

bool array_resizing_bottom_up

(

char *

)

array_resizing_bottom_up.c

array_resizing_full_bottom_up()

bool array_resizing_full_bottom_up

(

char *

)

array_resizing_statistic()

bool array_resizing_statistic

(

const

string

)

array_resizing_statistic.c

Parameters

string

odule_name

array_resizing_top_down()

bool array_resizing_top_down

(

const char *

)

array_resizing_top_down.c

array_section_privatizer()

bool array_section_privatizer

(

const

string

)

Parameters

string

odule_name

cast_at_call_sites()

bool cast_at_call_sites

(

const

string

)

cast_at_call_sites.c

Parameters

string

od_name

check_initialize_vla_with_effects()

bool check_initialize_vla_with_effects

(

const

string

)

Parameters

string

odule_name

check_initialize_vla_with_preconditions()

bool check_initialize_vla_with_preconditions

(

const

string

)

initialized_vla.c

Parameters

string

odule_name

check_initialize_vla_with_regions()

bool check_initialize_vla_with_regions

(

const

string

)

Parameters

string

odule_name

clean_declarations()

bool clean_declarations

(

const string

module_name

)

A phase to remove the declaration of useless variables.

It recursively calls statement_remove_unused_declarations on all module statement

Parameters

[in]

module_name

is the name of the module to process

Returns

true because always successful

prelude

first remove any statement that writes only variable that are never read

body

ostlude

Parameters

module_name

odule_name

Definition at line 155 of file declarations.c.

{
  /* prelude */
  set_current_module_entity(module_name_to_entity( module_name ));
  set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
  set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS,module_name,true));
 
  debug_on("CLEAN_DECLARATIONS_DEBUG_LEVEL");
 
  /* first remove any statement that writes only variable that are never read */
  gen_recurse(get_current_module_statement(),statement_domain,gen_true,remove_unread_variables);
 
  /* body*/
  module_clean_declarations(get_current_module_entity(),get_current_module_statement());
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
  debug_off();
 
  /*postlude */
  reset_cumulated_rw_effects();
  reset_current_module_entity();
  reset_current_module_statement();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), get_current_module_entity(), get_current_module_statement(), module_clean_declarations(), module_name(), module_name_to_entity(), remove_unread_variables(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

clean_labels()

bool clean_labels

(

const

string

)

Parameters

string

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_unused_dynamic_variables()

bool clean_unused_dynamic_variables

(

string

)

dynamic_declarations.c

coarse_grain_parallelization()

bool coarse_grain_parallelization

(

const

string

)

coarse_grain_parallelization.c

Parameters

string

odule_name

coarse_grain_parallelization_with_reduction()

bool coarse_grain_parallelization_with_reduction

(

const

string

)

Parameters

string

odule_name

constant_array_scalarization()

bool constant_array_scalarization

(

const

string

)

Parameters

string

odule_name

dead_code_elimination()

bool dead_code_elimination

(

char *

)

dead_code_elimination_on_module()

bool dead_code_elimination_on_module	(	char *	,
		bool
	)

dead_code_elimination.c

dead_code_elimination_with_out_regions()

bool dead_code_elimination_with_out_regions

(

char *

)

declarations_privatizer()

bool declarations_privatizer

(

const

string

)

Parameters

string

od_name

do_loop_unroll()

void do_loop_unroll	(	statement	loop_statement,
		int	rate,
		void(*)(statement)	statement_post_processor
	)

loop_unroll.c

Parameters

loop_statement	oop_statement
rate	ate

Definition at line 714 of file loop_unroll.c.

{
  pips_debug(2, "unroll %d times\n", rate);
  pips_assert("the statement is a loop",
              instruction_loop_p(statement_instruction(loop_statement)));
  pips_assert("the unrolling factor is strictly positive", rate > 0);
 
  if(rate>1) {
    loop il = instruction_loop(statement_instruction(loop_statement));
    range lr = loop_range(il);
    expression inc = range_increment(lr);
    intptr_t incval;
 
    // FI: a property should be checked because epilogue cannot be
    // used if backward compatibility must be maintained
    if(expression_integer_value(inc, &incval) && incval==1
       && !get_bool_property("LOOP_UNROLL_WITH_PROLOGUE"))
      do_loop_unroll_with_epilogue(loop_statement,
                                   rate,
                                   statement_post_processor);
    else
      do_loop_unroll_with_prologue(loop_statement,
                                   rate,
                                   statement_post_processor);
  }
  pips_debug(3, "done\n");
}

References do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), expression_integer_value(), get_bool_property(), instruction_loop, instruction_loop_p, intptr_t, loop_range, pips_assert, pips_debug, range_increment, and statement_instruction.

Referenced by loop_unroll(), and simd_loop_unroll().

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:

find_loop_from_label()

statement find_loop_from_label	(	statement	s,
		entity	label
	)

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(), loop_auto_unroll(), loop_expansion(), loop_expansion_init(), loop_pragma(), module_loops(), print_loopnest_dependence_cone(), simdizer_auto_tile(), symbolic_tiling(), and unroll().

Here is the call graph for this function:

Here is the caller graph for this function:

flag_loops()

bool flag_loops

(

const string

module_name

)

put a label on each doloop without label

Parameters

module_name

Returns

prelude

run loop labeler

validate

ostlude

Parameters

module_name

odule_name

Definition at line 191 of file interactive_loop_transformation.c.

{
  /* prelude */
  set_current_module_entity(module_name_to_entity( module_name ));
  set_current_module_statement
    ((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
  flag_loop_param_t flp = { .loops = NIL, .new_label_created = false };
 
  /* run loop labeler */
  gen_context_recurse(get_current_module_statement(), &flp,
                      statement_domain, gen_true2, flag_loop);
 
  /* validate */
  if( flp.new_label_created) DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
  DB_PUT_MEMORY_RESOURCE(DBR_LOOPS, module_name,make_callees(flp.loops));
 
  /*postlude*/
  reset_current_module_entity();
  reset_current_module_statement();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, flag_loop(), gen_context_recurse, gen_true2(), get_current_module_statement(), flag_loop_param_t::loops, make_callees(), module_name(), module_name_to_entity(), flag_loop_param_t::new_label_created, NIL, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

flatten_code()

bool flatten_code

(

const string

module_name

)

Pipsmake 'flatten_code' phase.

This function is be composed of several steps:

1 flatten declarations inside statement: declarations are moved as high as possible in the control structure; this may serialize parallel loops, but this pass was designed for sequential code.

2 clean_up_sequences: remove useless braces when they are nested.

3 unroll looops with statically known iteration number.

4 clean_up_sequences: remove useless braces when they are nested.

It is assumed that the function main statement will contain at least one local variable. This is used to preserve the scoping mechanism used by the parser. Thus, "void foo(void){{{}}}" cannot be flatten. Note that clean_up_sequences could be used first to avoid such cases. Function "void foo(void){{{extern int i;}}}" cannot be flatten either, but clean_up_sequences might help.

Is it a top-level entity?

Parameters

module_name

odule_name

Definition at line 648 of file flatten_code.c.

{
  bool good_result_p = true;
 
  set_current_module_entity(module_name_to_entity(module_name));
  entity module = get_current_module_entity();
  value mv = entity_initial(module);
  code c = value_code(mv); // No check on value's kind
  list dl = code_declarations(c);
 
  debug_on("FLATTEN_CODE_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  // Step 0: the algorithms used do not deal with dependent or
  // variable-length array (VLA) types unless they are formal parameters
  // or appear at top-level... (see TRAC ticket 751)
  // Declarations are moved to the top, without any regard to data dependencies
  FOREACH(ENTITY, v, dl) {
    if(!entity_formal_p(v)) {
      type t = entity_type(v);
      if(dependent_type_p(t)) {
        string eln = (string) entity_local_name(v);
        string s = local_name_to_scope(eln);
        /* Is it a top-level entity? */
        if(strlen(s)>2) {
          good_result_p = false;
          break;
        }
        else {
          pips_user_warning("Code generated by pass Flatten_code may be wrong"
                            " because of VLA type of variable \"%s\"\n",
                            entity_user_name(v));
        }
      }
    }
  }
 
  if(!good_result_p) {
    pips_user_warning("Module \"%s\" could not be flattened because it uses a variable-length array (VLA).\n", entity_user_name(module));
  }
  else {
    set_current_module_statement( (statement)
                                  db_get_memory_resource(DBR_CODE, module_name, true) );
    statement module_stat = get_current_module_statement();
 
    // Step 1 and 2: flatten declarations and clean up sequences
    if ((good_result_p=statement_flatten_declarations(module,module_stat)))
      {
        statement_purge_declarations(module_stat);
        // call sequence flattening as some declarations may have been moved up
        clean_up_sequences(module_stat);
 
        // Step 3 and 4: unroll loops and clean up sequences
        if(get_bool_property("FLATTEN_CODE_UNROLL"))
  {
    gen_recurse(module_stat,
                statement_domain, gen_true, unroll_loops_in_statement);
    clean_up_sequences(module_stat); // again
  }
 
        // This might not be necessary, thanks to clean_up_sequences
        module_reorder(module_stat);
        // Save modified code to database
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_stat);
      }
  reset_current_module_statement();
  }
 
  pips_debug(1, "end\n");
  debug_off();
 
  reset_current_module_entity();
 
  return good_result_p;
}

References clean_up_sequences(), code_declarations, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dependent_type_p(), ENTITY, entity_formal_p(), entity_initial, entity_local_name(), entity_type, entity_user_name(), FOREACH, gen_recurse, gen_true(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), local_name_to_scope(), module, module_name(), module_name_to_entity(), module_reorder(), pips_debug, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_domain, statement_flatten_declarations(), statement_purge_declarations(), strdup(), unroll_loops_in_statement(), and value_code.

Here is the call graph for this function:

force_loop_fusion()

bool force_loop_fusion

(

const

string

)

Parameters

string

odule_name

force_register_declarations()

bool force_register_declarations

(

const char *

)

registers.c

freeze_variables()

bool freeze_variables

(

char *

)

freeze_variables.c

full_loop_unroll()

void full_loop_unroll

(

statement

loop_statement

)

get rid of the loop by body replication;

the loop body is replicated as many times as there are iterations

FI: could be improved to handle symbolic lower bounds (18 January 1993)

final loop body label

Start debug in Newgen

Validity of transformation should be checked

ie.: - pas d'effets de bords dans les expressions duplique'es

Instruction block is created and will contain everything

get rid of labels in loop body: don't worry, useful labels have been transformed into arcs by controlizer, you just loose loop labels. However, the label of the last statement in the loop body might be used by an outer loop and, in doubt, should be preserved.

FI: clone_statement() has been used above to perform flatten_code. Hence the declarations are no longer accessible from "transformed_stmt". And when dependent types are used, they are not updated.

Try to update dependent types. Too bad the declarations are scanned again and again.

Add the transformated old loop body (transformed_stmt) at the end of the loop

Generate a CONTINUE to carry the final loop body label in case an outer loop uses it

Generate a statement to reinitialize old index

SG: only needed if index is not private

Free old instruction and replace with block

FI: according to me, gen_copy_tree() does not create a copy sharing nothing with its actual parameter; if the free is executed, Pvecteur normalized_linear is destroyed (18 January 1993)

Do not forget to move forbidden information associated with block:

?? Bad condition

Stop debug in Newgen

Parameters

loop_statement

oop_statement

Definition at line 788 of file loop_unroll.c.

{
    loop il = instruction_loop(statement_instruction(loop_statement));
    range lr = loop_range(il);
    entity ind = loop_index(il);
    entity flbl = entity_undefined; /* final loop body label */
    expression lb = range_lower(lr);
    expression ub = range_upper(lr);
    expression inc = range_increment(lr);
    expression rhs_expr, expr;
    statement stmt;
    instruction block;
    intptr_t lbval, ubval, incval;
    int iter;
 
    pips_debug(2, "begin\n");
 
    ifdebug(7) {
      /* Start debug in Newgen */
      gen_debug |= GEN_DBG_CHECK;
    }
    /* Validity of transformation should be checked */
    /* ie.: - pas d'effets de bords dans les expressions duplique'es */
 
    if (expression_integer_value(lb, &lbval)
        && expression_integer_value(ub, &ubval)
        && expression_integer_value(inc, &incval)) {
      pips_assert("full_loop_unroll", incval != 0);
    }
    else {
      pips_user_error("loop range for loop %s must be numerically known\n",
                      label_local_name(loop_label(il)));
      // previous function is noreturn... but try to please lang.
      return;
    }
 
    /* Instruction block is created and will contain everything */
    block = make_instruction_block(NIL);
 
    /* get rid of labels in loop body: don't worry, useful labels have
       been transformed into arcs by controlizer, you just loose loop
       labels. However, the label of the last statement in the loop body
       might be used by an outer loop and, in doubt, should be preserved. */
 
    flbl = find_final_statement_label(loop_body(il));
 
    (void) clear_labels (loop_body (il));
 
    for(iter = lbval; iter <= ubval; iter += incval) {
        statement transformed_stmt;
 
        clone_context cc = make_clone_context(
                get_current_module_entity(),
                get_current_module_entity(),
                NIL,
                get_current_module_statement() );
        transformed_stmt = clone_statement(loop_body(il), cc);
        free_clone_context(cc);
 
        ifdebug(9)
            statement_consistent_p(transformed_stmt);
        expr = int_to_expression(iter);
        ifdebug(9) {
            pips_assert("full_loop_unroll", expression_consistent_p(expr));
        }
        /* FI: clone_statement() has been used above to perform
           flatten_code. Hence the declarations are no longer
           accessible from "transformed_stmt". And when dependent
           types are used, they are not updated. */
        replace_entity_by_expression(transformed_stmt,ind,expr);
        /* Try to update dependent types. Too bad the declarations are
           scanned again and again. */
        FOREACH(ENTITY,e,statement_declarations(get_current_module_statement()))
          replace_entity_by_expression(entity_type(e),ind,expr);
 
        ifdebug(9) {
            pips_assert("full_loop_unroll", statement_consistent_p(transformed_stmt));
        }
        free_expression(expr);
 
        ifdebug(9) {
            pips_assert("full_loop_unroll", statement_consistent_p(transformed_stmt));
        }
 
        /* Add the transformated old loop body (transformed_stmt) at
         * the end of the loop */
        if( statement_block_p(transformed_stmt) && get_bool_property("LOOP_UNROLL_MERGE"))
        {
            if(ENDP(statement_declarations(loop_statement)))
                statement_declarations(loop_statement)=statement_declarations(transformed_stmt);
            else {
                list declaration_initializations = NIL;
                FOREACH(ENTITY,e,statement_declarations(transformed_stmt))
                {
                    value v = entity_initial(e);
                    if( value_expression_p(v) )
                    {
                        statement s = make_assign_statement(
                                entity_to_expression(e),
                                copy_expression(value_expression(v)));
                        declaration_initializations=CONS(STATEMENT,s,declaration_initializations);
                    }
                }
                declaration_initializations=gen_nreverse(declaration_initializations);
                instruction_block(statement_instruction(transformed_stmt))=
                    gen_nconc(declaration_initializations,instruction_block(statement_instruction(transformed_stmt)));
            }
            instruction_block(block) =
                gen_nconc( instruction_block(block),
                        instruction_block(statement_instruction(transformed_stmt)));
        }
        else {
            instruction_block(block) = 
                gen_nconc(instruction_block(block),
                        CONS(STATEMENT, transformed_stmt, NIL));
        }
    }
 
    /* Generate a CONTINUE to carry the final loop body label in case an
       outer loop uses it */
    if(!entity_empty_label_p(flbl)) {
      stmt = make_continue_statement(flbl);
      ifdebug(9) {
        print_statement(stmt);
        pips_assert("full_loop_unroll", statement_consistent_p(stmt));
      }
      instruction_block(block)= gen_nconc(instruction_block(block),
                                          CONS(STATEMENT, stmt, NIL ));
    }
 
    /* Generate a statement to reinitialize old index */
    /* SG: only needed if index is not private */
    if(entity_in_list_p(ind,loop_locals(il))) {
        rhs_expr = int_to_expression(iter);
        expr = make_ref_expr(ind, NIL);
        stmt = make_assign_statement(expr, rhs_expr);
        ifdebug(9) {
            print_statement(stmt);
            pips_assert("full_loop_unroll", statement_consistent_p(stmt));
        }
        instruction_block(block)= gen_nconc(instruction_block(block),
                CONS(STATEMENT, stmt, NIL ));
    }
 
 
    /* Free old instruction and replace with block */
    /* FI: according to me, gen_copy_tree() does not create a copy sharing nothing
     * with its actual parameter; if the free is executed, Pvecteur normalized_linear
     * is destroyed (18 January 1993) */
    free_instruction(statement_instruction(loop_statement));
    statement_instruction(loop_statement) = block;
    /* Do not forget to move forbidden information associated with
       block: */
    fix_sequence_statement_attributes(loop_statement);
    clean_up_sequences(loop_statement);
 
    ifdebug(9) {
      print_statement(loop_statement);
      pips_assert("full_loop_unroll", statement_consistent_p(loop_statement));
    }
    /* ?? Bad condition */
    if(get_debug_level()==7) {
        /* Stop debug in Newgen */
        gen_debug &= ~GEN_DBG_CHECK;
    }
 
    pips_debug(3, "done\n");
}

References clean_up_sequences(), clear_labels(), clone_statement(), CONS, copy_expression(), ENDP, ENTITY, entity_empty_label_p(), entity_in_list_p(), entity_initial, entity_to_expression(), entity_type, entity_undefined, expression_consistent_p(), expression_integer_value(), find_final_statement_label(), fix_sequence_statement_attributes(), FOREACH, free_clone_context(), free_expression(), free_instruction(), GEN_DBG_CHECK, gen_debug, gen_nconc(), gen_nreverse(), get_bool_property(), get_current_module_entity(), get_current_module_statement(), get_debug_level(), ifdebug, instruction_block, instruction_loop, int_to_expression(), intptr_t, label_local_name(), loop_body, loop_index, loop_label, loop_locals, loop_range, make_assign_statement(), make_clone_context(), make_continue_statement(), make_instruction_block(), make_ref_expr(), NIL, pips_assert, pips_debug, pips_user_error, print_statement(), range_increment, range_lower, range_upper, replace_entity_by_expression(), STATEMENT, statement_block_p, statement_consistent_p(), statement_declarations, statement_instruction, value_expression, and value_expression_p.

Referenced by apply_full_loop_unroll(), find_unroll_pragma_and_fully_unroll(), full_unroll(), simd_loop_unroll(), terapixify_loops(), unroll_loops_in_statement(), and unroll_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

full_unroll()

bool full_unroll

(

const

string

)

user interaction

prelude

do the job

Reorder the module, because new statements have been generated.

ostlude

Reorder the module, because new statements have been generated.

Parameters

string

od_name

Definition at line 1077 of file loop_unroll.c.

{
    statement mod_stmt = statement_undefined;
    const char *lp_label = string_undefined;
    entity lb_ent = entity_undefined;
    bool return_status = true;
 
    debug_on("FULL_UNROLL_DEBUG_LEVEL");
 
    /* user interaction */
    lp_label = get_string_property_or_ask("LOOP_LABEL","loop to fully unroll ?");
    if( empty_string_p(lp_label) )
        return_status = false;
    else {
        lb_ent = find_label_entity(mod_name,lp_label);
        if( entity_undefined_p(lb_ent) )
            pips_user_warning("loop label `%s' does not exist, unrolling all loops\n", lp_label);
        mod_stmt = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
 
        /* prelude */
        set_current_module_entity(module_name_to_entity( mod_name ));
        set_current_module_statement( mod_stmt);
 
        /* do the job */
        if(entity_undefined_p(lb_ent)) {
            gen_recurse (mod_stmt, statement_domain, 
                    (bool(*)(void*))apply_full_loop_unroll, gen_null);
        }
        else {
            statement loop_statement = find_loop_from_label(mod_stmt,lb_ent);
            if( statement_undefined_p(loop_statement) )
                pips_user_error("label '%s' is not put on a loop\n",lp_label);
            else
                full_loop_unroll(loop_statement);
        }
 
        /* Reorder the module, because new statements have been generated. */
        module_reorder(mod_stmt);
 
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
        /*postlude*/
        reset_current_module_entity();
        reset_current_module_statement();
    }
    if( !return_status)
        user_log("transformation has been cancelled\n");
    pips_debug(2,"done for %s\n", mod_name);
    debug_off();
        /* Reorder the module, because new statements have been generated. */
        module_reorder(mod_stmt);
 
    return return_status;
}

References apply_full_loop_unroll(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, empty_string_p(), entity_undefined, entity_undefined_p, find_label_entity(), find_loop_from_label(), full_loop_unroll(), gen_null(), gen_recurse, get_string_property_or_ask(), module_name_to_entity(), module_reorder(), pips_debug, pips_user_error, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_domain, statement_undefined, statement_undefined_p, string_undefined, and user_log().

Here is the call graph for this function:

full_unroll_pragma()

bool full_unroll_pragma

(

const

string

)

Keep track of effects on code

Perform the loop unrollings

Perform the transformation bottom up to reduce the scanning and the number of unrollings

Reorder the module, because new statements have been generated.

Provide statistics about changes performed

Parameters

string

od_name

Definition at line 1170 of file loop_unroll.c.

{
  set_current_module_entity(module_name_to_entity(mod_name));
  set_current_module_statement( (statement) db_get_memory_resource(DBR_CODE, mod_name, true) );
 
  statement mod_stmt = statement_undefined;
  bool return_status = false;
 
  debug_on("FULL_UNROLL_DEBUG_LEVEL");
 
  debug(1,"full_unroll_pragma","Fully unroll loops with pragma in module %s\n",
        mod_name);
 
  /* Keep track of effects on code */
  number_of_unrolled_loops = 0;
  number_of_requested_unrollings = 0;
 
  /* Perform the loop unrollings */
  mod_stmt = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
 
  // gen_recurse (mod_stmt, statement_domain, 
  // find_unroll_pragma_and_fully_unroll, gen_null);
 
  /* Perform the transformation bottom up to reduce the scanning and the
     number of unrollings */
  gen_recurse (mod_stmt, statement_domain, 
               gen_true, find_unroll_pragma_and_fully_unroll);
 
  /* Reorder the module, because new statements have been generated. */
  module_reorder(mod_stmt);
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
 
  /* Provide statistics about changes performed */
  if(number_of_unrolled_loops == number_of_requested_unrollings) {
    user_log("%d loop%s unrolled as requested\n", number_of_unrolled_loops,
             number_of_unrolled_loops>1?"s":"");
    return_status = true;
  }
  else {
    int failures = number_of_requested_unrollings - number_of_unrolled_loops;
    user_log("%d loop%s unrolled as requested\n", number_of_unrolled_loops,
             number_of_unrolled_loops>1?"s":"");
    user_log("%d loop%s could not be unrolled as requested\n", failures,
             failures>1?"s":"");
    return_status = false;
  }
 
  debug(1,"full_unroll_pragma","done for %s\n", mod_name);
  debug_off();
 
  reset_current_module_entity();
  reset_current_module_statement();
 
  return return_status;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, find_unroll_pragma_and_fully_unroll(), gen_recurse, gen_true(), module_name_to_entity(), module_reorder(), number_of_requested_unrollings, number_of_unrolled_loops, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_domain, statement_undefined, and user_log().

Here is the call 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;
}

identity_elimination()

bool identity_elimination

(

const char *

)

identity_elimination.c

identity_elimination_with_points_to()

bool identity_elimination_with_points_to

(

const char *

)

index_set_splitting()

bool index_set_splitting

(

const

string

)

index_set_splitting.c

Parameters

string

odule_name

induction_substitution()

bool induction_substitution

(

const

string

)

induction_substitution.c

Parameters

string

odule_name

initialize_vla_with_effects()

bool initialize_vla_with_effects

(

const char *

)

initialize_vla_with_preconditions()

bool initialize_vla_with_preconditions

(

const char *

)

initialize_vla_with_regions()

bool initialize_vla_with_regions

(

const char *

)

interactive_loop_transformation()

bool interactive_loop_transformation	(	const char *	module_name,
		statement(*)(list, bool(*)(statement))	loop_transformation
	)

DBR_CODE will be changed: argument "pure" should take false but this would be useless since there is only one version of code; a new version will be put back in the data base after transforming the loops

Get the loop label from the user

Reorder the module, because new statements have been generated.

Parameters

module_name

odule_name

Definition at line 73 of file interactive_loop_transformation.c.

{
  const char *lp_label=NULL;
  entity module = module_name_to_entity(module_name);
  statement s = statement_undefined;
  bool return_status = false;
 
  pips_assert("interactive_loop_transformation", entity_module_p(module));
 
  /* DBR_CODE will be changed: argument "pure" should take false but
     this would be useless since there is only *one* version of code;
     a new version will be put back in the data base after transforming
     the loops */
  s = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  set_current_module_entity(module);
  set_current_module_statement(s);
 
  /* Get the loop label from the user */
      lp_label = get_string_property_or_ask("LOOP_LABEL","Which loop do you want to transform?\n"
                            "(give its label): ");
      if( string_undefined_p( lp_label ) )
        {
          pips_user_error("please set %s  property to a valid label\n","LOOP_LABEL");
        }
 
  if(lp_label)
    {
      selected_label = find_label_entity(module_name, lp_label);
      if (entity_undefined_p(selected_label)) {
        pips_user_error("loop label `%s' does not exist\n", lp_label);
      }
 
      debug_on("INTERACTIVE_LOOP_TRANSFORMATION_DEBUG_LEVEL");
 
      look_for_nested_loop_statements(s, loop_transformation, selected_loop_p);
 
      debug_off();
 
      /* Reorder the module, because new statements have been generated. */
      module_reorder(s);
 
      DB_PUT_MEMORY_RESOURCE(DBR_CODE,
                             strdup(module_name),
                             (char*) s);
      return_status = true;
    }
  reset_current_module_entity();
  reset_current_module_statement();
 
  return return_status;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, entity_module_p(), entity_undefined_p, find_label_entity(), get_string_property_or_ask(), look_for_nested_loop_statements(), module, module_name(), module_name_to_entity(), module_reorder(), pips_assert, pips_user_error, reset_current_module_entity(), reset_current_module_statement(), selected_label, selected_loop_p(), set_current_module_entity(), set_current_module_statement(), statement_undefined, strdup(), and string_undefined_p.

Referenced by loop_hyperplane(), loop_tiling(), and parallel_loop_tiling().

Here is the call graph for this function:

Here is the caller graph for this function:

interchange_inner_outermost_loops()

statement interchange_inner_outermost_loops	(	list	,
		bool(*)(statement)
	)

interchange.c

interchange_two_loops()

statement interchange_two_loops	(	list	,
		int	,
		int
	)

internalize_parallel_code()

bool internalize_parallel_code

(

const

string

)

internalize_parallel_code.c

Parameters

string

od_name

limit_nested_parallelism()

bool limit_nested_parallelism

(

const

string

)

manage_parallel_loops.c

Parameters

string

odule_name

limit_parallelism_using_complexity()

bool limit_parallelism_using_complexity

(

const

string

)

Parameters

string

odule_name

linearize_loop_range()

bool linearize_loop_range

(

const char *

)

localize_declaration()

bool localize_declaration

(

const

string

)

Parameters

string

od_name

loop_bound_minimization_with_out_regions()

bool loop_bound_minimization_with_out_regions

(

const char *

)

loop_bound_minimization_with_out_regions_on_statement()

bool loop_bound_minimization_with_out_regions_on_statement

(

statement

)

loop_bound_minimization.c

loop_fully_unrollable_p()

bool loop_fully_unrollable_p

(

loop

l

)

Definition at line 753 of file loop_unroll.c.

{
  bool unroll_p = false;
  range lr = loop_range(l);
  expression lb = range_lower(lr);
  expression ub = range_upper(lr);
  expression inc = range_increment(lr);
  intptr_t lbval, ubval, incval;
 
  pips_debug(2, "begin\n");
 
  unroll_p = expression_integer_value(lb, &lbval)
    && expression_integer_value(ub, &ubval)
    && expression_integer_value(inc, &incval);
 
  if(unroll_p) {
    const char* s = get_string_property("FULL_LOOP_UNROLL_EXCEPTIONS");
    if(*s!=0) {
      list callees = statement_to_called_user_entities(loop_body(l));
      list exceptions = string_to_user_modules(s);
      list p = arguments_intersection(callees, exceptions);
      unroll_p = ENDP(p);
      gen_free_list(p);
    }
  }
 
  return unroll_p;
}

References arguments_intersection(), ENDP, expression_integer_value(), gen_free_list(), get_string_property(), intptr_t, loop_body, loop_range, pips_debug, range_increment, range_lower, range_upper, statement_to_called_user_entities(), and string_to_user_modules().

Referenced by unroll_loops_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_fusion()

bool loop_fusion

(

char *

)

loop_fusion.c

loop_fusion_with_regions()

bool loop_fusion_with_regions

(

char *

)

loop_interchange()

bool loop_interchange

(

const

string

)

Parameters

string

odule_name

loop_normalize()

bool loop_normalize

(

const

string

)

Parameters

string

od_name

loop_normalize_statement()

void loop_normalize_statement

(

statement

)

loop_normalize.c

Referenced by simd_loop_unroll().

Here is the caller graph for this function:

loop_pragma()

char* loop_pragma	(	const char *	module_name,
		const char *	parent_loop
	)

Parameters

module_name	odule_name
parent_loop	arent_loop

Definition at line 225 of file interactive_loop_transformation.c.

{
  // ensure pipsmake is ok with what we ask for
  safe_make(DBR_LOOPS,module_name);
 
  // prelude
  set_current_module_entity(module_name_to_entity( module_name ));
  set_current_module_statement
    ((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
 
  entity label = find_label_entity(module_name,parent_loop);
  if(entity_undefined_p(label))
  pips_user_error("label '%s' does not exist\n",parent_loop);
  statement stmt = find_loop_from_label(get_current_module_statement(),label);
  if(statement_undefined_p(stmt))
  pips_user_error("label '%s' is not on a loop\n",parent_loop);
  string s = extensions_to_string(statement_extensions(stmt),false);
  if(string_undefined_p(s)) s = strdup("");
  reset_current_module_entity();
  reset_current_module_statement();
  return s;
}

References db_get_memory_resource(), entity_undefined_p, extensions_to_string(), find_label_entity(), find_loop_from_label(), get_current_module_statement(), module_name(), module_name_to_entity(), pips_user_error, reset_current_module_entity(), reset_current_module_statement(), safe_make(), set_current_module_entity(), set_current_module_statement(), statement_extensions, statement_undefined_p, strdup(), and string_undefined_p.

Here is the call graph for this function:

loop_strip_mine()

statement loop_strip_mine	(	statement	loop_statement,
		int	chunk_size,
		int	chunk_number
	)

strip_mine.c

strip_mine.c

Sharing is (theoretically) avoided when the AST is built

Assumption:

• a loop body can be a loop (no need for a block with one statement, a loop)

compute the expression for the chunk size

make sure that the outer loop does not use a continue that will end up in the inner loop body

derive a new loop index (FI: only one name :-(

build the inner loop preserving the initial index set

update the outer loop

Parameters

loop_statement	oop_statement
chunk_size	hunk_size
chunk_number	hunk_number

Definition at line 64 of file strip_mine.c.

{
    loop l = instruction_loop(statement_instruction(loop_statement));
    loop new_l = loop_undefined;
    statement new_s = statement_undefined;
    expression size = expression_undefined;
    expression sizem1 = expression_undefined;
    expression lb = range_lower(loop_range(l));
    expression ub = range_upper(loop_range(l));
    entity index = loop_index(l);
    statement b = loop_body(l);
    entity new_index = entity_undefined;
 
    debug(9, "loop_strip_mine", "begin: chunk_size = %d,chunk_number = %d\n",
          chunk_size, chunk_number);
    pips_assert("loop_strip_mine", ( chunk_size > 1 && chunk_number == -1 )
                ||
                (chunk_size == -1 && chunk_number > 1) );
 
    if(loop_increment_value(l) != 1)
        user_error("loop_strip_mine",
                   "Loop increment has to be one for strip-mining!\n");
 
    if(get_debug_level()>=9) {
      print_statement(loop_statement);
      pips_assert("loop_strip_mine", statement_consistent_p(loop_statement));
    }
 
    /* compute the expression for the chunk size */
    if(chunk_size==-1) {
        expression e_number = int_to_expression(chunk_number);
 
        size = make_op_exp(MINUS_OPERATOR_NAME, copy_expression(ub), copy_expression(lb));
        size = make_op_exp(PLUS_OPERATOR_NAME, size, copy_expression(e_number));
        size = make_op_exp(DIVIDE_OPERATOR_NAME, size, e_number);
        sizem1 = make_op_exp(MINUS_OPERATOR_NAME, copy_expression(size), int_to_expression(1));
    }
    else {
        size = int_to_expression(chunk_size);
        sizem1 = int_to_expression(chunk_size-1);
    }
    ifdebug(9) {
      pips_debug(8, "size = ");
      print_expression(size);
      pips_debug(8, "sizem1 = ");
      print_expression(sizem1);
    }
    
    /* make sure that the outer loop does not use a continue that will
    end up in the inner loop body */
    loop_label(l)=entity_empty_label();
 
    /* derive a new loop index (FI: only *one* name :-( */
    new_index = make_new_index_entity(index, "_1");
    AddEntityToDeclarations(new_index, get_current_module_entity());
 
    /* build the inner loop preserving the initial index set */
    expression fst_min_param=MakeBinaryCall(entity_intrinsic("+"),entity_to_expression(new_index),sizem1);
    expression snd_min_parameter=copy_expression(ub);
    expression min_exp = 
        MakeBinaryCall(entity_intrinsic(MIN_OPERATOR_NAME),fst_min_param,snd_min_parameter);
    new_l = make_loop(index,
                      make_range(entity_to_expression(new_index),
                  min_exp,
                                 int_to_expression(1)),
                      b,
                      entity_empty_label(),
                      execution_sequential_p(loop_execution(l)) ?
                      make_execution(is_execution_sequential, UU):
                      make_execution(is_execution_parallel, UU),
                      NIL);
 
    new_s = instruction_to_statement(make_instruction(is_instruction_loop, new_l));
 
    ifdebug(8) {
      pips_debug(8, "new inner loop:");
      print_statement(new_s);
      pips_assert("loop_strip_mine", statement_consistent_p(new_s));
    }
 
    /* update the outer loop */
    loop_index(l) = new_index;
    range_increment(loop_range(l)) = copy_expression(size);
    loop_body(l) = new_s;
 
    ifdebug(8) {
      print_statement(loop_statement);
      pips_assert("loop_statement consistent_p", statement_consistent_p(loop_statement));
    }
 
    pips_debug(8, "end\n");
    return(loop_statement);
}

References AddEntityToDeclarations(), copy_expression(), debug(), DIVIDE_OPERATOR_NAME, entity_empty_label(), entity_intrinsic(), entity_to_expression(), entity_undefined, execution_sequential_p, expression_undefined, get_current_module_entity(), get_debug_level(), ifdebug, instruction_loop, instruction_to_statement(), int_to_expression(), is_execution_parallel, is_execution_sequential, is_instruction_loop, loop_body, loop_execution, loop_increment_value(), loop_index, loop_label, loop_range, loop_undefined, make_execution(), make_instruction(), make_loop(), make_new_index_entity(), make_op_exp(), make_range(), MakeBinaryCall(), MIN_OPERATOR_NAME, MINUS_OPERATOR_NAME, NIL, pips_assert, pips_debug, PLUS_OPERATOR_NAME, print_expression(), print_statement(), range_increment, range_lower, range_upper, statement_consistent_p(), statement_instruction, statement_undefined, user_error, and UU.

Referenced by do_kernelize(), and loop_chunk_size_and_strip_mine().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_unroll()

void loop_unroll	(	statement	loop_statement,
		int	rate
	)

fallbacks on do_loop_unroll without statement post processing

Parameters

loop_statement	oop_statement
rate	ate

Definition at line 748 of file loop_unroll.c.

{
    do_loop_unroll(loop_statement, rate, NULL);
}

References do_loop_unroll().

Referenced by unroll().

Here is the call graph for this function:

Here is the caller graph for this function:

module_clean_declarations()

void module_clean_declarations	(	entity	module,
		statement	module_statement
	)

declarations.c

Parameters

module	odule
module_statement	odule_statement

Definition at line 140 of file declarations.c.

                                                                          {
  entity_clean_declarations(module,module_statement);
 
  gen_recurse(module_statement,statement_domain, gen_true, statement_clean_declarations);
}

References entity_clean_declarations(), gen_recurse, gen_true(), module, module_statement, statement_clean_declarations(), and statement_domain.

Referenced by clean_declarations(), and do_scalar_renaming().

Here is the call graph for this function:

Here is the caller graph for this function:

module_loops()

char* module_loops	(	const char *	module_name,
		const char *	parent_loop
	)

gather the list of enclosing loops expect flag_loops has been called before

Parameters

module_name	module we want the loops of
parent_loop	null if we wat to gather outer loops, a loop_label if we want to gather enclosed loops

Returns

list of strings, one string per loop label

this function is needed by pyps?

Parameters

module_name	odule_name
parent_loop	arent_loop

Definition at line 259 of file interactive_loop_transformation.c.

{
  // ensure pipsmake is ok with what we ask for
  safe_make(DBR_LOOPS,module_name);
 
  // prelude
  set_current_module_entity(module_name_to_entity( module_name ));
  set_current_module_statement
    ((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
  list loops = NIL;
 
  statement seed = statement_undefined;
  if(empty_string_p(parent_loop))
    seed=get_current_module_statement();
  else {
    entity label = find_label_entity(module_name,parent_loop);
    if(entity_undefined_p(label))
        pips_user_error("label '%s' does not exist\n",parent_loop);
    statement stmt = find_loop_from_label(get_current_module_statement(),label);
    if(statement_undefined_p(stmt))
        pips_user_error("label '%s' is not on a loop\n",parent_loop);
    seed=loop_body(statement_loop(stmt));
  }
 
  // run loop gatherer
  gen_context_recurse(seed, &loops,
                      statement_domain, module_loops_walker, gen_null2);
  loops=gen_nreverse(loops);
 
  // postlude
  reset_current_module_entity();
  reset_current_module_statement();
  string out = list_to_string(loops);
  gen_free_list(loops);
  if(out) out[strlen(out)-1]=0;
  return out;
}

References db_get_memory_resource(), empty_string_p(), entity_undefined_p, find_label_entity(), find_loop_from_label(), gen_context_recurse, gen_free_list(), gen_nreverse(), gen_null2(), get_current_module_statement(), list_to_string(), loop_body, loops, module_loops_walker(), module_name(), module_name_to_entity(), NIL, out, pips_user_error, reset_current_module_entity(), reset_current_module_statement(), safe_make(), set_current_module_entity(), set_current_module_statement(), statement_domain, statement_loop(), statement_undefined, and statement_undefined_p.

Here is the call graph for this function:

nest_parallelization()

bool nest_parallelization

(

const char *

)

nest_parallelization.c

partial_redundancy_elimination()

bool partial_redundancy_elimination

(

const

string

)

partial_redundancy_elimination.c

Parameters

string

odule_name

print_c_code()

bool print_c_code

(

const char *

module_name

)

C indentation thru indent.

Parameters

module_name

odule_name

Definition at line 2262 of file cprettyprinter.c.

{
    string crough, cpretty, dir, cmd;
 
    crough = db_get_memory_resource(DBR_CROUGH, module_name, true);
    cpretty = db_build_file_resource_name(DBR_C_PRINTED_FILE, module_name, CPRETTY);
    dir = db_get_current_workspace_directory();
 
    cmd = strdup(concatenate(INDENT, " ",
                dir, "/", crough, " -st > ",
                dir, "/", cpretty, NULL));
 
    safe_system(cmd);
 
    DB_PUT_FILE_RESOURCE(DBR_C_PRINTED_FILE, module_name, cpretty);
    free(cmd);
    free(dir);
 
    return true;
}

References concatenate(), CPRETTY, db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, free(), INDENT, module_name(), safe_system(), and strdup().

Here is the call graph for this function:

print_code_privatized_regions()

bool print_code_privatized_regions

(

const

string

)

Parameters

string

odule_name

print_crough()

bool print_crough

(

const char *

module_name

)

save to file

Parameters

module_name

odule_name

Definition at line 2194 of file cprettyprinter.c.

{
    FILE * out;
    string ppt, crough, dir, filename;
    entity module;
    statement stat;
    list l_effect = NULL;
 
    // get what is needed from PIPS DBM
    crough = db_build_file_resource_name(DBR_CROUGH, module_name, CROUGH);
    module = module_name_to_entity(module_name);
    dir = db_get_current_workspace_directory();
    filename = strdup(concatenate(dir, "/", crough, NULL));
    stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
    l_effect = effects_to_list((effects)
                               db_get_memory_resource(DBR_SUMMARY_EFFECTS,
                                                      module_name, true));
    set_current_module_entity(module);
    set_current_module_statement(stat);
 
    debug_on("CPRETTYPRINTER_DEBUG_LEVEL");
    pips_debug(1, "Begin C prettyprrinter for %s\n", entity_name(module));
 
    // init the list needed for the function pre and postlude
    l_type    = NIL;
    l_name    = NIL;
    l_rename  = NIL;
    l_entity  = NIL;
    l_written = NIL;
    // build the list of written entity
    build_written_list (l_effect);
 
    // get the c code as a string
    ppt = c_code_string(module, stat);
    pips_debug(1, "end\n");
    debug_off();
 
    /* save to file */
    out = safe_fopen(filename, "w");
    fprintf(out, "/* C pretty print for module %s. */\n", module_name);
    fprintf(out, "%s", ppt);
    safe_fclose(out, filename);
 
    // free and reset strin lists
    gen_free_list (l_entity);
    gen_free_list (l_written);
    gen_free_string_list (l_type);
    gen_free_string_list (l_name);
    gen_free_string_list (l_rename);
    l_type    = NIL;
    l_name    = NIL;
    l_rename  = NIL;
    l_entity  = NIL;
    l_written = NIL;
    free(ppt);
    free(dir);
    free(filename);
 
    DB_PUT_FILE_RESOURCE(DBR_CROUGH, module_name, crough);
 
    reset_current_module_statement();
    reset_current_module_entity();
 
    return true;
}

References build_written_list(), c_code_string(), concatenate(), CROUGH, db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, effects_to_list(), entity_name, fprintf(), free(), gen_free_list(), gen_free_string_list(), l_entity, l_name, l_rename, l_type, l_written, module, module_name(), module_name_to_entity(), NIL, out, pips_debug, reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), and strdup().

Here is the call graph for this function:

print_interface()

bool print_interface

(

const char *

module_name

)

cprettyprinter.c

save to file

Parameters

module_name

odule_name

Definition at line 2151 of file cprettyprinter.c.

{
  FILE * out;
  string interface_code, interface, dir, filename;
  entity module;
  statement stat;
 
  // get what is needed from PIPS DBM
  interface = db_build_file_resource_name(DBR_INTERFACE, module_name, INTERFACE);
  module = module_name_to_entity(module_name);
  dir = db_get_current_workspace_directory();
  filename = strdup(concatenate(dir, "/", interface, NULL));
  stat = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  set_current_module_entity(module);
  set_current_module_statement(stat);
 
  debug_on("INTERFACE_DEBUG_LEVEL");
  pips_debug(1, "Begin print_interface for %s\n", entity_name(module));
 
  // get the inteface code as a string
  interface_code = interface_code_string(module, stat);
  pips_debug(1, "end\n");
  debug_off();
 
  /* save to file */
  out = safe_fopen(filename, "w");
  fprintf(out, "! Fortran interface module for %s. \n", module_name);
  fprintf(out, "%s", interface_code);
  safe_fclose(out, filename);
 
  DB_PUT_FILE_RESOURCE(DBR_INTERFACE, module_name, INTERFACE);
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  free (interface_code);
  free (dir);
  free (filename);
 
  return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, entity_name, fprintf(), free(), INTERFACE, interface_code_string(), module, module_name(), module_name_to_entity(), out, pips_debug, reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), and strdup().

Here is the call graph for this function:

print_loops()

bool print_loops

(

const

string

)

prelude

do the job

ostlude

Parameters

string

odule_name

Definition at line 152 of file interactive_loop_transformation.c.

{
  /* prelude */
  set_current_module_entity(module_name_to_entity( module_name ));
  set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
  callees loops = (callees)db_get_memory_resource(DBR_LOOPS, module_name, true);
 
  /* do the job */
  {
    string local = db_build_file_resource_name(DBR_LOOPS_FILE, module_name, ".loops");
    string dir = db_get_current_workspace_directory();
    string full = strdup(concatenate(dir,"/",local, NULL));
    free(dir);
    FILE * fp = safe_fopen(full,"w");
    text r = make_text(NIL);
    FOREACH(STRING,s,callees_callees(loops))
      {
        ADD_SENTENCE_TO_TEXT(r,MAKE_ONE_WORD_SENTENCE(0,s));
      }
    print_text(fp,r);
    free_text(r);
    safe_fclose(fp,full);
    free(full);
    DB_PUT_FILE_RESOURCE(DBR_LOOPS_FILE, module_name, local);
  }
 
  /*postlude*/
  reset_current_module_entity();
  reset_current_module_statement();
  return true;
}

References ADD_SENTENCE_TO_TEXT, callees_callees, concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, FOREACH, free(), free_text(), full, loops, MAKE_ONE_WORD_SENTENCE, make_text(), module_name(), module_name_to_entity(), NIL, print_text(), reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), strdup(), and STRING.

Here is the call graph for this function:

print_parallelizedcray_code()

bool print_parallelizedcray_code

(

char *

)

prettyprintcray.c

privatize_module()

bool privatize_module

(

const

string

)

privatize.c

Parameters

string

od_name

privatize_module_even_globals()

bool privatize_module_even_globals

(

const

string

)

Parameters

string

od_name

quick_scalarization()

bool quick_scalarization

(

const

string

)

Parameters

string

odule_name

recover_for_loop()

bool recover_for_loop

(

const

string

)

for_loop_recovering.c

Parameters

string

odule_name

reduction_variable_expansion()

bool reduction_variable_expansion

(

const char *

)

remove_useless_label()

bool remove_useless_label

(

const

string

)

Parameters

string

odule_name

Referenced by do_unfolding().

Here is the caller graph for this function:

scalarization()

bool scalarization

(

const

string

)

scalarization.c

Parameters

string

odule_name

selected_loop_p()

bool selected_loop_p

(

statement

s

)

SG+EC 2010: The loop_label(statement_loop(s)) is kept for compatibility reasons but is invalid and should eventually be removed

Definition at line 63 of file interactive_loop_transformation.c.

{
  /* SG+EC 2010:
     The loop_label(statement_loop(s)) is kept for compatibility reasons
     but is invalid and should eventually be removed */
  return statement_loop_p(s) &&
          (statement_label(s) == selected_label ||
           loop_label(statement_loop(s)) == selected_label);
}

References loop_label, selected_label, statement_label, statement_loop(), and statement_loop_p().

Referenced by interactive_loop_transformation(), and strip_mine().

Here is the call graph for this function:

Here is the caller graph for this function:

set_return_type_as_typedef()

bool set_return_type_as_typedef

(

const

string

)

set_return_type.c

Parameters

string

od_name

simplify_control()

bool simplify_control

(

const

string

)

simplify_control.c

Parameters

string

od_name

simplify_control_directly()

bool simplify_control_directly

(

const

string

)

Parameters

string

od_name

split_initializations()

bool split_initializations

(

const char *

module_name

)

Pipsmake 'split_initializations' phase.

Save modified code to database

Parameters

module_name

odule_name

Definition at line 742 of file flatten_code.c.

{
  statement module_stat;
  bool good_result_p = true;
 
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement( (statement)
                                db_get_memory_resource(DBR_CODE, module_name, true) );
  module_stat = get_current_module_statement();
 
  debug_on("SPLIT_INITIALIZATIONS_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  // Do split !
  statement_split_initializations(module_stat);
 
  pips_debug(1, "end\n");
  debug_off();
 
  /* Save modified code to database */
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_stat);
 
  reset_current_module_entity();
  reset_current_module_statement();
 
  return (good_result_p);
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_split_initializations(), and strdup().

Here is the call graph for this function:

split_update_call()

void split_update_call

(

call

c

)

Definition at line 772 of file flatten_code.c.

{
    entity op = call_function(c);
    list args = call_arguments(c);
    entity new_op = update_operator_to_regular_operator(op);
    if(!entity_undefined_p(new_op))
    {
        if(ENTITY_PLUS_C_P(new_op)||ENTITY_MINUS_C_P(new_op))
        {
            bool has_pointer =false;
            FOREACH(EXPRESSION,exp,call_arguments(c))
            {
                basic b = basic_of_expression(exp);
                if(basic_pointer_p(b)) { has_pointer=true;}
                free_basic(b);
            }
            if(!has_pointer) {
                if(ENTITY_PLUS_C_P(new_op))new_op=entity_intrinsic(PLUS_OPERATOR_NAME);
                else new_op=entity_intrinsic(MINUS_OPERATOR_NAME);
            }
        }
        ifdebug(1){
            expression tmp = call_to_expression(c);
            pips_debug(1,"changed expression \n");
            print_expression(tmp);
            syntax_call(expression_syntax(tmp))=call_undefined;
            free_expression(tmp);
        }
 
        call_function(c)=entity_intrinsic(ASSIGN_OPERATOR_NAME);
        expression lhs = binary_call_lhs(c);
        expression rhs = binary_call_rhs(c);
        CAR(CDR(args)).p=(gen_chunkp)MakeBinaryCall(
                new_op,
                copy_expression(lhs),
                rhs);
 
        ifdebug(1){
            expression tmp = call_to_expression(c);
            pips_debug(1,"into expression \n");
            print_expression(tmp);
            syntax_call(expression_syntax(tmp))=call_undefined;
            free_expression(tmp);
        }
    }
}

References ASSIGN_OPERATOR_NAME, basic_of_expression(), basic_pointer_p, binary_call_lhs, binary_call_rhs, call_arguments, call_function, call_to_expression(), call_undefined, CAR, CDR, copy_expression(), entity_intrinsic(), ENTITY_MINUS_C_P, ENTITY_PLUS_C_P, entity_undefined_p, exp, EXPRESSION, expression_syntax, FOREACH, free_basic(), free_expression(), ifdebug, MakeBinaryCall(), MINUS_OPERATOR_NAME, pips_debug, PLUS_OPERATOR_NAME, print_expression(), syntax_call, and update_operator_to_regular_operator().

Referenced by check_if_conv_call(), simd_supported_stat_p(), split_update_operator(), and split_update_operator_statement_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

split_update_operator()

bool split_update_operator

(

const char *

module_name

)

Save modified code to database

Parameters

module_name

odule_name

Definition at line 834 of file flatten_code.c.

{
  set_current_module_entity(module_name_to_entity(module_name));
  set_current_module_statement( (statement)     db_get_memory_resource(DBR_CODE, module_name, true) );
  debug_on("SPLIT_UPDATE_OPERATOR_DEBUG_LEVEL");
  pips_debug(1, "begin\n");
 
  gen_multi_recurse(get_current_module_statement(),
          call_domain,gen_true,split_update_call,
          statement_domain,gen_true,split_update_operator_statement_walker,
          NULL);
 
  pips_debug(1, "end\n");
  debug_off();
 
  /* Save modified code to database */
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
  reset_current_module_entity();
  reset_current_module_statement();
  return true;
}

References call_domain, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_multi_recurse(), gen_true(), get_current_module_statement(), module_name(), module_name_to_entity(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), split_update_call(), split_update_operator_statement_walker(), and statement_domain.

Here is the call graph for this function:

statement_clean_declarations()

void statement_clean_declarations

(

statement

s

)

cproto-generated files

util.c

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_flatten_declarations()

bool statement_flatten_declarations	(	entity	module,
		statement	s
	)

flatten_code.c

For the time being, we handle only blocks with declarations

Can we find out what the local scope of statement s is?

FI: Shouldn't it be "0`"?

current scope for se

Parameters

module

odule

Definition at line 509 of file flatten_code.c.

{
  /* For the time being, we handle only blocks with declarations */
  if (statement_block_p(s)) {
    list declarations = instruction_to_declarations(statement_instruction(s));
    // Recursive
    hash_table renamings = hash_table_make(hash_pointer, HASH_DEFAULT_SIZE);
    bool renaming_p = false;
    string cs = string_undefined;
    int csl = INT_MAX;
 
    /* Can we find out what the local scope of statement s is? */
    /* FI: Shouldn't it be "0`"? */
    const char* cmn = entity_user_name(module);
    FOREACH(ENTITY, se, entity_declarations(module)) {
      string sen  = entity_name(se);
      const char* seln = entity_local_name(se);
      string cs_se   = local_name_to_scope(seln); /* current scope for se */
      const char* mn   = module_name(sen);
 
      if(same_string_p(mn, cmn)) {
              renaming_p = true;
              int cs_se_l = strlen(cs_se);
              if(cs_se_l>0 && cs_se_l<csl) {
          csl = cs_se_l;
          cs = cs_se;
              }
              else {
          free(cs_se);
              }
      }
            else {
              free(cs_se);
            }
    }
    if (renaming_p) {
      compute_renamings(s, cs, cmn, renamings);
      // FC: 2014-12-20 kludge to avoid a coredump
      if (cs != string_undefined) {
        free(cs);
        cs = string_undefined;
      }
    }
 
    if(renaming_p) {
      ifdebug(1)
        hash_table_fprintf(stderr,
                           // The warning will disappear when Fabien
                           // updates Newgen
                           //(char * (*)(void *)) entity_local_name,
                           //(char * (*)(void *)) entity_local_name,
                           (gen_string_func_t) entity_local_name,
                           (gen_string_func_t) entity_local_name,
                           renamings);
 
      //char *(*key_to_string)(void*),
      //char *(*value_to_string)(void*),
 
      gen_context_multi_recurse(
        statement_instruction(s), renamings,
        reference_domain, gen_true, rename_reference,
        loop_domain, gen_true, rename_loop_index,
        statement_domain, gen_true, rename_statement_declarations,
        NULL);
 
      // This look like a bad hack, partially redundant with previous
      // replacement but... only partially ! For instance extensions was not
      // handled previously.
      // Probably that there's need for factoring, but it'll be another time !
      replace_entities(s,renamings);
 
      gen_free_list(declarations), declarations = NIL;
      hash_table_free(renamings), renamings = NULL;
    }
    else {
      pips_debug(2,"Code flattening fails because the statement does"
                 " not contain any local declaration\n");
    }
  }
  return true;
}

References compute_renamings(), ENTITY, entity_declarations, entity_local_name(), entity_name, entity_user_name(), FOREACH, free(), gen_context_multi_recurse(), gen_free_list(), gen_true(), HASH_DEFAULT_SIZE, hash_pointer, hash_table_fprintf(), hash_table_free(), hash_table_make(), ifdebug, instruction_to_declarations(), local_name_to_scope(), loop_domain, module, module_name(), NIL, pips_debug, reference_domain, rename_loop_index(), rename_reference(), rename_statement_declarations(), replace_entities(), same_string_p, statement_block_p, statement_domain, statement_instruction, and string_undefined.

Referenced by delay_communications(), delay_load_communications(), delay_store_communications(), and flatten_code().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_split_initializations()

void statement_split_initializations

(

statement

s

)

Recurse through the statements of s and split local declarations.

For the time being, we handle only blocks with declarations.

NOTE: Statement s is modified in-place.

This function can be called from another module to apply transformation directly.

Is it still useful?

Definition at line 733 of file flatten_code.c.

{
    gen_recurse(s, statement_domain, gen_true, split_initializations_in_statement);
    /* Is it still useful? */
    clean_up_sequences(s);
}

References clean_up_sequences(), gen_recurse, gen_true(), split_initializations_in_statement(), and statement_domain.

Referenced by process_true_stat(), promote_local_entities(), and split_initializations().

Here is the call graph for this function:

Here is the caller graph for this function:

stf()

bool stf

(

const

string

)

standardize_structure.c

Parameters

string

od_name

Referenced by block_to_transformer(), block_to_transformer_list(), declarations_to_transformer(), declarations_to_transformer_list(), EnterScope(), propagate_preconditions_in_declarations(), and statement_to_transformer().

Here is the caller graph for this function:

strength_reduction()

bool strength_reduction

(

const

string

)

strength_reduction.c

Parameters

string

odule_name

strip_mine()

bool strip_mine

(

const

string

)

Top-level function.

Get the loop label form the user

DBR_CODE will be changed: argument "pure" should take false but this would be useless since there is only one version of code; a new version will be put back in the data base after strip_mineing

Reorder the module, because new statements have been generated.

Parameters

string

od_name

Definition at line 233 of file strip_mine.c.

{
    entity module = module_name_to_entity(mod_name);
    statement mod_stmt;
    const char *lp_label=NULL;
    bool return_status;
 
    debug_on("STRIP_MINE_DEBUG_LEVEL");
 
    /* Get the loop label form the user */
    lp_label=get_string_property_or_ask("LOOP_LABEL","Which loop do you want to strip_mine?\n" "(give its label): ");
    if (lp_label[0] == '\0') {
        user_log("Strip mining has been cancelled.\n");
        return_status = false;
    }
    else {
        selected_label = find_label_entity(mod_name, lp_label);
        if (entity_undefined_p(selected_label)) {
            user_error("strip_mine", "loop label `%s' does not exist\n", lp_label);
        }
 
        set_current_module_entity(module);
 
        /* DBR_CODE will be changed: argument "pure" should take false but
           this would be useless since there is only *one* version of code;
           a new version will be put back in the data base after
           strip_mineing */
        mod_stmt = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
        set_current_module_statement(mod_stmt);
 
        look_for_nested_loop_statements(mod_stmt, loop_chunk_size_and_strip_mine, selected_loop_p);
 
        /* Reorder the module, because new statements have been generated. */
        module_reorder(mod_stmt);
 
        reset_current_module_entity();
        reset_current_module_statement();
 
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
        return_status = true;
    }
 
    debug(2,"strip_mine","done for %s\n", mod_name);
    debug_off();
 
    return return_status;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug(), debug_off, debug_on, entity_undefined_p, find_label_entity(), get_string_property_or_ask(), look_for_nested_loop_statements(), loop_chunk_size_and_strip_mine(), module, module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), selected_label, selected_loop_p(), set_current_module_entity(), set_current_module_statement(), user_error, and user_log().

Here is the call graph for this function:

suppress_dead_code()

bool suppress_dead_code

(

const

string

)

Parameters

string

od_name

suppress_trivial_test()

bool suppress_trivial_test

(

const

string

)

trivial_test_elimination.c

Parameters

string

od_name

transformation_test()

bool transformation_test

(

const

string

)

transformation_test.c

Parameters

string

od_name

unroll()

bool unroll

(

const

string

)

Top-level functions.

Get the loop label form the user

Get the unrolling factor from the user

User asked to cancel:

Sets the current module to "mod_name".

current_module(module_name_to_entity(mod_name));

DBR_CODE will be changed: argument "pure" should take false but this would be useless since there is only one version of code; a new version will be put back in the data base after unrolling

prelude

Validity of transformation should be checked

ie.: - no side effects in replicated expressions

No dependent types in C

do the job

Reorder the module, because new statements have been generated.

ostlude

Parameters

string

od_name

Definition at line 960 of file loop_unroll.c.

{
    statement mod_stmt;
    const char *lp_label = NULL;
    entity lb_ent;
    int rate;
    bool return_status =true;
 
    debug_on("UNROLL_DEBUG_LEVEL");
 
    /* Get the loop label form the user */
    lp_label=get_string_property_or_ask("LOOP_LABEL","Which loop do you want to unroll?\n(give its label):");
    if( empty_string_p(lp_label) )
        return_status = false;
    else {
        lb_ent = find_label_entity(mod_name, lp_label);
        if (entity_undefined_p(lb_ent))
            user_error("unroll", "loop label `%s' does not exist\n", lp_label);
 
        /* Get the unrolling factor from the user */
        rate = get_int_property("UNROLL_RATE");
        if( rate <= 1 ) {
            string resp = user_request("How many times do you want to unroll?\n(choose integer greater or egal to 2): ");
 
            if (empty_string_p(resp))
                /* User asked to cancel: */
                return_status = false;
            else {
                if(sscanf(resp, "%d", &rate)!=1 || rate <= 1)
                    user_error("unroll", "unroll factor should be greater than 2\n");
            }
        }
        if( return_status ) {
 
            pips_debug(1,"Unroll %d times loop %s in module %s\n",
                       rate, lp_label, mod_name);
 
            /* Sets the current module to "mod_name". */
            /* current_module(module_name_to_entity(mod_name)); */
 
            /* DBR_CODE will be changed: argument "pure" should take false 
               but this would be useless
               since there is only *one* version of code; a new version 
               will be put back in the
               data base after unrolling */
 
            mod_stmt = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
 
            /* prelude */
            set_current_module_entity(module_name_to_entity( mod_name ));
            set_current_module_statement( mod_stmt);
 
            statement loop_statement = find_loop_from_label(mod_stmt,lb_ent);
            if( ! statement_undefined_p(loop_statement) ) {
              instruction i = statement_instruction(loop_statement);
              loop l = instruction_loop(i);
              /* Validity of transformation should be checked */
              /* ie.: - no side effects in replicated expressions */
              /* No dependent types in C */
              list vl = statement_declarations(loop_body(l));
              bool dependent_p = false;
              FOREACH(ENTITY, v, vl) {
                type t = entity_type(v);
                if(dependent_type_p(t)) {
                  dependent_p = true;
                  break;
                }
              }
 
              if(dependent_p) {
                pips_user_warning("Loop cannot be unrolled because it contains a dependent type.\n");
                return_status = false;
              }
              else {
                /* do the job */
                loop_unroll(loop_statement,rate);
              }
            }
            else
                pips_user_error("label '%s' is not linked to a loop\n", lp_label);
 
            if(return_status) {
              /* Reorder the module, because new statements have been generated. */
              module_reorder(mod_stmt);
 
              DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
            }
            /*postlude*/
            reset_current_module_entity();
            reset_current_module_statement();
            return_status = true;
        }
    }
 
    pips_debug(2, "done for %s\n", mod_name);
    debug_off();
 
    if ( ! return_status )
        user_log("Loop unrolling has been cancelled.\n");
 
    return return_status;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dependent_type_p(), empty_string_p(), ENTITY, entity_type, entity_undefined_p, find_label_entity(), find_loop_from_label(), FOREACH, get_int_property(), get_string_property_or_ask(), instruction_loop, loop_body, loop_unroll(), module_name_to_entity(), module_reorder(), pips_debug, pips_user_error, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_declarations, statement_instruction, statement_undefined_p, user_error, user_log(), and user_request().

Here is the call graph for this function:

use_def_elimination()

bool use_def_elimination

(

char *

)

variable_expansion()

bool variable_expansion

(

const char *

)

variable_expansion.c

Variable Documentation

selected_label

entity selected_label

extern

interactive_loop_transformation.c

interactive_loop_transformation.c

Definition at line 61 of file interactive_loop_transformation.c.

Referenced by interactive_loop_transformation(), and selected_loop_p().