#include <stdlib.h>
#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "resources.h"
#include "database.h"
#include "ri.h"
#include "ri-util.h"
#include "effects.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "control.h"
#include "misc.h"
#include "properties.h"
#include "text-util.h"
#include "task_parallelization.h"
#include "prettyprint.h"

Include dependency graph for eliminate_original_variables.c:

Data Structures
struct	ctx_eov
	ctx_eov: More...

Typedefs
typedef struct ctx_eov	ctx_eov_t
	ctx_eov: More...

Functions
static void	print_ctx (const ctx_eov_t ctx)

static ctx_eov_t	eov_make_ctx (int nbr_cluster, string prefix_new_entity)

static void	eov_free_ctx (ctx_eov_t *ctx)

static void	eov_stack_task_push_task (ctx_eov_t *ctx, task t)

static task	eov_stack_task_pop_task (ctx_eov_t *ctx)

static void	eov_add_entity_to_eliminate (ctx_eov_t *ctx, entity e)

static bool	eov_entity_to_eliminate_p (ctx_eov_t *ctx, entity e)

static entity	eov_get_replaced_enity (ctx_eov_t *ctx, entity e, int on_cluster)
	call entity_to_eliminate_p before eov_get_replaced_enity check on_cluster <= ctx->nbr_cluster before eov_get_replaced_enity More...

static void	eov_set_current_cluster (ctx_eov_t *ctx, int on_cluster)

static int	eov_get_current_cluster (ctx_eov_t *ctx)

static void	subtsitute_variable_in_reference (reference r, ctx_eov_t *ctx)
	if it's needed, variable present in list of variable to eliminate, substitute the variable entity present in reference r by the corresponding one on the corresponding cluster. More...

static bool	prepare_context (statement st, ctx_eov_t *ctx)
	The function in this section modify the context to know. More...

static void	release_context (__attribute__((unused)) statement st, ctx_eov_t *ctx)

static bool	loop_replace_variable (loop l, ctx_eov_t *ctx)
	have to separate loop from reference because index and locals of loop can also be entity variables If it's needed, variable present in list of variable to eliminate, substitute the variable entity present in loop l by the corresponding one on the corresponding cluster. More...

static bool	expression_substitute_variable (expression e, ctx_eov_t *ctx)
	expression_substitute_variable will substitute variable entity that have to be substitute In fact we can not recurse with this domain but directly recurse with reference_domain It was done like this because at the beginning, it was expected to use substitute_entity_in_expression But a custom substitution is more efficient. More...

static bool	make_eliminate_original_variables (__attribute__((unused)) entity module, statement module_statement)

bool	eliminate_original_variables (const char *module_name)
	PIPS pass. More...

Variables
static int	compteur_stack_task = 0
	Pass: ELIMINATE_ORIGINAL_VARIABLES Debug mode: MPI_GENERATION_DEBUG_LEVEL Properties used: More...

Typedef Documentation

◆ ctx_eov_t

typedef struct ctx_eov ctx_eov_t

ctx_eov:

stack_task stack_task is a stack of task each time we enter a statement, we add task corresponding to the statement into stack_task each time we leave a statement, we remove task corresponding to this statement (the last task added) we could access to the current task with function eov_current_task
hash_entity_to_eliminate hash_entity_to_eliminate is a hash table with key an variable entity, that we will have to eliminate/replace with value an array of entity that correspond to the entity that will replace the key the array size correspond to the number of cluster asked by the user (see property with #define MPI_GENERATION_NBR_CLUSTER) structure of hash_entity_to_eliminate entity_var_key0 -> 0 -> entity_new_var0_0 1 -> entity_new_var0_1 2 -> entity_new_var0_2 3 -> entity_new_var0_3 ... entity_var_key1 -> 0 -> entity_new_var1_0 1 -> entity_new_var1_1 2 -> entity_new_var1_2 3 -> entity_new_var1_3 ... ...
nbr_cluster nbr_cluster is the number of cluster it must be different than 0 it's stocked in ctx to not always have to get it from properties
prefix_new_entity prefix_new_entity is a string corresponding to the prefix of the new entity it's stocked in ctx to not always have to get it from properties

Function Documentation

◆ eliminate_original_variables()

bool eliminate_original_variables ( const char * module_name )

PIPS pass.

eliminate_original_variables.c

Reorder the module, because some statements have been added. Well, the order on the remaining statements should be the same, but by reordering the statements, the number are consecutive. Just for pretty print... :-)

Parameters

module_name odule_name

Definition at line 474 of file eliminate_original_variables.c.

                                                            {
   entity module;
   statement module_statement;
   bool good_result_p = true;
  
   debug_on("MPI_GENERATION_DEBUG_LEVEL");
   pips_debug(1, "begin\n");
  
   //-- configure environment --//
   set_current_module_entity(module_name_to_entity(module_name));
   module = get_current_module_entity();
  
   set_current_module_statement( (statement)
       db_get_memory_resource(DBR_CODE, module_name, true) );
   module_statement = get_current_module_statement();
  
   pips_assert("Statement should be OK before...",
       statement_consistent_p(module_statement));
  
   set_ordering_to_statement(module_statement);
  
   //-- get dependencies --//
   set_parallel_task_mapping((statement_task)
       db_get_memory_resource(DBR_TASK, module_name, true));
  
  
   //-- Make the job -- //
   good_result_p = make_eliminate_original_variables(module, module_statement);
 //  gen_recurse(module_statement, statement_domain, gen_true, eliminate_in_statement);
  
  
   /* Reorder the module, because some statements have been added.
      Well, the order on the remaining statements should be the same,
      but by reordering the statements, the number are consecutive. Just
      for pretty print... :-) */
   module_reorder(module_statement);
  
   pips_assert("Statement should be OK after...",
       statement_consistent_p(module_statement));
  
   //-- Save modified code to database --//
   DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(module_name), module_statement);
  
   reset_ordering_to_statement();
   reset_current_module_statement();
   reset_current_module_entity();
   reset_parallel_task_mapping();
  
   pips_debug(1, "end\n");
   debug_off();
  
   return (good_result_p);
 }

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, get_current_module_entity(), get_current_module_statement(), make_eliminate_original_variables(), module, module_name(), module_name_to_entity(), module_reorder(), module_statement, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_parallel_task_mapping(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_parallel_task_mapping(), statement_consistent_p(), and strdup().

Here is the call graph for this function:

◆ eov_add_entity_to_eliminate()

static void eov_add_entity_to_eliminate	(	ctx_eov_t *	ctx,
		entity	e
	)

static

Definition at line 172 of file eliminate_original_variables.c.

                                                                    {
   int nbr_cluster = ctx->nbr_cluster;
   string prefix = ctx->prefix_new_entity;
  
   gen_array_t array = gen_array_make(nbr_cluster);
  
   string name = "";
   entity new_entity = entity_undefined;
  
   for (int i=0; i<nbr_cluster; i++) {
     name = concatenate(
         entity_module_name(e), MODULE_SEP_STRING,
         local_name_to_scope(entity_local_name(e)),
         prefix, entity_user_name(e), "_", i2a(i),
         NULL);
  
     if ((new_entity = gen_find_tabulated(name, entity_domain)) != entity_undefined) {
       gen_array_addto(array, i, new_entity);
     }
     else {
       pips_internal_error("The variable with name %s doesn't exist.\n"
           "  PIPS can't generate the copy for this variable.\n"
           "  Try to launch pass VARIABLE_REPLICATION.\n", name);
     }
     name = "";
     new_entity = entity_undefined;
   }
  
   hash_put(ctx->hash_entity_to_eliminate, e, array);
 }

References array, concatenate(), entity_domain, entity_local_name(), entity_module_name(), entity_undefined, entity_user_name(), gen_array_addto(), gen_array_make(), gen_find_tabulated(), ctx_eov::hash_entity_to_eliminate, hash_put(), i2a(), local_name_to_scope(), MODULE_SEP_STRING, ctx_eov::nbr_cluster, pips_internal_error, prefix, and ctx_eov::prefix_new_entity.

Referenced by prepare_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eov_entity_to_eliminate_p()

static bool eov_entity_to_eliminate_p	(	ctx_eov_t *	ctx,
		entity	e
	)

static

Definition at line 202 of file eliminate_original_variables.c.

                                                                  {
   return hash_defined_p(ctx->hash_entity_to_eliminate, e);
 }

References hash_defined_p(), and ctx_eov::hash_entity_to_eliminate.

Referenced by loop_replace_variable(), and subtsitute_variable_in_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eov_free_ctx()

static void eov_free_ctx ( ctx_eov_t * ctx )

static

Definition at line 139 of file eliminate_original_variables.c.

                                           {
   pips_assert("stack of task not empty", stack_size(ctx->stack_task) == 0);
 //  pips_assert("current_task have to be undefined", ctx->current_task == task_undefined);
   HASH_FOREACH(entity, e, gen_array_t, a, ctx->hash_entity_to_eliminate) {
     gen_array_free(a);
   }
   hash_table_free(ctx->hash_entity_to_eliminate);
 }

References gen_array_free(), ctx_eov::hash_entity_to_eliminate, HASH_FOREACH, hash_table_free(), pips_assert, stack_size(), and ctx_eov::stack_task.

Referenced by make_eliminate_original_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eov_get_current_cluster()

static int eov_get_current_cluster ( ctx_eov_t * ctx )

static

Definition at line 223 of file eliminate_original_variables.c.

                                                     {
   return ctx->current_cluster;
 }

References ctx_eov::current_cluster.

Referenced by loop_replace_variable(), and subtsitute_variable_in_reference().

Here is the caller graph for this function:

◆ eov_get_replaced_enity()

static entity eov_get_replaced_enity	(	ctx_eov_t *	ctx,
		entity	e,
		int	on_cluster
	)

static

call entity_to_eliminate_p before eov_get_replaced_enity check on_cluster <= ctx->nbr_cluster before eov_get_replaced_enity

Definition at line 209 of file eliminate_original_variables.c.

                                                                                 {
   //since it was only local call and I know what I do this assert was not needed
   // pips_assert("entity don't have to be eliminate", entity_to_eliminate_p(ctx, e));
   //since it was only local call and I know what I do this assert was not needed
   // pips_assert("entity asked out of bounded", on_cluster <= ctx->nbr_cluster);
  
   gen_array_t array = hash_get(ctx->hash_entity_to_eliminate, e);
   entity new_entity = gen_array_item(array, on_cluster);
  
   return new_entity;
 }

References array, gen_array_item(), ctx_eov::hash_entity_to_eliminate, and hash_get().

Referenced by loop_replace_variable(), and subtsitute_variable_in_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eov_make_ctx()

static ctx_eov_t eov_make_ctx	(	int	nbr_cluster,
		string	prefix_new_entity
	)

static

Definition at line 128 of file eliminate_original_variables.c.

                                                                          {
   pips_assert("number of cluster can't be equal to 0", nbr_cluster != 0);
   ctx_eov_t ctx;
   ctx.stack_task = stack_make(task_domain, 0, 0);
   ctx.current_task = task_undefined;
   ctx.hash_entity_to_eliminate = hash_table_make(hash_pointer, 10);
   ctx.nbr_cluster = nbr_cluster;
   ctx.current_cluster = -2;
   ctx.prefix_new_entity = prefix_new_entity;
   return ctx;
 }

References ctx_eov::current_cluster, ctx_eov::current_task, ctx_eov::hash_entity_to_eliminate, hash_pointer, hash_table_make(), ctx_eov::nbr_cluster, pips_assert, ctx_eov::prefix_new_entity, stack_make(), ctx_eov::stack_task, task_domain, and task_undefined.

Referenced by make_eliminate_original_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eov_set_current_cluster()

static void eov_set_current_cluster	(	ctx_eov_t *	ctx,
		int	on_cluster
	)

static

Definition at line 220 of file eliminate_original_variables.c.

                                                                      {
   ctx->current_cluster = on_cluster;
 }

References ctx_eov::current_cluster.

Referenced by prepare_context().

Here is the caller graph for this function:

◆ eov_stack_task_pop_task()

static task eov_stack_task_pop_task ( ctx_eov_t * ctx )

static

Definition at line 154 of file eliminate_original_variables.c.

                                                      {
   compteur_stack_task--;
   stack s = ctx->stack_task;
   task pop = (task) stack_pop(s);
   if (stack_empty_p(s)) {
     ctx->current_task = task_undefined;
     ctx->current_cluster = -2;
   }
   else {
     ctx->current_task = (task) stack_head(ctx->stack_task);
     ctx->current_cluster = task_on_cluster(ctx->current_task);
   }
   return pop;
 }

References compteur_stack_task, ctx_eov::current_cluster, ctx_eov::current_task, stack_empty_p(), stack_head(), stack_pop(), ctx_eov::stack_task, task_on_cluster, and task_undefined.

Referenced by release_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eov_stack_task_push_task()

static void eov_stack_task_push_task	(	ctx_eov_t *	ctx,
		task	t
	)

static

Definition at line 148 of file eliminate_original_variables.c.

                                                               {
   compteur_stack_task++;
   ctx->current_task = t;
   ctx->current_cluster = task_on_cluster(t);
   stack_push((void *)t, ctx->stack_task);
 }

References compteur_stack_task, ctx_eov::current_cluster, ctx_eov::current_task, stack_push(), ctx_eov::stack_task, and task_on_cluster.

Referenced by prepare_context().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ expression_substitute_variable()

static bool expression_substitute_variable	(	expression	e,
		ctx_eov_t *	ctx
	)

static

expression_substitute_variable will substitute variable entity that have to be substitute In fact we can not recurse with this domain but directly recurse with reference_domain It was done like this because at the beginning, it was expected to use substitute_entity_in_expression But a custom substitution is more efficient.

Returns: false since we make another gen_context_recurse inside expression_substitute_variable the filter always return false

Definition at line 423 of file eliminate_original_variables.c.

                                                                          {
   ifdebug(3) {
     pips_debug(3, "work on expression\n");
     print_expression(e);
     ifdebug(8) {
       print_ctx(*ctx);
     }
   }
  
   //We don't use substitute_entity_in_expression for performance
   // to use substitute_entity_in_expression we will have to parse 2 times the expression
   // 1 time to find the entity to substitute and make some filter to not have duplicated
   // 1 time with substitute_entity_in_expression to make the substitution
   gen_context_recurse(e, ctx, reference_domain, gen_true2, subtsitute_variable_in_reference);
  
   return false;
 }

References gen_context_recurse, gen_true2(), ifdebug, pips_debug, print_ctx(), print_expression(), reference_domain, and subtsitute_variable_in_reference().

Referenced by make_eliminate_original_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ loop_replace_variable()

static bool loop_replace_variable	(	loop	l,
		ctx_eov_t *	ctx
	)

static

have to separate loop from reference because index and locals of loop can also be entity variables If it's needed, variable present in list of variable to eliminate, substitute the variable entity present in loop l by the corresponding one on the corresponding cluster.

Parameters

l	loop on which the variable will be substituted
ctx	context that content the cluster in which the reference will be executed list on var to eliminate correspondence between variable and new_variable

Definition at line 340 of file eliminate_original_variables.c.

                                                           {
   ifdebug(3) {
     pips_debug(3, "work on loop\n");
     printf_loop(l);
     ifdebug(8) {
       print_ctx(*ctx);
     }
   }
   //task t = eov_current_task(ctx);
   //int on_cluster = task_on_cluster(t);
   int on_cluster = eov_get_current_cluster(ctx);
   if (on_cluster>=ctx->nbr_cluster) {
     pips_user_error("the cluster asked is out of bounded, on_cluster=%%d", on_cluster);
     return true;
   }
  
   entity idx = loop_index(l);
   if (eov_entity_to_eliminate_p(ctx, idx)) {
     entity new_idx = eov_get_replaced_enity(ctx, idx, on_cluster);
     loop_index(l) = new_idx;
   }
  
   list new_locs = NIL;
   FOREACH(ENTITY, ent, loop_locals(l)) {
     if (eov_entity_to_eliminate_p(ctx, ent)) {
       entity new_ent = eov_get_replaced_enity(ctx, ent, on_cluster);
       new_locs = gen_nconc(new_locs, CONS(ENTITY,new_ent,NIL));
     }
     else {
       new_locs = gen_nconc(new_locs, CONS(ENTITY,ent,NIL));
     }
   }
  
   return true;
 }

References CONS, ENTITY, eov_entity_to_eliminate_p(), eov_get_current_cluster(), eov_get_replaced_enity(), FOREACH, gen_nconc(), ifdebug, loop_index, loop_locals, ctx_eov::nbr_cluster, NIL, pips_debug, pips_user_error, print_ctx(), and printf_loop().

Referenced by make_eliminate_original_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ make_eliminate_original_variables()

static bool make_eliminate_original_variables	(	__attribute__((unused)) entity	module,
		statement	module_statement
	)

static

Definition at line 442 of file eliminate_original_variables.c.

                                                                                                                  {
   int nbr_cluster = get_int_property(MPI_GENERATION_NBR_CLUSTER);
   string prefix = (string)get_string_property(MPI_GENERATION_PREFIX);
   ctx_eov_t ctx = eov_make_ctx(nbr_cluster, prefix);
  
   ifdebug(1) {
     pips_debug(1, "begin\n");
     print_ctx(ctx);
   }
  
   // The domain was parse
   gen_context_multi_recurse(
       module_statement, &ctx,
       // to know in which task we are
       statement_domain, prepare_context, release_context,
       // do the work
       // have to distinguish loop since it can have variable entity not encapsulated inside an expression...
       loop_domain, loop_replace_variable, gen_null,
       expression_domain, expression_substitute_variable, gen_null,
       NULL);
  
   ifdebug(1) {
     pips_debug(1, "end\n");
     print_ctx(ctx);
   }
   eov_free_ctx(&ctx);
   return true;
 }

References eov_free_ctx(), eov_make_ctx(), expression_domain, expression_substitute_variable(), gen_context_multi_recurse(), gen_null(), get_int_property(), get_string_property(), ifdebug, loop_domain, loop_replace_variable(), module_statement, MPI_GENERATION_NBR_CLUSTER, MPI_GENERATION_PREFIX, pips_debug, prefix, prepare_context(), print_ctx(), release_context(), and statement_domain.

Referenced by eliminate_original_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepare_context()

static bool prepare_context	(	statement	st,
		ctx_eov_t *	ctx
	)

static

The function in this section modify the context to know.

where we are
on which cluster the statement is executed
which variables will be replaced
in which expression/loop the variable are replaced update current_task update list of entity_variable to eliminate
Parameters

st current statement

ctx context to uppdate

Definition at line 250 of file eliminate_original_variables.c.

                                                           {
   ifdebug(2) {
     pips_debug(2, "prepare_context\n");
     print_statement(st);
   }
   //TODO have to do something for return statement... (on a previous pass?)
   if (statement_call_p(st) && ENTITY_C_RETURN_P(call_function(statement_call(st)))) {
     return false;
   }
   task t = load_parallel_task_mapping(st);
  
   // update the current task to work on
   eov_stack_task_push_task(ctx, t);
   pips_debug(4, "current_task modified:%s\n", task_to_string(t, false));
  
   // update the eliminated variable
   // Check if it's a declaration statement
   // if so maybe have to add entity to the list of entity to eliminate
   if (declaration_statement_p(st)) {
     // we don't have to eliminate variable on_cluster generated
     if (!comments_equal_p(statement_comments(st), COMMENT_VARIABLE_REPLICATION)) {
       FOREACH(ENTITY, var, statement_declarations(st)) {
         if (strncasecmp(entity_user_name(var), ctx->prefix_new_entity, strlen(ctx->prefix_new_entity)) != 0
             && !entity_in_list_p(var, task_private_data(t))) {
           //add entity to the list of entity to eliminate
           eov_add_entity_to_eliminate(ctx, var);
         }
       }
       ifdebug(4) {
         FOREACH(ENTITY, var, statement_declarations(st)) {
           if (strncasecmp(entity_user_name(var), ctx->prefix_new_entity, strlen(ctx->prefix_new_entity))) {
             pips_debug(5, "add entity to entity_to_eliminate:\n");
             print_entity_variable(var);
           }
         }
       }
     }
     // for variable on_cluster generated, check if it's an dynamic declaration of an array
     // and so modify the size of the array with the right new size (the old variable by the new one)
     else {
       FOREACH(ENTITY, var, statement_declarations(st)) {
         if (strncasecmp(entity_user_name(var), ctx->prefix_new_entity, strlen(ctx->prefix_new_entity)) == 0
             && !entity_in_list_p(var, task_private_data(t))) {
           //Modify type dependency declaration
           //a1[size] -> a1[size1]
           //TODO : modify type dependency
           variable vvar = type_variable(entity_type(var));
           if (variable_entity_dimension(var)>0) {
           //if (variable_dimension_number(vvar)) {
             string scurrent_cluster = strrchr(entity_user_name(var),'_');
             if (scurrent_cluster != NULL) {
               int current_cluster = atoi(scurrent_cluster+1);
               eov_set_current_cluster(ctx, current_cluster);
               gen_context_recurse(vvar, ctx, reference_domain, gen_true2, subtsitute_variable_in_reference);
             }
           }
         }
       }
     }
   }
  
   ifdebug(8) {
     print_ctx(*ctx);
   }
   return true;
 }

References call_function, COMMENT_VARIABLE_REPLICATION, comments_equal_p(), declaration_statement_p(), ENTITY, ENTITY_C_RETURN_P, entity_in_list_p(), entity_type, entity_user_name(), eov_add_entity_to_eliminate(), eov_set_current_cluster(), eov_stack_task_push_task(), FOREACH, gen_context_recurse, gen_true2(), ifdebug, load_parallel_task_mapping(), pips_debug, ctx_eov::prefix_new_entity, print_ctx(), print_entity_variable(), print_statement(), reference_domain, statement_call(), statement_call_p(), statement_comments, statement_declarations, subtsitute_variable_in_reference(), task_private_data, task_to_string(), type_variable, and variable_entity_dimension().

Referenced by make_eliminate_original_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_ctx()

static void print_ctx ( const ctx_eov_t ctx )

static

Definition at line 116 of file eliminate_original_variables.c.

                                            {
   fprintf(stderr, "current_task:\n");
   print_task(ctx.current_task);
   fprintf(stderr, "entities to eliminate:\n");
   HASH_FOREACH(entity, e, gen_array_t, a, ctx.hash_entity_to_eliminate) {
     print_entity_variable(e);
     fprintf(stderr, "\n");
   }
   fprintf(stderr, "nbr_cluster=%d", ctx.nbr_cluster);
   fprintf(stderr, "current_cluster=%d", ctx.current_cluster);
 }

References ctx_eov::current_cluster, ctx_eov::current_task, fprintf(), ctx_eov::hash_entity_to_eliminate, HASH_FOREACH, ctx_eov::nbr_cluster, print_entity_variable(), and print_task().

Referenced by expression_substitute_variable(), loop_replace_variable(), make_eliminate_original_variables(), prepare_context(), release_context(), and subtsitute_variable_in_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ release_context()

static void release_context	(	__attribute__((unused)) statement	st,
		ctx_eov_t *	ctx
	)

static

Definition at line 317 of file eliminate_original_variables.c.

                                                                                   {
   pips_debug(2, "release_context\n");
   eov_stack_task_pop_task(ctx);
   ifdebug(8) {
     print_ctx(*ctx);
   }
 }

References eov_stack_task_pop_task(), ifdebug, pips_debug, and print_ctx().

Referenced by make_eliminate_original_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ subtsitute_variable_in_reference()

static void subtsitute_variable_in_reference	(	reference	r,
		ctx_eov_t *	ctx
	)

static

if it's needed, variable present in list of variable to eliminate, substitute the variable entity present in reference r by the corresponding one on the corresponding cluster.

Parameters

r	reference on which the variable will be substituted
ctx	context that content the cluster in which the reference will be executed list on var to eliminate correspondence between variable and new_variable

Definition at line 385 of file eliminate_original_variables.c.

                                                                            {
   ifdebug(3) {
     pips_debug(3, "work on reference\n");
     print_reference(r);
     ifdebug(8) {
       print_ctx(*ctx);
     }
   }
   //task t = eov_current_task(ctx);
   //int on_cluster = task_on_cluster(t);
   int on_cluster = eov_get_current_cluster(ctx);
   entity var = reference_variable(r);
  
   //Test if we want to substitute the variable
   if (eov_entity_to_eliminate_p(ctx, var)) {
     if (on_cluster==-1) {
       statement st = (statement)gen_get_ancestor(statement_domain, r);
       pips_user_error("statement %p in all cluster. This case may never happens.\n%s\n", st, text_to_string(statement_to_text(st)));
     }
     else if (on_cluster < ctx->nbr_cluster) {
       entity new_idx = eov_get_replaced_enity(ctx, var, on_cluster);
       reference_variable(r) = new_idx;
     }
     else {
       pips_user_error("the cluster asked is out of bounded, on_cluster=%%d", on_cluster);
     }
   }
 }