statement_insertion.c File Reference

#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "text.h"
#include "pipsdbm.h"
#include "resources.h"
#include "properties.h"
#include "misc.h"
#include "conversion.h"
#include "effects.h"
#include "semantics.h"
#include "transformer.h"
#include "control.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "text-util.h"
#include "parser_private.h"
#include "accel-util.h"

Include dependency graph for statement_insertion.c:

Go to the source code of this file.

Data Structures
struct	entity_list_pair
struct	entity_to_declaring_statement_t

Functions
static void	find_calls_to_function_walker (call c, entity_list_pair *p)
static void	find_calls_to_function_walker_in_declaration (statement s, entity_list_pair *p)
static list	find_calls_to_function (statement in, entity to)
	returns a list of call to to found in in More...
static void	statement_insertion_fix_access_in_callers (const char *module_name, entity new_formal)
	tries hard to propagate entity dimension change More...
static void	statement_insertion_fix_access (list regions)
	fixes statement declaration depending on region access More...
static bool	do_statement_insertion (statement s)
bool	statement_insertion (const char *module_name)
	statement_insertion.c More...
static void	entity_to_declaring_statement_aux (statement s, entity_to_declaring_statement_t *param)
static statement	entity_to_declaring_statement (entity e, statement top)
	returns the statement block declaring entity e among all thoses in top assumes the entity is declared locally c only More...
static void	do_array_expansion_aux (statement s, hash_table expanded)
static bool	do_array_expansion (statement s, hash_table expanded)
bool	array_expansion (const char *module_name)

Function Documentation

array_expansion()

bool array_expansion

(

const char *

module_name

)

init

do

validate

Parameters

module_name

odule_name

Definition at line 395 of file statement_insertion.c.

{
    /* init */
    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_REGIONS, module_name, true));
    set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings(get_current_module_entity());
    set_precondition_map( (statement_mapping) db_get_memory_resource(DBR_PRECONDITIONS, module_name, true) );
    debug_on("ARRAY_EXPANSION_DEBUG_LEVEL");
 
    /* do */
    hash_table expanded = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
    gen_context_recurse(get_current_module_statement(),expanded,
            statement_domain,do_array_expansion,do_array_expansion_aux);
    hash_table_free(expanded);
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
 
    debug_off();
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_precondition_map();
    free_value_mappings();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_array_expansion(), do_array_expansion_aux(), expanded, free_value_mappings(), gen_context_recurse, get_current_module_entity(), get_current_module_statement(), HASH_DEFAULT_SIZE, hash_pointer, hash_table_free(), hash_table_make(), module_name(), module_name_to_entity(), module_reorder(), module_to_value_mappings(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_precondition_map(), set_proper_rw_effects(), and statement_domain.

Here is the call graph for this function:

do_array_expansion()

static bool do_array_expansion ( statement  s, hash_table  expanded  )

static

if we reach this point, we are ready for backward translation from vecteur to dimensions :)

Definition at line 305 of file statement_insertion.c.

                                                                 {
    list regions = load_cumulated_rw_effects_list(s);
    set declarations =set_make(set_pointer);
    set_assign_list(declarations,entity_declarations(get_current_module_entity()));
    VOLATILE_FOREACH(REGION,reg,regions)
    {
        reference r = region_any_reference(reg);
        entity e = reference_variable(r);
        if(set_belong_p(declarations,e) &&
                hash_get(expanded,e)==HASH_UNDEFINED_VALUE &&
                array_entity_p(e) ) {
 
            statement sdecl = entity_to_declaring_statement(e,get_current_module_statement());
            transformer tr = transformer_range(
                    load_statement_precondition(sdecl));
 
            list phis = expressions_to_entities(reference_indices(r));
            Psysteme access_syst = region_system(reg);
            Psysteme decl = entity_declaration_sc(e);
 
            volatile Psysteme sr;
            CATCH(overflow_error)
            {
                pips_debug(1, "overflow error\n");
                return true;
            }
            TRY
            {
                Psysteme tmp = sc_cute_convex_hull(access_syst,decl);
                tmp=
                    sc_safe_append(tmp,
                            predicate_system(transformer_relation(tr)));
                sc_nredund(&tmp);
                Pbase pb = list_to_base(phis);
                sr = sc_rectangular_hull(tmp,pb);
                sc_rm(tmp);
                UNCATCH(overflow_error);
            }
            /* if we reach this point, we are ready for backward translation from vecteur to dimensions :) */
            list new_dimensions = NIL;
            bool ok=true;
            FOREACH(ENTITY,phi,phis)
            {
                Pcontrainte lower,upper;
                constraints_for_bounds(phi, &sc_inegalites(sr), &lower, &upper);
                if( !CONTRAINTE_UNDEFINED_P(lower) && !CONTRAINTE_UNDEFINED_P(upper))
                {
                    expression elower = constraints_to_loop_bound(lower,phi,true,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                    simplify_minmax_expression(elower,tr);
                    expression eupper = constraints_to_loop_bound(upper,phi,false,entity_intrinsic(DIVIDE_OPERATOR_NAME));
                    simplify_minmax_expression(eupper,tr);
                    new_dimensions=CONS(DIMENSION,
                                        make_dimension(elower,eupper,NIL),
                                        new_dimensions);
                }
                else {
                    pips_user_warning("failed to translate region\n");
                    ok=false;
                }
            }
            transformer_free(tr);
            if(ok) {
                hash_put(expanded,e,s);
                new_dimensions=gen_nreverse(new_dimensions);
                gen_full_free_list(variable_dimensions(type_variable(entity_type(e))));
                variable_dimensions(type_variable(entity_type(e)))=new_dimensions;
                gen_free_list(phis);
                if(formal_parameter_p(e)) {
                    formal f = storage_formal(entity_storage(e));
                    intptr_t i=0,offset = formal_offset(f);
                    FOREACH(PARAMETER,p,module_functional_parameters(get_current_module_entity())) {
                        if(i++ == offset) {
                            dummy d = parameter_dummy(p);
                            if(dummy_identifier_p(d))
                            {
                                entity di = dummy_identifier(d);
                                variable v = type_variable(entity_type(di));
                                gen_full_free_list(variable_dimensions(v));
                                variable_dimensions(v)=gen_full_copy_list(new_dimensions);
                            }
                        }
                    }
                }
            }
        }
    }
    set_free(declarations);
    return true;
}

References array_entity_p(), CATCH, CONS, constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED_P, DIMENSION, DIVIDE_OPERATOR_NAME, dummy_identifier, dummy_identifier_p, ENTITY, entity_declaration_sc(), entity_declarations, entity_intrinsic(), entity_storage, entity_to_declaring_statement(), entity_type, expanded, expressions_to_entities(), f(), FOREACH, formal_offset, formal_parameter_p(), gen_free_list(), gen_full_copy_list(), gen_full_free_list(), gen_nreverse(), get_current_module_entity(), get_current_module_statement(), hash_get(), hash_put(), HASH_UNDEFINED_VALUE, intptr_t, list_to_base(), load_cumulated_rw_effects_list(), load_statement_precondition(), make_dimension(), module_functional_parameters, NIL, offset, ok, overflow_error, PARAMETER, parameter_dummy, pips_debug, pips_user_warning, predicate_system, reference_indices, reference_variable, REGION, region_any_reference, region_system, sc_cute_convex_hull(), sc_rectangular_hull(), sc_rm(), sc_safe_append(), set_assign_list(), set_belong_p(), set_free(), set_make(), set_pointer, simplify_minmax_expression(), storage_formal, transformer_free(), transformer_range(), transformer_relation, TRY, type_variable, UNCATCH, variable_dimensions, and VOLATILE_FOREACH.

Referenced by array_expansion().

Here is the call graph for this function:

Here is the caller graph for this function:

do_array_expansion_aux()

static void do_array_expansion_aux ( statement  s, hash_table  expanded  )

static

Definition at line 294 of file statement_insertion.c.

                                                                     {
    list remove = NIL;
    HASH_FOREACH(entity,e,statement,sp,expanded) {
        if(s==sp)
            remove=CONS(ENTITY,e,remove);
    }
    FOREACH(ENTITY,e,remove)
        hash_del(expanded,e);
    gen_free_list(remove);
}

References CONS, ENTITY, expanded, FOREACH, gen_free_list(), hash_del(), HASH_FOREACH, and NIL.

Referenced by array_expansion().

Here is the call graph for this function:

Here is the caller graph for this function:

do_statement_insertion()

static bool do_statement_insertion ( statement  s )

static

first find a statement with the relevant pragma

make sure all data access are ok by building the convex union of data access and data declarations

update pragma

update pragma

Definition at line 180 of file statement_insertion.c.

{
    /* first find a statement with the relevant pragma */
    const char* inserted_pragma = get_string_property("STATEMENT_INSERTION_PRAGMA");
    if(empty_string_p(inserted_pragma)) {
        pips_user_warning("STATEMENT_INSERTION_PRAGMA property should not be empty\n");
    }
    else {
        list flagged_statements = find_statements_with_pragma(s,inserted_pragma);
        if(ENDP(flagged_statements)) {
            pips_user_warning("no statement with pragma '%s' found\n",inserted_pragma);
        }
        else {
            FOREACH(STATEMENT,flagged_statement,flagged_statements) {
                list out_regions = effects_effects(load_proper_rw_effects(flagged_statement));
                if(ENDP(out_regions))
                {
                    /* make sure all data access are ok by building the convex union of data access and data declarations */
                    list regions = load_cumulated_rw_effects_list(flagged_statement);
                    statement_insertion_fix_access(regions);
                    /* update pragma */
                    FOREACH(EXTENSION,ext,extensions_extension(statement_extensions(flagged_statement)))
                    {
                        if(pragma_string_p(extension_pragma(ext)))
                        {
                            string str_pragma = pragma_string(extension_pragma(ext));
                            if(strstr( str_pragma , inserted_pragma ))
                            {
                                free(str_pragma);
                                pragma_string(extension_pragma(ext))=strdup(get_string_property("STATEMENT_INSERTION_SUCCESS_PRAGMA"));
                            }
                        }
                    }
                    return true;
                }
                else
                {
                    pips_user_warning("inserted statment has out effects\n");
                    /* update pragma */
                    FOREACH(EXTENSION,ext,extensions_extension(statement_extensions(flagged_statement)))
                    {
                        if(pragma_string_p(extension_pragma(ext)))
                        {
                            string str_pragma = pragma_string(extension_pragma(ext));
                            if(strstr( str_pragma , inserted_pragma ))
                            {
                                free(str_pragma);
                                pragma_string(extension_pragma(ext))=strdup(get_string_property("STATEMENT_INSERTION_FAILURE_PRAGMA"));
                            }
                        }
                    }
                }
 
            }
        }
 
    }
    return false;
}

References effects_effects, empty_string_p(), ENDP, EXTENSION, extension_pragma, extensions_extension, find_statements_with_pragma(), FOREACH, free(), get_string_property(), load_cumulated_rw_effects_list(), load_proper_rw_effects(), out_regions(), pips_user_warning, pragma_string, pragma_string_p, STATEMENT, statement_extensions, statement_insertion_fix_access(), and strdup().

Referenced by statement_insertion().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_declaring_statement()

static statement entity_to_declaring_statement ( entity  e, statement  top  )

static

returns the statement block declaring entity e among all thoses in top assumes the entity is declared locally c only

Definition at line 283 of file statement_insertion.c.

                                                                        {
    entity_to_declaring_statement_t param = { e, statement_undefined };
    if(formal_parameter_p(e))
        return top;
    else {
        gen_context_recurse(top,&param,statement_domain,gen_true2,entity_to_declaring_statement_aux);
        pips_assert("entity not a local entity ?",!statement_undefined_p(param.s));
        return param.s;
    }
}

References entity_to_declaring_statement_aux(), formal_parameter_p(), gen_context_recurse, gen_true2(), pips_assert, statement_domain, statement_undefined, and statement_undefined_p.

Referenced by do_array_expansion().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_declaring_statement_aux()

static void entity_to_declaring_statement_aux ( statement  s, entity_to_declaring_statement_t *  param  )

static

Definition at line 269 of file statement_insertion.c.

                                                                                                   {
    if(statement_block_p(s)) {
        if(entity_in_list_p(param->e,statement_declarations(s))) {
            param->s=s;
            gen_recurse_stop(0);
        }
    }
}

References entity_in_list_p(), gen_recurse_stop(), statement_block_p, and statement_declarations.

Referenced by entity_to_declaring_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

find_calls_to_function()

static list find_calls_to_function ( statement  in, entity  to  )

static

returns a list of call to to found in in

Definition at line 75 of file statement_insertion.c.

                                                           {
    entity_list_pair p = { to , NIL };
    gen_context_multi_recurse(in,&p,
      call_domain, gen_true2, find_calls_to_function_walker,
      statement_domain, gen_true2, find_calls_to_function_walker_in_declaration,
      NULL);
    return p.found;
}

References call_domain, find_calls_to_function_walker(), find_calls_to_function_walker_in_declaration(), entity_list_pair::found, gen_context_multi_recurse(), gen_true2(), NIL, and statement_domain.

Referenced by statement_insertion_fix_access_in_callers().

Here is the call graph for this function:

Here is the caller graph for this function:

find_calls_to_function_walker()

static void find_calls_to_function_walker ( call  c, entity_list_pair *  p  )

static

Definition at line 61 of file statement_insertion.c.

{
    if(same_entity_p(p->to,call_function(c)))
        p->found=CONS(CALL,c,p->found);
}

References CALL, call_function, CONS, entity_list_pair::found, same_entity_p(), and entity_list_pair::to.

Referenced by find_calls_to_function(), and find_calls_to_function_walker_in_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

find_calls_to_function_walker_in_declaration()

static void find_calls_to_function_walker_in_declaration ( statement  s, entity_list_pair *  p  )

static

Definition at line 67 of file statement_insertion.c.

{
    FOREACH(ENTITY,e,statement_declarations(s))
        if(value_expression_p(entity_initial(e)))
            gen_context_recurse(s,&p,call_domain,gen_true2,find_calls_to_function_walker);
}

References call_domain, ENTITY, entity_initial, find_calls_to_function_walker(), FOREACH, gen_context_recurse, gen_true2(), statement_declarations, and value_expression_p.

Referenced by find_calls_to_function().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_insertion()

bool statement_insertion

(

const char *

module_name

)

statement_insertion.c

init

do

validate

Parameters

module_name

odule_name

Definition at line 240 of file statement_insertion.c.

{
    /* init */
    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_REGIONS, module_name, true));
    set_proper_rw_effects((statement_effects)db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
    debug_on("STATEMENT_INSERTION_DEBUG_LEVEL");
 
    /* do */
    if(do_statement_insertion(get_current_module_statement()))
    {
        /* validate */
        module_reorder(get_current_module_statement());
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name,get_current_module_statement());
    }
 
    debug_off();
    reset_current_module_entity();
    reset_current_module_statement();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, do_statement_insertion(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and set_proper_rw_effects().

Here is the call graph for this function:

statement_insertion_fix_access()

static void statement_insertion_fix_access ( list  regions )

static

fixes statement declaration depending on region access

Definition at line 120 of file statement_insertion.c.

{
  VOLATILE_FOREACH(REGION, reg, regions)
  {
    reference r = region_any_reference(reg);
    entity e = reference_variable(r);
    if(formal_parameter_p(e)) {
      pips_user_warning("cannot change formal parameter with this version\n"
                        "try using inlining if possible\n");
      break;
    }
    list phis = expressions_to_entities(reference_indices(r));
    Psysteme dims_syst = entity_declaration_sc(e);
    Psysteme access_syst = region_system(reg);
 
    volatile Psysteme sr;
    CATCH(overflow_error)
    {
      pips_debug(1, "overflow error\n");
      return ;
    }
    TRY
    {
      sr = sc_cute_convex_hull(access_syst, dims_syst);
      sc_rm(dims_syst);
      sc_nredund(&sr);
      UNCATCH(overflow_error);
    }
    // if we reach this point, we are ready for backward translation
    // from vecteur to dimensions :)
    list new_dimensions = NIL;
    FOREACH(ENTITY,phi,phis)
    {
      Pcontrainte lower,upper;
      constraints_for_bounds(phi, &sc_inegalites(sr), &lower, &upper);
      if( !CONTRAINTE_UNDEFINED_P(lower) && !CONTRAINTE_UNDEFINED_P(upper))
      {
        expression elower = constraints_to_loop_bound(lower,phi,true,entity_intrinsic(DIVIDE_OPERATOR_NAME));
        expression eupper = constraints_to_loop_bound(upper,phi,false,entity_intrinsic(DIVIDE_OPERATOR_NAME));
        new_dimensions= CONS(DIMENSION,
                             make_dimension(elower,eupper,NIL),
                             new_dimensions);
      }
      else {
        pips_user_warning("failed to translate region\n");
      }
    }
    new_dimensions=gen_nreverse(new_dimensions);
    gen_full_free_list(variable_dimensions(type_variable(entity_type(e))));
    variable_dimensions(type_variable(entity_type(e)))=new_dimensions;
    gen_free_list(phis);
    // formal entites are a special case: the actual parameter
    // declaration must be changed too
 
    // currently disabled, see you later, aligator
    if(formal_parameter_p(e))
      statement_insertion_fix_access_in_callers(get_current_module_name(),e);
  }
}

References CATCH, CONS, constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED_P, DIMENSION, DIVIDE_OPERATOR_NAME, ENTITY, entity_declaration_sc(), entity_intrinsic(), entity_type, expressions_to_entities(), FOREACH, formal_parameter_p(), gen_free_list(), gen_full_free_list(), gen_nreverse(), get_current_module_name(), make_dimension(), NIL, overflow_error, pips_debug, pips_user_warning, reference_indices, reference_variable, REGION, region_any_reference, region_system, return(), sc_cute_convex_hull(), sc_rm(), statement_insertion_fix_access_in_callers(), TRY, type_variable, UNCATCH, variable_dimensions, and VOLATILE_FOREACH.

Referenced by do_statement_insertion().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_insertion_fix_access_in_callers()

static void statement_insertion_fix_access_in_callers ( const char *  module_name, entity  new_formal  )

static

tries hard to propagate entity dimension change

Definition at line 86 of file statement_insertion.c.

{
    callees callers = (callees)db_get_memory_resource(DBR_CALLERS, module_name,true);
    intptr_t new_formal_offset=formal_offset(storage_formal(entity_storage(new_formal)));
    size_t new_formal_dimensions=gen_length(variable_dimensions(type_variable(ultimate_type(entity_type(new_formal)))));
    FOREACH(STRING,caller_name,callees_callees(callers)) {
 
        statement caller_statement = (statement)db_get_memory_resource(DBR_CODE,caller_name,true);
        list calls = find_calls_to_function(caller_statement,module_name_to_entity(module_name));
        FOREACH(CALL,c,calls) {
            expression nth = EXPRESSION(gen_nth(new_formal_offset-1,call_arguments(c)));
            if(expression_reference_p(nth))
            {
                reference r = expression_reference(nth);
                size_t nb_indices = gen_length(reference_indices(r));
                size_t nb_dimensions = gen_length(variable_dimensions(type_variable(ultimate_type(entity_type(reference_variable(r))))));
                if(nb_dimensions - nb_indices == new_formal_dimensions)
                {
                    list *iter = &variable_dimensions(type_variable(ultimate_type(entity_type(reference_variable(r)))));
                    for(size_t i=1;i<nb_indices;i++) POP(*iter);
                    gen_full_free_list(*iter);
                    *iter=gen_full_copy_list(variable_dimensions(type_variable(ultimate_type(entity_type(new_formal)))));
                    statement_insertion_fix_access_in_callers(caller_name,reference_variable(r));
                }
                else pips_internal_error("unhandled case");
            }
            else pips_internal_error("unhandled case");
        }
        DB_PUT_MEMORY_RESOURCE(DBR_CODE,caller_name,caller_statement);
        gen_free_list(calls);
    }
}

References CALL, call_arguments, callees_callees, caller_name, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, entity_storage, entity_type, EXPRESSION, expression_reference(), expression_reference_p(), find_calls_to_function(), FOREACH, formal_offset, gen_free_list(), gen_full_copy_list(), gen_full_free_list(), gen_length(), gen_nth(), intptr_t, module_name(), module_name_to_entity(), pips_internal_error, POP, reference_indices, reference_variable, storage_formal, STRING, type_variable, ultimate_type(), and variable_dimensions.

Referenced by statement_insertion_fix_access().

Here is the call graph for this function:

Here is the caller graph for this function: