group_constants.c File Reference

provide several layour for program constants grouping More...

#include <ctype.h>
#include "genC.h"
#include "ri-util.h"
#include "effects.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "resources.h"
#include "properties.h"
#include "misc.h"
#include "control.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "accel-util.h"

Include dependency graph for group_constants.c:

Go to the source code of this file.

Data Structures
struct	grouping_context

Enumerations
enum	grouping_layout { TERAPIX_GROUPING , GROUPING_UNDEFINED }

Functions
static void	do_group_constant_entity (expression exp, set constants)
static bool	do_group_statement_constant_filter (range r, set constants)
	remove entities involved in a range from the set of constants More...
static bool	not_type_chunk_p (void *obj)
static void	do_group_statement_constant_prune (statement st, set s)
	remove entities that are never referenced by st from s More...
static void	do_group_statement_constant (statement st, set constants)
	gather all entities that are read and constant in statement s in the set of constant entities More...
static grouping_layout	get_grouping_layout ()
static void *	do_group_basics_maximum_reduce (void *v, const list l)
static basic	do_group_basics_maximum (list entities)
static void *	do_group_count_elements_reduce (void *v, const list l)
static expression	do_group_count_elements (list entities)
static bool	group_constant_range_filter (range r, set constants)
static bool	do_grouping_filter_out_self (expression exp)
static bool	do_grouping_filter_out_self2 (expression e, _UNUSED_ void *ctx)
static void	do_grouping_replace_reference_by_expression_walker (expression exp, grouping_context *ctxt)
static void	do_grouping_replace_reference_by_expression (void *in, entity old, entity new, expression offset)
static void	do_group_constants_terapix (statement in, set constants)
static void	do_group_constants (statement in, set constants)
static bool	declaration_filter (call c)
	Do not touch to the prettyprint control list. More...
bool	group_constants (const string module_name)
	Dependences for accel-util.h. More...

Variables
static entity	constant_holder

Detailed Description

provide several layour for program constants grouping

Author

Serge Guelton serge.nosp@m..gue.nosp@m.lton@.nosp@m.enst.nosp@m.-bret.nosp@m.agne.nosp@m..fr

Date

2010-05-12

Definition in file group_constants.c.

Enumeration Type Documentation

grouping_layout

enum grouping_layout

Enumerator
TERAPIX_GROUPING
GROUPING_UNDEFINED

Definition at line 161 of file group_constants.c.

             {
    TERAPIX_GROUPING,
    GROUPING_UNDEFINED
} grouping_layout;

Function Documentation

declaration_filter()

static bool declaration_filter ( call  c )

static

Do not touch to the prettyprint control list.

Might be better to avoid it... at least for functions if not control units.

Definition at line 338 of file group_constants.c.

{
  bool go_on_p = true;
  entity f = call_function(c);
  if(ENTITY_CONTINUE_P(f))
    go_on_p = false;
  return go_on_p;
}

References call_function, ENTITY_CONTINUE_P, and f().

Referenced by group_constants().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_basics_maximum()

static basic do_group_basics_maximum ( list  entities )

static

Definition at line 178 of file group_constants.c.

{
    if(ENDP(entities)) return basic_undefined;
    else return (basic)gen_reduce(entity_basic(ENTITY(CAR(entities))),do_group_basics_maximum_reduce,CDR(entities));
}

References basic_undefined, CAR, CDR, do_group_basics_maximum_reduce(), ENDP, ENTITY, entity_basic(), and gen_reduce().

Referenced by do_group_constants_terapix().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_basics_maximum_reduce()

static void* do_group_basics_maximum_reduce ( void *  v, const list  l  )

static

Definition at line 173 of file group_constants.c.

{
    return basic_maximum((basic)v,entity_basic(ENTITY(CAR(l))));
}

References basic_maximum(), CAR, ENTITY, and entity_basic().

Referenced by do_group_basics_maximum().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_constant_entity()

static void do_group_constant_entity ( expression  exp, set  constants  )

static

Definition at line 47 of file group_constants.c.

{
    if(expression_call_p(exp))
    {
        call c = expression_call(exp);
        value cv = entity_initial(call_function(c));
        if (value_symbolic_p(cv))
            set_add_element(constants,constants,call_function(c));
        else if (value_constant_p(cv) && get_bool_property("GROUP_CONSTANTS_LITERAL")) {
            set_add_element(constants,constants,call_function(c));
 
        }
    }
}

References call_function, entity_initial, exp, expression_call(), expression_call_p(), get_bool_property(), set_add_element(), value_constant_p, and value_symbolic_p.

Referenced by group_constants().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_constants()

static void do_group_constants ( statement  in, set  constants  )

static

as of now, put everything in an array, no matter of the real type, yes it is horrible, but it matches my needs for terapix, where everything as the same type later on, you may want to use a structure to pass parameters

Definition at line 320 of file group_constants.c.

{
    /* as of now, put everything in an array, no matter of the real type, yes it is horrible,
     * but it matches my needs for terapix, where everything as the same type
     * later on, you may want to use a structure to pass parameters*/
    switch(get_grouping_layout()) {
        case TERAPIX_GROUPING:
            return do_group_constants_terapix(in,constants);
        case GROUPING_UNDEFINED:
            pips_user_error("no valid grouping layout given\n");
    }
}

References do_group_constants_terapix(), get_grouping_layout(), GROUPING_UNDEFINED, pips_user_error, and TERAPIX_GROUPING.

Referenced by group_constants().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_constants_terapix()

static void do_group_constants_terapix ( statement  in, set  constants  )

static

it may not be possible to initialize statically the array, so use loop initialization to be more general

Definition at line 251 of file group_constants.c.

{
    list lconstants = set_to_sorted_list(constants,(gen_cmp_func_t)compare_entities);
    basic max = do_group_basics_maximum(lconstants);
    if(!basic_undefined_p(max))
    {
        expression size = do_group_count_elements(lconstants);
        constant_holder = make_new_array_variable_with_prefix(
                get_string_property("GROUP_CONSTANTS_HOLDER"),
                get_current_module_entity(),
                basic_overloaded_p(max)?make_basic_int(DEFAULT_INTEGER_TYPE_SIZE):copy_basic(max),
                CONS(DIMENSION,
                     make_dimension(int_to_expression(0),
                                    make_op_exp(MINUS_OPERATOR_NAME,size,int_to_expression(1)),
                                    NIL),
                     NIL)
                );
 
        /* it may not be possible to initialize statically the array, so use loop initialization
         * to be more general
         */
        list initializations_holder_seq = NIL;
        expression index = int_to_expression(0);
 
        FOREACH(ENTITY,econstant,lconstants)
        {
            if((entity_variable_p(econstant) && entity_scalar_p(econstant)) || entity_constant_p(econstant))
            {
                expression new_constant_exp = reference_to_expression(make_reference(constant_holder,make_expression_list(copy_expression(index))));
                initializations_holder_seq=CONS(STATEMENT,
                        make_assign_statement(
                            new_constant_exp,
                            entity_to_expression(econstant)
                            ),
                        initializations_holder_seq);
                replace_entity_by_expression_with_filter(in,econstant,new_constant_exp, do_grouping_filter_out_self);
                index=make_op_exp(PLUS_OPERATOR_NAME,index,int_to_expression(1));
            }
            else {
                list indices = NIL;
                reference lhs = make_reference(constant_holder,NIL);// the indices will be set later
                reference rhs = make_reference(econstant,NIL);// the indices will be set later I told you
                statement body = make_assign_statement(reference_to_expression(lhs),reference_to_expression(rhs));
                list dimensions = gen_copy_seq(variable_dimensions(type_variable(ultimate_type(entity_type(econstant)))));
                dimensions=gen_nreverse(dimensions);
                FOREACH(DIMENSION,dim,dimensions)
                {
                    entity lindex = make_new_scalar_variable_with_prefix("z",get_current_module_entity(),make_basic_int(DEFAULT_INTEGER_TYPE_SIZE));
                    AddLocalEntityToDeclarations(lindex,get_current_module_entity(),in);
                    loop l = make_loop(lindex,dimension_to_range(dim),body,entity_empty_label(),make_execution_sequential(),NIL);
                    body=instruction_to_statement(make_instruction_loop(l));
                    indices=CONS(EXPRESSION,entity_to_expression(lindex),indices);
                }
                reference_indices(rhs)=indices;
                reference_indices(lhs)=make_expression_list(make_op_exp(PLUS_OPERATOR_NAME,copy_expression(index),reference_offset(rhs)));
                initializations_holder_seq=CONS(STATEMENT,body,initializations_holder_seq);
                do_grouping_replace_reference_by_expression(in,econstant,constant_holder,index);
                index=make_op_exp(PLUS_OPERATOR_NAME,index,SizeOfDimensions(dimensions));
                gen_free_list(dimensions);
            }
        }
        insert_statement(in,make_block_statement(gen_nreverse(initializations_holder_seq)),true);
        AddLocalEntityToDeclarations(constant_holder,get_current_module_entity(),in);
    }
    gen_free_list(lconstants);
}

References AddLocalEntityToDeclarations(), basic_overloaded_p, basic_undefined_p, compare_entities(), CONS, constant_holder, copy_basic(), copy_expression(), DEFAULT_INTEGER_TYPE_SIZE, DIMENSION, dimension_to_range(), do_group_basics_maximum(), do_group_count_elements(), do_grouping_filter_out_self(), do_grouping_replace_reference_by_expression(), ENTITY, entity_constant_p, entity_empty_label(), entity_scalar_p(), entity_to_expression(), entity_type, entity_variable_p, EXPRESSION, FOREACH, gen_copy_seq(), gen_free_list(), gen_nreverse(), get_current_module_entity(), get_string_property(), indices, insert_statement(), instruction_to_statement(), int_to_expression(), make_assign_statement(), make_basic_int(), make_block_statement(), make_dimension(), make_execution_sequential(), make_expression_list, make_instruction_loop(), make_loop(), make_new_array_variable_with_prefix(), make_new_scalar_variable_with_prefix(), make_op_exp(), make_reference(), max, MINUS_OPERATOR_NAME, NIL, PLUS_OPERATOR_NAME, reference_indices, reference_offset(), reference_to_expression(), replace_entity_by_expression_with_filter(), set_to_sorted_list(), SizeOfDimensions(), STATEMENT, type_variable, ultimate_type(), and variable_dimensions.

Referenced by do_group_constants().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_count_elements()

static expression do_group_count_elements ( list  entities )

static

Definition at line 193 of file group_constants.c.

{
    return (expression)gen_reduce(int_to_expression(0),do_group_count_elements_reduce,entities);
}

References do_group_count_elements_reduce(), gen_reduce(), and int_to_expression().

Referenced by do_group_constants_terapix().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_count_elements_reduce()

static void* do_group_count_elements_reduce ( void *  v, const list  l  )

static

Definition at line 184 of file group_constants.c.

{
    entity e = ENTITY(CAR(l));
    if( (entity_variable_p(e) && entity_scalar_p(e)) || entity_constant_p(e))
        return  make_op_exp(PLUS_OPERATOR_NAME,copy_expression((expression)v),int_to_expression(1));
    else
        return make_op_exp(PLUS_OPERATOR_NAME,copy_expression((expression)v),SizeOfDimensions(variable_dimensions(type_variable(ultimate_type(entity_type(e))))));
}

References CAR, copy_expression(), ENTITY, entity_constant_p, entity_scalar_p(), entity_type, entity_variable_p, int_to_expression(), make_op_exp(), PLUS_OPERATOR_NAME, SizeOfDimensions(), type_variable, ultimate_type(), and variable_dimensions.

Referenced by do_group_count_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_statement_constant()

static void do_group_statement_constant ( statement  st, set  constants  )

static

gather all entities that are read and constant in statement s in the set of constant entities

first gather all written entities

then search among all read and not written variables those who have constant phis

we have found the right vector, now check for other vectors

check the size too : small means mask

then prune this set, because it contains the preconditions too

eventually filter out some entities involved in range computation

Definition at line 84 of file group_constants.c.

{
    list regions = load_rw_effects_list(st);
    list read_regions = regions_read_regions(regions);
    list write_regions = regions_write_regions(regions);
    set written_entities = set_make(set_pointer);
 
    /* first gather all written entities */
    FOREACH(REGION,reg,write_regions)
    {
        reference ref = region_any_reference(reg);
        entity var = reference_variable(ref);
        set_add_element(written_entities,written_entities,var);
    }
    gen_free_list(write_regions);
 
 
    /* then search among all read and not written variables
     * those who have constant phis
     */
    FOREACH(REGION,reg,read_regions)
    {
        reference ref = region_any_reference(reg);
        entity var = reference_variable(ref);
        if(!set_belong_p(written_entities,var))
        {
            bool found_not_constant_constraint = false;
            Psysteme sc = sc_dup(region_system(reg));
            sc_transform_eg_in_ineg(sc);
            FOREACH(EXPRESSION,index,reference_indices(ref))
            {
                Variable phi = expression_to_entity(index);
                bool phi_found_p =false;
                for(Pcontrainte iter = sc_inegalites(sc);iter;iter=contrainte_succ(iter))
                {
                    Pvecteur cvect = contrainte_vecteur(iter);
                    Value phi_coeff = vect_coeff(phi,cvect);
                    /* we have found the right vector, now check for other vectors */
                    if(phi_coeff != VALUE_ZERO )
                    {
                        phi_found_p=true;
                        Pvecteur other_vects = vect_del_var(cvect,phi);
                        found_not_constant_constraint|=vect_size(other_vects)!=1 || VARIABLE_DEFINED_P(other_vects->var);
                        vect_rm(other_vects);
                    }
                }
                found_not_constant_constraint |=!phi_found_p;
            }
            if(!found_not_constant_constraint) {
                    set_add_element(constants,constants,var);
            }
            else {
                /* check the size too : small means mask */
                Ppolynome pp = region_enumerate(reg);
                if(!POLYNOME_UNDEFINED_P(pp)) {
                    expression epp = polynome_to_expression(pp);
                    intptr_t ipp;
                    if(expression_integer_value(epp,&ipp) && ipp < 33)
                        found_not_constant_constraint=false;
                    free_expression(epp);
                    polynome_free(pp);
                }
                if(!found_not_constant_constraint) 
                    set_add_element(constants,constants,var);
            }
        }
    }
    /* then prune this set, because it contains the preconditions too */
    do_group_statement_constant_prune(st,constants);
 
    /* eventually filter out some entities involved in range computation */
    if(get_bool_property("GROUP_CONSTANTS_SKIP_LOOP_RANGE"))
        gen_context_recurse(st,constants,range_domain,do_group_statement_constant_filter,gen_null2);
    gen_free_list(read_regions);
    set_free(written_entities);
}

References contrainte_succ, contrainte_vecteur, do_group_statement_constant_filter(), do_group_statement_constant_prune(), EXPRESSION, expression_integer_value(), expression_to_entity(), FOREACH, free_expression(), gen_context_recurse, gen_free_list(), gen_null2(), get_bool_property(), intptr_t, load_rw_effects_list(), polynome_free(), polynome_to_expression(), POLYNOME_UNDEFINED_P, range_domain, ref, reference_indices, reference_variable, REGION, region_any_reference, region_enumerate(), region_system, regions_read_regions(), regions_write_regions(), sc_dup(), sc_transform_eg_in_ineg(), set_add_element(), set_belong_p(), set_free(), set_make(), set_pointer, VALUE_ZERO, Svecteur::var, VARIABLE_DEFINED_P, vect_coeff(), vect_del_var(), vect_rm(), and vect_size().

Referenced by group_constants().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_statement_constant_filter()

static bool do_group_statement_constant_filter ( range  r, set  constants  )

static

remove entities involved in a range from the set of constants

Definition at line 63 of file group_constants.c.

                                                                      {
    set ref = get_referenced_entities(r);
    set_difference(constants,constants,ref);
    set_free(ref);
    return false;
}

References get_referenced_entities(), ref, set_difference(), and set_free().

Referenced by do_group_statement_constant().

Here is the call graph for this function:

Here is the caller graph for this function:

do_group_statement_constant_prune()

static void do_group_statement_constant_prune ( statement  st, set  s  )

static

remove entities that are never referenced by st from s

Definition at line 75 of file group_constants.c.

{
    set ref = get_referenced_entities_filtered(st,not_type_chunk_p,entity_not_constant_or_intrinsic_p);
    set_intersection(s,s,ref);
    set_free(ref);
}

References entity_not_constant_or_intrinsic_p(), get_referenced_entities_filtered(), not_type_chunk_p(), ref, set_free(), and set_intersection().

Referenced by do_group_statement_constant().

Here is the call graph for this function:

Here is the caller graph for this function:

do_grouping_filter_out_self()

static bool do_grouping_filter_out_self ( expression  exp )

static

Definition at line 205 of file group_constants.c.

{
    if(gen_get_ancestor(range_domain,exp) && get_bool_property("GROUP_CONSTANTS_SKIP_LOOP_RANGE") )
        return false;
    if(expression_reference_p(exp))
    {
        reference ref = expression_reference(exp);
        return !same_entity_p(reference_variable(ref),constant_holder);
    }
    return true;
}

References constant_holder, exp, expression_reference(), expression_reference_p(), gen_get_ancestor(), get_bool_property(), range_domain, ref, reference_variable, and same_entity_p().

Referenced by do_group_constants_terapix(), and do_grouping_filter_out_self2().

Here is the call graph for this function:

Here is the caller graph for this function:

do_grouping_filter_out_self2()

static bool do_grouping_filter_out_self2 ( expression  e, _UNUSED_ void *  ctx  )

static

Definition at line 217 of file group_constants.c.

{
  return do_grouping_filter_out_self(e);
}

References do_grouping_filter_out_self().

Referenced by do_grouping_replace_reference_by_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

do_grouping_replace_reference_by_expression()

static void do_grouping_replace_reference_by_expression ( void *  in, entity  old, entity  new, expression  offset  )

static

Definition at line 245 of file group_constants.c.

{
    grouping_context ctxt = { old,new,offset };
    gen_context_recurse(in,&ctxt,expression_domain,do_grouping_filter_out_self2,do_grouping_replace_reference_by_expression_walker);
}

References do_grouping_filter_out_self2(), do_grouping_replace_reference_by_expression_walker(), expression_domain, gen_context_recurse, and offset.

Referenced by do_group_constants_terapix().

Here is the call graph for this function:

Here is the caller graph for this function:

do_grouping_replace_reference_by_expression_walker()

static void do_grouping_replace_reference_by_expression_walker ( expression  exp, grouping_context *  ctxt  )

static

compute new index

perform substitution

Definition at line 228 of file group_constants.c.

{
    if(expression_reference_p(exp))
    {
        reference ref = expression_reference(exp);
        if(same_entity_p(reference_variable(ref),ctxt->old))
        {
            /* compute new index */
            expression current_index = reference_offset(ref);
            /* perform substitution */
            reference_variable(ref)=ctxt->new;
            gen_full_free_list(reference_indices(ref));
            reference_indices(ref)=make_expression_list(make_op_exp(PLUS_OPERATOR_NAME,current_index,copy_expression(ctxt->offset)));
        }
    }
}

References copy_expression(), exp, expression_reference(), expression_reference_p(), gen_full_free_list(), make_expression_list, make_op_exp(), grouping_context::new, grouping_context::offset, grouping_context::old, PLUS_OPERATOR_NAME, ref, reference_indices, reference_offset(), reference_variable, and same_entity_p().

Referenced by do_grouping_replace_reference_by_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

get_grouping_layout()

static grouping_layout get_grouping_layout ( )

static

Definition at line 166 of file group_constants.c.

{
    const char* layout = get_string_property("GROUP_CONSTANTS_LAYOUT");
    if(same_string_p(layout,"terapix")) return TERAPIX_GROUPING;
    return GROUPING_UNDEFINED;
}

References get_string_property(), GROUPING_UNDEFINED, same_string_p, and TERAPIX_GROUPING.

Referenced by do_group_constants().

Here is the call graph for this function:

Here is the caller graph for this function:

group_constant_range_filter()

static bool group_constant_range_filter ( range  r, set  constants  )

static

Definition at line 198 of file group_constants.c.

{
  pips_assert("true", r==r && constants==constants);
    return !get_bool_property("GROUP_CONSTANTS_SKIP_LOOP_RANGE");
}

References get_bool_property(), and pips_assert.

Referenced by group_constants().

Here is the call graph for this function:

Here is the caller graph for this function:

group_constants()

bool group_constants

(

const

string

)

Dependences for accel-util.h.

cproto-generated files group_constants.c

prelude

f entities

gather statement constants

gather constants

pack all constants and perform replacement

validate

ostlude

Parameters

module_name

odule_name

Definition at line 347 of file group_constants.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_rw_effects((statement_effects) db_get_memory_resource(DBR_REGIONS,module_name,true) );
 
    set/*of entities*/ constants=set_make(set_pointer);;
 
    /* gather statement constants */
    statement constant_statement = find_statement_from_label_name(get_current_module_statement(),module_name,get_string_property("GROUP_CONSTANTS_STATEMENT_LABEL"));
    if(statement_undefined_p(constant_statement))  constant_statement=get_current_module_statement();
    do_group_statement_constant(constant_statement,constants);
 
    /* gather constants */
    gen_context_multi_recurse(constant_statement,constants,
            range_domain,group_constant_range_filter,gen_null,
            call_domain, declaration_filter, gen_null,
            reference_domain,gen_false,gen_null,
            expression_domain,gen_true,do_group_constant_entity,NULL);
 
    /* pack all constants and perform replacement */
    do_group_constants(constant_statement,constants);
 
    set_free(constants);
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
    reset_rw_effects();
    return true;
}

References call_domain, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, declaration_filter(), do_group_constant_entity(), do_group_constants(), do_group_statement_constant(), expression_domain, find_statement_from_label_name(), gen_context_multi_recurse(), gen_false(), gen_null(), gen_true(), get_current_module_statement(), get_string_property(), group_constant_range_filter(), module_name(), module_name_to_entity(), module_reorder(), range_domain, reference_domain, reset_current_module_entity(), reset_current_module_statement(), reset_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_free(), set_make(), set_pointer, set_rw_effects(), and statement_undefined_p.

Here is the call graph for this function:

not_type_chunk_p()

static bool not_type_chunk_p ( void *  obj )

static

Definition at line 70 of file group_constants.c.

                                        {
    return !INSTANCE_OF(type,(gen_chunkp)obj);
}

References INSTANCE_OF.

Referenced by do_group_statement_constant_prune().

Here is the caller graph for this function:

Variable Documentation

constant_holder

entity constant_holder

static

Definition at line 204 of file group_constants.c.

Referenced by do_group_constants_terapix(), and do_grouping_filter_out_self().