replacement in statements

it is not unusual to generate a new entity, this helper functions will take care of substituing all referenced to an old entity by reference in new entities More...

Data Structures
struct	param

Functions
static void	replace_entities_declaration_walker (statement s, hash_table ht)
static void	replace_entities_call_walker (call c, hash_table ht)
static void	replace_entities_expression_walker (expression parent, hash_table ht)
static void	replace_entities_loop_walker (loop l, hash_table ht)
void	replace_entities (void *s, hash_table ht)
	Recursively substitute a set of entities in a statement. More...
void	replace_entity (void *s, entity old, entity new)
	per variable version of replace_entities. More...
void	replace_reference (void *s, reference old, entity new)
	Replace an old reference by a reference to a new entity in a statement. More...
static void	replace_entity_by_expression_expression_walker (expression e, struct param *p)
static void	replace_entity_by_expression_entity_walker (entity e, struct param *p)
static void	replace_entity_by_expression_declarations_walker (statement s, struct param *p)
static void	replace_entity_by_expression_loop_walker (loop l, struct param *p)
void	replace_entity_by_expression_with_filter (void *s, entity ent, expression exp, bool(*filter)(expression))
void	replace_entity_by_expression (void *s, entity ent, expression exp)
	replace all reference to entity ent by expression exp in s. More...
void	replace_entities_by_expression (void *s, hash_table ht)

Detailed Description

it is not unusual to generate a new entity, this helper functions will take care of substituing all referenced to an old entity by reference in new entities

Function Documentation

replace_entities()

void replace_entities	(	void *	s,
		hash_table	ht
	)

Recursively substitute a set of entities in a statement.

replace.c

Parameters

s	newgen type where the substitution must be done
ht	table of old->new pairs

Warning: if the intersection between the input and output sets is not empty, the behavior is undefined

Parameters

ht

t

Definition at line 91 of file replace.c.

{
  if( INSTANCE_OF(entity,(gen_chunkp)s) ) {
      replace_entities(entity_type((entity)s),ht);
      value v = entity_initial((entity)s);
      if( !value_undefined_p(v) && value_expression_p( v ) )
          replace_entities(v,ht);
  }
  else {
      gen_context_multi_recurse(s, ht,
              expression_domain, gen_true, replace_entities_expression_walker,
              statement_domain, gen_true, replace_entities_declaration_walker,
              call_domain, gen_true, replace_entities_call_walker,
              loop_domain, gen_true, replace_entities_loop_walker,
              NULL);
  }
}

References call_domain, entity_initial, entity_type, expression_domain, gen_context_multi_recurse(), gen_true(), INSTANCE_OF, loop_domain, replace_entities_call_walker(), replace_entities_declaration_walker(), replace_entities_expression_walker(), replace_entities_loop_walker(), statement_domain, value_expression_p, and value_undefined_p.

Referenced by rename_statement_declarations(), replace_entities_declaration_walker(), replace_entity(), slightly_rename_entities(), statement_flatten_declarations(), and sww_seq_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entities_by_expression()

void replace_entities_by_expression	(	void *	s,
		hash_table	ht
	)

Parameters

ht

t

Definition at line 225 of file replace.c.

{
    HASH_MAP(k, v, replace_entity_by_expression(s,(entity)k,(expression)v);, ht);
}

References HASH_MAP, and replace_entity_by_expression().

Here is the call graph for this function:

replace_entities_call_walker()

static void replace_entities_call_walker ( call  c, hash_table  ht  )

static

Definition at line 33 of file replace.c.

                                                    {
    entity new = hash_get(ht, call_function(c));
    if( new != HASH_UNDEFINED_VALUE) {
        call_function(c)=new;
    }
}

References call_function, hash_get(), and HASH_UNDEFINED_VALUE.

Referenced by replace_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entities_declaration_walker()

static void replace_entities_declaration_walker ( statement  s, hash_table  ht  )

static

Definition at line 23 of file replace.c.

{
  // FI: this does not seem to replace the declaration itself
  // I need a side-effect on the statement_declarations list when
  // decl_ent == thecouple->old
    FOREACH(ENTITY,decl_ent,statement_declarations(s))
        replace_entities(decl_ent,ht);
}

References ENTITY, FOREACH, replace_entities(), and statement_declarations.

Referenced by replace_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entities_expression_walker()

static void replace_entities_expression_walker ( expression  parent, hash_table  ht  )

static

we need to unormalize the uppermost parent of this expression otherwise its normalized field gets incorrect

otherwise field normalized get wrong

Definition at line 41 of file replace.c.

{
    if(expression_reference_p(parent)) {
        reference r = expression_reference(parent);
        entity new = hash_get(ht,reference_variable(r));
        if(new!= HASH_UNDEFINED_VALUE) {
            if(entity_constant_p(new)) {
                update_expression_syntax(parent,
                        make_syntax_call(make_call(new,NIL))
                        );
            }
            else
                reference_variable(r)=new;
            expression next=parent,root=parent;
            /* we need to unormalize the uppermost parent of this expression
             * otherwise its normalized field gets incorrect */
            while((next=(expression) gen_get_ancestor(expression_domain,next)))
                root=next;
            unnormalize_expression(root); /* otherwise field normalized get wrong */
        }
    }
}

References entity_constant_p, expression_domain, expression_reference(), expression_reference_p(), gen_get_ancestor(), hash_get(), HASH_UNDEFINED_VALUE, make_call(), make_syntax_call(), NIL, reference_variable, unnormalize_expression(), and update_expression_syntax().

Referenced by replace_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entities_loop_walker()

static void replace_entities_loop_walker ( loop  l, hash_table  ht  )

static

Definition at line 64 of file replace.c.

                                                                {
    entity new = hash_get(ht,loop_index(l));
    if(new!= HASH_UNDEFINED_VALUE) {
        // We replace the loop index
        loop_index(l) = new;
    }
 
    // Handle loop locals, in-place replacement
    for(list ll = loop_locals(l); !ENDP(ll); POP(ll)) {
        entity local = ENTITY(CAR(ll));
        entity new = hash_get(ht,local);
        if(new!= HASH_UNDEFINED_VALUE) {
            CAR(ll).p = (gen_chunkp)new;
        }
    }
}

References CAR, ENDP, ENTITY, hash_get(), HASH_UNDEFINED_VALUE, loop_index, loop_locals, and POP.

Referenced by replace_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entity()

void replace_entity	(	void *	s,
		entity	old,
		entity	new
	)

per variable version of replace_entities.

Much slower if you have an hash table of old/new pairs than the replace_entities version

Parameters

old	ld
new	ew

Definition at line 113 of file replace.c.

                                                {
    hash_table ht = hash_table_make(hash_pointer,1);
    hash_put(ht,old,new);
    replace_entities(s,ht);
    hash_table_free(ht);
}

References hash_pointer, hash_put(), hash_table_free(), hash_table_make(), and replace_entities().

Referenced by do_kernelize(), do_scalar_renaming_in_successors(), do_scalar_renaming_in_vertex(), do_terapix_argument_handler(), fix_loop_index_sign(), inline_expression_call(), loadstore_type_conversion_string(), make_array_communication_statement(), move_declaration_control_node_declarations_to_statement(), outliner_independent_recursively(), promote_local_entities(), replace_reference(), solve_name_clashes(), statements_localize_declarations(), terapix_loop_handler(), and terapix_optimize_accumulator().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entity_by_expression()

void replace_entity_by_expression	(	void *	s,
		entity	ent,
		expression	exp
	)

replace all reference to entity ent by expression exp in s.

@s can be any newgen type !

Parameters

ent	nt
exp	xp

Definition at line 220 of file replace.c.

{
    replace_entity_by_expression_with_filter(s,ent,exp,(bool(*)(expression))gen_true);
}

References param::ent, exp, gen_true(), and replace_entity_by_expression_with_filter().

Referenced by do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), do_reduction_propagation(), full_loop_unroll(), fusion(), fusion_buffer(), Hierarchical_tiling(), inline_expression_call(), loop_annotate(), make_loadsave_statement(), normalize_microcode(), replace_entities_by_expression(), scalopify(), sesamify(), Tiling2_buffer(), Tiling_buffer_allocation(), and translate_arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entity_by_expression_declarations_walker()

static void replace_entity_by_expression_declarations_walker ( statement  s, struct param *  p  )

static

Definition at line 191 of file replace.c.

{
    FOREACH(ENTITY,e,statement_declarations(s))
        replace_entity_by_expression_entity_walker(e,p);
 
}

References ENTITY, FOREACH, replace_entity_by_expression_entity_walker(), and statement_declarations.

Referenced by replace_entity_by_expression_with_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entity_by_expression_entity_walker()

static void replace_entity_by_expression_entity_walker ( entity  e, struct param *  p  )

static

Definition at line 176 of file replace.c.

{
    if( ! set_belong_p(p->visited_entities,e)) {
        set_add_element(p->visited_entities,p->visited_entities,e);
        value v = entity_initial(e);
        if( value_expression_p(v) )
            gen_context_recurse(value_expression(v),p,
                            expression_domain,gen_true2,replace_entity_by_expression_expression_walker);
        gen_context_recurse(entity_type(e),p,
                        expression_domain,gen_true2,replace_entity_by_expression_expression_walker);
    }
}

References entity_initial, entity_type, expression_domain, gen_context_recurse, gen_true2(), replace_entity_by_expression_expression_walker(), set_add_element(), set_belong_p(), value_expression, value_expression_p, and param::visited_entities.

Referenced by replace_entity_by_expression_declarations_walker(), and replace_entity_by_expression_loop_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entity_by_expression_expression_walker()

static void replace_entity_by_expression_expression_walker ( expression  e, struct param *  p  )

static

if both are references , concatenante indices

else generate a subscript

Definition at line 137 of file replace.c.

{
    if( expression_reference_p(e) )
    {
        reference r = expression_reference(e);
        if(same_entity_p(p->ent, reference_variable(r) ))
        {
            syntax syn = copy_syntax(expression_syntax(p->exp));
            if(!ENDP(reference_indices(r))) {
                list indices = gen_full_copy_list(reference_indices(r));
                /* if both are references , concatenante indices */
                if(expression_reference_p(p->exp))
                {
                    reference pr = expression_reference(p->exp);
                    syn = make_syntax_reference(
                            make_reference(
                                reference_variable(pr),
                                gen_nconc(gen_full_copy_list(reference_indices(pr)),indices)
                                )
                            );
                }
                /* else generate a subscript */
                else {
                    syn = make_syntax_subscript(make_subscript(make_expression(syn,normalized_undefined),indices));
                }
            }
            update_expression_syntax(e,syn);
        }
    }
    else if(expression_call_p(e))
    {
        call c = expression_call(e);
        if(call_constant_p(c) && same_entity_p(p->ent,call_function(c)))
            update_expression_syntax(e,copy_syntax(expression_syntax(p->exp)));
 
    }
}

References call_constant_p, call_function, copy_syntax(), ENDP, param::ent, param::exp, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), expression_syntax, gen_full_copy_list(), gen_nconc(), indices, make_expression(), make_reference(), make_subscript(), make_syntax_reference(), make_syntax_subscript(), normalized_undefined, reference_indices, reference_variable, same_entity_p(), and update_expression_syntax().

Referenced by replace_entity_by_expression_entity_walker(), and replace_entity_by_expression_with_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entity_by_expression_loop_walker()

static void replace_entity_by_expression_loop_walker ( loop  l, struct param *  p  )

static

Definition at line 199 of file replace.c.

{
    replace_entity_by_expression_entity_walker(loop_index(l),p);
}

References loop_index, and replace_entity_by_expression_entity_walker().

Referenced by replace_entity_by_expression_with_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_entity_by_expression_with_filter()

void replace_entity_by_expression_with_filter	(	void *	s,
		entity	ent,
		expression	exp,
		bool(*)(expression)	filter
	)

Parameters

ent	nt
exp	xp

Definition at line 204 of file replace.c.

{
    struct param p = { ent, exp, set_make(set_pointer)};
    gen_context_multi_recurse(s,&p,
            expression_domain,filter,replace_entity_by_expression_expression_walker,
            statement_domain,gen_true,replace_entity_by_expression_declarations_walker,
                        loop_domain,gen_true, replace_entity_by_expression_loop_walker,
            NULL);
    set_free(p.visited_entities);
}

References param::ent, exp, expression_domain, gen_context_multi_recurse(), gen_true(), loop_domain, replace_entity_by_expression_declarations_walker(), replace_entity_by_expression_expression_walker(), replace_entity_by_expression_loop_walker(), set_free(), set_make(), set_pointer, statement_domain, and param::visited_entities.

Referenced by do_group_constants_terapix(), and replace_entity_by_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_reference()

void replace_reference	(	void *	s,
		reference	old,
		entity	new
	)

Replace an old reference by a reference to a new entity in a statement.

If the reference is a scalar, it's similar to replace_entity, otherwise, it's replace_entity_by_expression

Parameters

old	ld
new	ew

Definition at line 124 of file replace.c.

                                                      {
  /* If the reference is a scalar, it's similar to replace_entity,
     otherwise, it's replace_entity_by_expression */
  if (ENDP(reference_indices(old)))
    replace_entity(s, reference_variable(old), new);
  else {
    pips_internal_error("not implemented yet");
  }
}

References ENDP, pips_internal_error, reference_indices, reference_variable, and replace_entity().

Referenced by add_parameter_variable_to_module(), add_private_variable_to_module(), do_reduction_detection(), and do_reduction_propagation().

Here is the call graph for this function:

Here is the caller graph for this function: