regions_to_loops.h File Reference

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

Go to the source code of this file.

Functions
statement	make_write_loopbody (entity, expression, list)
	Warning! Do not modify this file that is automatically generated! More...
statement	make_read_loopbody (entity, entity, list)
	Makes the body of a "read" loop. More...
statement	region_to_loop_nest (effect, bool, entity, expression)
expression	make_addition (expression, expression)
	Makes an addition expression from two expressions. More...
void	replace_indices_region (effect, list *, int, entity)
statement	make_sequence_from_statement_list (list)
	Make a sequence from a statement list The equivalent of this function was already made somewhere else. More...
bool	regions_to_loops (char *)
	This phase replaces the body of a function by automatically generated loops where the read and write statements are representative of the original function. More...

Function Documentation

make_addition()

expression make_addition	(	expression	e1,
		expression	e2
	)

Makes an addition expression from two expressions.

Parameters

e1	1
e2	2

Definition at line 175 of file regions_to_loops.c.

                                                       {
  entity add_ent = gen_find_entity("TOP-LEVEL:+");
  return make_call_expression(add_ent, CONS(EXPRESSION, e1, CONS(EXPRESSION, e2, NIL)));
}

References CONS, EXPRESSION, gen_find_entity(), make_call_expression(), and NIL.

Referenced by regions_to_loops().

Here is the call graph for this function:

Here is the caller graph for this function:

make_read_loopbody()

statement make_read_loopbody	(	entity	v,
		entity	readVar,
		list	vl
	)

Makes the body of a "read" loop.

An assign statement is made using the variables generated and the array.

Parameters

readVar	eadVar
vl	l

Definition at line 106 of file regions_to_loops.c.

                                                                 {
  expression e = reference_to_expression(make_reference(v, gen_full_copy_list(vl)));
  expression e2 = entity_to_expression(readVar);
  statement s = make_assign_statement(e2, e);
  pips_assert("read body is not properly generated", statement_consistent_p(s));
  return s;
}

References entity_to_expression(), gen_full_copy_list(), make_assign_statement(), make_reference(), pips_assert, reference_to_expression(), and statement_consistent_p().

Referenced by Psysteme_to_loop_nest().

Here is the call graph for this function:

Here is the caller graph for this function:

make_sequence_from_statement_list()

statement make_sequence_from_statement_list

(

list

l

)

Make a sequence from a statement list The equivalent of this function was already made somewhere else.

However when the list only has one element it returns that element instead of making a sequence of one element containing that element. This function always makes a sequence

Definition at line 243 of file regions_to_loops.c.

                                                    {
  if (l == NIL) {
    return statement_undefined;
  }
  else {
    if (gen_length(l) == 1) {
      return make_block_with_stmt_if_not_already(STATEMENT(CAR(l)));
    }
    else {
      return make_block_statement(l);
    }
  }
}

References CAR, gen_length(), make_block_statement(), make_block_with_stmt_if_not_already(), NIL, STATEMENT, and statement_undefined.

Referenced by regions_to_loops().

Here is the call graph for this function:

Here is the caller graph for this function:

make_write_loopbody()

statement make_write_loopbody	(	entity	v,
		expression	exp,
		list	vl
	)

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

Modify src/Libs/regions_to_loops/regions_to_loops-local.h instead, to add your own modifications. header file built by cproto regions_to_loops-local.h cproto-generated files regions_to_loops.c

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

An assign statement is made using the array and the expression built using read variables. This allows to avoid dead code elimination.

Parameters

exp	xp
vl	l

Definition at line 96 of file regions_to_loops.c.

                                                                 {
  expression e = reference_to_expression(make_reference(v, gen_full_copy_list(vl)));
  statement s = make_assign_statement(e, exp);
  pips_assert("write body is not properly generated", statement_consistent_p(s));
  return s;
}

References exp, gen_full_copy_list(), make_assign_statement(), make_reference(), pips_assert, reference_to_expression(), and statement_consistent_p().

Referenced by Psysteme_to_loop_nest().

Here is the call graph for this function:

Here is the caller graph for this function:

region_to_loop_nest()

statement region_to_loop_nest	(	effect	,
		bool	,
		entity	,
		expression
	)

regions_to_loops()

bool regions_to_loops

(

char *

module_name

)

This phase replaces the body of a function by automatically generated loops where the read and write statements are representative of the original function.

If the regions are not computable then the function is not modified.

Parameters

module_name

odule_name

Definition at line 261 of file regions_to_loops.c.

                                         {
  // List of the read/write regions
  list l_write = NIL;
  list l_read = NIL;
  
  // List of variables to add in the declaration statement
  list declarations_to_add = NIL;
  
  // Standard initialization
  entity module = local_name_to_top_level_entity(module_name);
  statement module_stat = (statement)db_get_memory_resource(DBR_CODE, module_name, true);
  set_ordering_to_statement(module_stat);
  set_current_module_entity(module);
  set_current_module_statement(module_stat);
  set_methods_for_convex_effects();
  
  // We fetch the summary region list
  list func_regions = effects_to_list((effects)db_get_memory_resource(DBR_SUMMARY_REGIONS, module_name, true));
  
  // And separate the R/W regions into two lists
  l_write = regions_write_regions(func_regions);
  l_read = regions_read_regions(func_regions);
  // We remove irrelevant regions from the lists
  filter_regions(&l_read);
  filter_regions(&l_write);
  
  // If no regions were fetched or if no region is left after filtering then we do nothing
  if (l_read == NIL && l_write == NIL) {
    // Standard reset
    reset_current_module_entity();
    reset_current_module_statement();  
    reset_out_summary_effects_list();
    reset_out_summary_regions_list();
    generic_effects_reset_all_methods();
    reset_ordering_to_statement();
    return true;
  }
 
  // List of statement we are going to use to build the new body of the function
  list sl = NIL;
  // Indices for variable and indices generation
  int varNum = 0;
  int indNum = 0;
  // List of the generated variables for read purposes
  list readVar = NIL;
  // a simple "3" in order to complete the "write" assign statements in case there is no read
  // Given that X1, X2 .. XN are the variables used to make the read statements
  // X1+X2+..+XN+3 is the expression used to make the write statements
  // In theory this avoids dead code elimination
  expression addVarRead = entity_to_expression(make_integer_constant_entity(3));
  // loop indice
  int i = 0;
  
  // We build as many variable as there are read regions 
  for (i = 0; i < (int) gen_length(l_read); i++) {
    entity e = make_new_module_variable(get_current_module_entity(), varNum);
    // We add the new variable to the current expression used for write assignments
    addVarRead = make_addition(addVarRead, entity_to_expression(e));
    varNum++;
    // We add this variable to a specific list
    readVar = CONS(ENTITY, e, readVar);
  }
  // The variables for read purposes having been made, we can add them to the list of declarations to add
  declarations_to_add = gen_nconc(declarations_to_add, readVar);
  
  // Read regions processing
  // We replace the PHI variables of the region, we create a loop statement for this region and add
  // it to the list of statement of the new body
  FOREACH(effect, e, l_read) {
    replace_indices_region(e, &declarations_to_add, indNum, module);
    indNum++;
    statement s = region_to_loop_nest(e, true, gen_car(readVar), expression_undefined);
    POP(readVar);
    sl = CONS(STATEMENT, s, sl);
  }
 
  // Write regions processing
  // Same processing as above. 
  FOREACH(effect, e, l_write) {
    replace_indices_region(e, &declarations_to_add, indNum, module);
    indNum++;
    statement s = region_to_loop_nest(e, false, entity_undefined, addVarRead);
    sl = CONS(STATEMENT, s, sl);
  }
 
  // Inverting and duplicating the elements of the list in order to avoid corrupting data structures.
  sl = gen_full_copy_list(gen_nreverse(sl));
  // Make a new sequence statement in order to replace the old one
  statement ns = make_sequence_from_statement_list(sl);
 
  // Using the list of variables needed to be declared we call a function
  // appending declaration statements to our main sequence
  declarations_to_add = gen_full_copy_list(gen_nreverse(declarations_to_add));
  FOREACH(entity, e, declarations_to_add) {
    ns = add_declaration_statement(ns, e);
  }
 
  // Consistency check
  pips_assert("list of statement is not consistent", statement_consistent_p(ns));
  pips_assert("list of statement is not sequence", statement_sequence_p(ns));
 
  // Free of the old body
  free_statement(module_stat);
 
  // Reorder and putting resource for the new function body
  module_stat = ns;
  module_reorder(module_stat);
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  
  // Standard reset
  reset_current_module_entity();
  reset_current_module_statement();  
  reset_out_summary_effects_list();
  reset_out_summary_regions_list();
  generic_effects_reset_all_methods();
  reset_ordering_to_statement();
  return true;
}

References add_declaration_statement(), CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, effects_to_list(), ENTITY, entity_to_expression(), entity_undefined, expression_undefined, filter_regions(), FOREACH, free_statement(), gen_car(), gen_full_copy_list(), gen_length(), gen_nconc(), gen_nreverse(), generic_effects_reset_all_methods(), get_current_module_entity(), int, local_name_to_top_level_entity(), make_addition(), make_integer_constant_entity(), make_new_module_variable(), make_sequence_from_statement_list(), module, module_name(), module_reorder(), NIL, pips_assert, POP, region_to_loop_nest(), regions_read_regions(), regions_write_regions(), replace_indices_region(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_out_summary_effects_list(), reset_out_summary_regions_list(), set_current_module_entity(), set_current_module_statement(), set_methods_for_convex_effects(), set_ordering_to_statement(), STATEMENT, statement_consistent_p(), and statement_sequence_p().

Here is the call graph for this function:

replace_indices_region()

void replace_indices_region	(	effect	,
		list *	,
		int	,
		entity
	)