simplify.c File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "effects-util.h"
#include "misc.h"
#include "pipsdbm.h"
#include "resources.h"
#include "control.h"
#include "properties.h"
#include "expressions.h"

Include dependency graph for simplify.c:

Go to the source code of this file.

Data Structures
struct	entity_used_in_calls_p
struct	rfr_param
struct	dssrhp

Functions
static bool	has_address_of_operator_walker_p (call c, bool *panswer)
static bool	has_address_of_operator_p (expression exp)
	look for an & in the expression More...
static void	simplify_subscript (subscript ss)
	the walker More...
static void	do_simplify_subscripts (statement s)
bool	simplify_subscripts (const char *module_name)
	atomize subscript expressions so that thay can be reprsetned as references More...
static void	entity_used_in_calls_walker (call c, entity_used_in_calls_p *p)
static bool	entity_used_in_calls (entity e)
static void	replace_field_by_reference_walker (call c, rfr_param *p)
static void	replace_field_by_reference (entity structure, entity field, entity new)
static instruction	make_fields_assignment_instruction (entity var, list fields, list new_vars)
static void	do_split_structure_return_hook_walker (statement s, dssrhp *p)
static void	do_split_structure_return_hook (entity var, list fields, list new_vars)
static list	do_split_structure (entity e, statement s)
static void	do_split_structures (statement s)
static void	do_split_structure_parameter (entity e)
bool	split_structures (const char *module_name)
expression	make_float_constant_expression (float)
static void	set_the_i ()
static void	reset_the_i ()
void	complex_translation_array_of_structs (list *pl, list l)
void	complex_translation_struct_of_array (list *pl, list l)
static void	set_translation_mode ()
static void	reset_translation_mode ()
static void	simplify_complex_entity (entity c)
	adds a dimension to all entity whose basic is complex , and change their basic to float More...
static void	simplify_complex_declaration (entity e)
static expression	split_complex_expression (expression e)
static bool	simplify_complex_expression (expression e)
static void	simplify_complex_statements (statement s)
bool	simplify_complex (const char *module_name)
	split complexes into an array with first element <> real part and second element <> imaginary part More...
static void	do_simplify_c_operator (call c)
void	simplify_c_operator (statement s)
	replace PLUS_C_OPERATOR_NAME by PLUS_OPERATOR_NAME when relevant More...
static void	do_simplify_constant_address_expression (expression exp)
	perform constant string dereferencing evaluation More...
static void	do_simplify_constant_address_expression_in_decl (statement st)
	forward processing through declarations More...
bool	simplify_constant_address_expressions (const char *module_name)
	transforms *"aer" into 'a' do not take care of "aer"[2] but could be extended to More...

Variables
static entity	THE_I = entity_undefined
static void(*	complex_translation )(list *, list) =NULL

Function Documentation

complex_translation_array_of_structs()

void complex_translation_array_of_structs	(	list *	pl,
		list	l
	)

Parameters

pl

l

Definition at line 412 of file simplify.c.

{
    gen_append(*pl,l);
}

References gen_append(), and pl.

Referenced by set_translation_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

complex_translation_struct_of_array()

void complex_translation_struct_of_array	(	list *	pl,
		list	l
	)

Parameters

pl

l

Definition at line 416 of file simplify.c.

{
    gen_append(l,*pl);
    *pl=l;
}

References gen_append(), and pl.

Referenced by set_translation_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

do_simplify_c_operator()

static void do_simplify_c_operator ( call  c )

static

Definition at line 604 of file simplify.c.

{
  entity op =call_function(c);
  if(ENTITY_PLUS_C_P(op)||ENTITY_MINUS_C_P(op)) {
    expression lhs = binary_call_lhs(c);
    expression rhs = binary_call_rhs(c);
    basic blhs = basic_of_expression(lhs);
    basic brhs = basic_of_expression(rhs);
    if(!basic_pointer_p(blhs) && ! basic_pointer_p(brhs))
      call_function(c) = entity_intrinsic(
          ENTITY_PLUS_C_P(op)?PLUS_OPERATOR_NAME:MINUS_OPERATOR_NAME);
    free_basic(blhs);
    free_basic(brhs);
  }
}

References basic_of_expression(), basic_pointer_p, binary_call_lhs, binary_call_rhs, call_function, entity_intrinsic(), ENTITY_MINUS_C_P, ENTITY_PLUS_C_P, free_basic(), MINUS_OPERATOR_NAME, and PLUS_OPERATOR_NAME.

Referenced by simplify_c_operator().

Here is the call graph for this function:

Here is the caller graph for this function:

do_simplify_constant_address_expression()

static void do_simplify_constant_address_expression ( expression  exp )

static

perform constant string dereferencing evaluation

Definition at line 626 of file simplify.c.

                                                                    {
    if(expression_call_p(exp)) {
        call c =expression_call(exp);
        entity operator = call_function(c);
        list args = call_arguments(c);
        if(ENTITY_DEREFERENCING_P(operator)) {
            expression arg = EXPRESSION(CAR(args));
            if(expression_string_constant_p(arg)) {
                char * string_constant = expression_string_constant(arg);
                char buf[] = { '\'', *string_constant, '\'', 0 };
                expression character_constant  = MakeCharacterConstantExpression(strdup(buf));
                update_expression_syntax(exp,expression_syntax(character_constant));
                expression_syntax(character_constant)=syntax_undefined;
                free(string_constant);
                free_expression(character_constant);
            }
        }
    }
}

References buf, call_arguments, call_function, CAR, ENTITY_DEREFERENCING_P, exp, EXPRESSION, expression_call(), expression_call_p(), expression_string_constant(), expression_string_constant_p(), expression_syntax, free(), free_expression(), MakeCharacterConstantExpression(), strdup(), syntax_undefined, and update_expression_syntax().

Referenced by do_simplify_constant_address_expression_in_decl(), and simplify_constant_address_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

do_simplify_constant_address_expression_in_decl()

static void do_simplify_constant_address_expression_in_decl ( statement  st )

static

forward processing through declarations

Definition at line 647 of file simplify.c.

                                                                          {
    if(declaration_statement_p(st)) {
        FOREACH(ENTITY,e,statement_declarations(st))
            gen_recurse(entity_initial(e),expression_domain, gen_true, do_simplify_constant_address_expression);
    }
}

References declaration_statement_p(), do_simplify_constant_address_expression(), ENTITY, entity_initial, expression_domain, FOREACH, gen_recurse, gen_true(), and statement_declarations.

Referenced by simplify_constant_address_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

do_simplify_subscripts()

static void do_simplify_subscripts ( statement  s )

static

Definition at line 57 of file simplify.c.

                                                {
    gen_recurse(s,
            subscript_domain,gen_true,simplify_subscript);
    statement_consistent_p(s);
}

References gen_recurse, gen_true(), simplify_subscript(), statement_consistent_p(), and subscript_domain.

Referenced by simplify_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

do_split_structure()

static list do_split_structure ( entity  e, statement  s  )

static

we copied the field storage, that is rom, recompute a ram storage

then take car of initial value if any

hook: handle returns as a special case

Definition at line 256 of file simplify.c.

{
    list added = NIL;
    if(entity_variable_p(e) )
    {
        type t = ultimate_type(entity_type(e));
        if(( type_struct_variable_p(t) || type_pointer_on_struct_variable_p(t)) &&
                !entity_used_in_calls(e))
        {
            list fields = type_struct_variable_p(t)?
                type_struct(entity_type(basic_derived(variable_basic(type_variable(t))))):
                type_struct(entity_type(basic_derived(variable_basic(type_variable(ultimate_type(basic_pointer(variable_basic(type_variable(t)))))))));
            list inits = value_expression_p(entity_initial(e)) ?
                call_arguments(expression_call(value_expression(entity_initial(e)))):
                NIL;
            FOREACH(ENTITY,f,fields)
            {
                expression init = ENDP(inits)?expression_undefined:EXPRESSION(CAR(inits));
                string new_name = strdup(entity_name(f));
                for(string found = strchr(new_name,MEMBER_SEP_CHAR);found;found = strchr(new_name,MEMBER_SEP_CHAR))
                    *found='_';
                entity new = make_entity_copy_with_new_name(f,new_name,false);
                free(new_name);
                /* we copied the field storage, that is rom, recompute a ram storage */
                free_storage(entity_storage(new));
                entity dyn_area = FindEntity(get_current_module_name(), DYNAMIC_AREA_LOCAL_NAME); 
                entity_storage(new) = 
                    make_storage_ram(
                            make_ram(get_current_module_entity(), dyn_area,
                                (basic_overloaded_p(entity_basic(new))?0:add_variable_to_area(dyn_area,new)),
                                NIL));
                /* then take car of initial value if any */
                if(formal_parameter_p(e))
                {
                if(entity_scalar_p(new))
                    entity_initial(new)=
                        make_value_expression(
                                MakeBinaryCall(
                                    entity_intrinsic(type_struct_variable_p(t)?FIELD_OPERATOR_NAME:POINT_TO_OPERATOR_NAME),
                                    entity_to_expression(e),
                                    entity_to_expression(f)
                                    )
                                );
                else
                    insert_statement(s,
                            instruction_to_statement(
                                make_call_instruction(
                                    entity_intrinsic(MEMCPY_FUNCTION_NAME),
                                    make_expression_list(
                                        entity_to_expression(new),
                                        entity_to_expression(f),
                                        make_expression(
                                            make_syntax_sizeofexpression(make_sizeofexpression_expression(entity_to_expression(new))),
                                            normalized_undefined)
                                        )
                                    )
                                ),
                            true
                            );
                }
                else
                    entity_initial(new)=expression_undefined_p(init)?
                        make_value_unknown():
                        make_value_expression(copy_expression(init));
                replace_field_by_reference(e,f,new);
                added=CONS(ENTITY,new,added);
                if(!ENDP(inits)) POP(inits);
            }
            added=gen_nreverse(added);
            if(value_expression_p(entity_initial(e)))
            {
                free_value(entity_initial(e));
                entity_initial(e)=make_value_unknown();
            }
            /* hook: handle returns as a special case */
            do_split_structure_return_hook(e,fields,added);
        }
    }
    return added;
}

References add_variable_to_area(), basic_derived, basic_overloaded_p, basic_pointer, call_arguments, CAR, CONS, copy_expression(), do_split_structure_return_hook(), DYNAMIC_AREA_LOCAL_NAME, ENDP, ENTITY, entity_basic(), entity_initial, entity_intrinsic(), entity_name, entity_scalar_p(), entity_storage, entity_to_expression(), entity_type, entity_used_in_calls(), entity_variable_p, EXPRESSION, expression_call(), expression_undefined, expression_undefined_p, f(), FIELD_OPERATOR_NAME, FindEntity(), FOREACH, formal_parameter_p(), free(), free_storage(), free_value(), gen_nreverse(), get_current_module_entity(), get_current_module_name(), init, insert_statement(), instruction_to_statement(), make_call_instruction(), make_entity_copy_with_new_name(), make_expression(), make_expression_list, make_ram(), make_sizeofexpression_expression(), make_storage_ram(), make_syntax_sizeofexpression(), make_value_expression(), make_value_unknown(), MakeBinaryCall(), MEMBER_SEP_CHAR, MEMCPY_FUNCTION_NAME, NIL, normalized_undefined, POINT_TO_OPERATOR_NAME, POP, replace_field_by_reference(), strdup(), type_pointer_on_struct_variable_p(), type_struct, type_struct_variable_p(), type_variable, ultimate_type(), value_expression, value_expression_p, and variable_basic.

Referenced by do_split_structure_parameter(), and do_split_structures().

Here is the call graph for this function:

Here is the caller graph for this function:

do_split_structure_parameter()

static void do_split_structure_parameter ( entity  e )

static

Definition at line 357 of file simplify.c.

{
    list added = do_split_structure(e,get_current_module_statement());
    FOREACH(ENTITY,e,added)
        AddEntityToCurrentModule(e);
    gen_free_list(added);
}

References AddEntityToCurrentModule(), do_split_structure(), ENTITY, FOREACH, gen_free_list(), and get_current_module_statement().

Referenced by split_structures().

Here is the call graph for this function:

Here is the caller graph for this function:

do_split_structure_return_hook()

static void do_split_structure_return_hook ( entity  var, list  fields, list  new_vars  )

static

also add a 'set all' operation at end ob block

Definition at line 239 of file simplify.c.

{
    pips_assert("as many new vars as fields\n",gen_length(fields)==gen_length(new_vars));
    dssrhp p = { var, fields, new_vars };
    gen_context_recurse(get_current_module_statement(), &p,
            statement_domain, gen_true2, do_split_structure_return_hook_walker);
    /* also add a 'set all' operation at end ob block */
    if(formal_parameter_p(var))
    {
        instruction fields_update = make_fields_assignment_instruction(var,fields,new_vars);
        insert_statement(get_current_module_statement(),instruction_to_statement(fields_update),false);
    }
 
}

References do_split_structure_return_hook_walker(), formal_parameter_p(), gen_context_recurse, gen_length(), gen_true2(), get_current_module_statement(), insert_statement(), instruction_to_statement(), make_fields_assignment_instruction(), pips_assert, and statement_domain.

Referenced by do_split_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

do_split_structure_return_hook_walker()

static void do_split_structure_return_hook_walker ( statement  s, dssrhp *  p  )

static

we return the same reference as the initial variable, update fields accordingly

Definition at line 215 of file simplify.c.

{
    if(return_statement_p(s))
    {
        instruction i = statement_instruction(s);
        expression returned = 
            EXPRESSION(CAR(call_arguments(
                        instruction_call_p(i)?
                        instruction_call(i):
                        expression_call(instruction_expression(i))
                        )));
        /* we return the same reference as the initial variable, update fields accordingly */
        if(expression_reference_p(returned) &&
                same_entity_p(reference_variable(expression_reference(returned)),p->var))
        {
            instruction fields_update = make_fields_assignment_instruction(p->var,p->fields,p->new_vars);
            insert_statement(s,instruction_to_statement(fields_update),true);
 
        }
            
    }
}

References call_arguments, CAR, EXPRESSION, expression_call(), expression_reference(), expression_reference_p(), dssrhp::fields, insert_statement(), instruction_call, instruction_call_p, instruction_expression, instruction_to_statement(), make_fields_assignment_instruction(), dssrhp::new_vars, reference_variable, return_statement_p(), same_entity_p(), statement_instruction, and dssrhp::var.

Referenced by do_split_structure_return_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

do_split_structures()

static void do_split_structures ( statement  s )

static

Definition at line 339 of file simplify.c.

{
    if(statement_block_p(s))
    {
        list added = NIL;
        FOREACH(ENTITY,e,statement_declarations(s))
        {
            list new = do_split_structure(e,s);
            added=gen_nconc(added,new);
        }
        FOREACH(ENTITY,e,added)
            AddLocalEntityToDeclarations(e,get_current_module_entity(),s);
        gen_free_list(added);
    }
 
}

References AddLocalEntityToDeclarations(), do_split_structure(), ENTITY, FOREACH, gen_free_list(), gen_nconc(), get_current_module_entity(), NIL, statement_block_p, and statement_declarations.

Referenced by split_structures().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_used_in_calls()

static bool entity_used_in_calls ( entity  e )

static

Definition at line 118 of file simplify.c.

{
    entity_used_in_calls_p p = { e, false};
    gen_context_recurse(get_current_module_statement(),&p,call_domain,gen_true2,entity_used_in_calls_walker);
    return p.used;
}

References call_domain, entity_used_in_calls_walker(), gen_context_recurse, gen_true2(), get_current_module_statement(), and entity_used_in_calls_p::used.

Referenced by do_split_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_used_in_calls_walker()

static void entity_used_in_calls_walker ( call  c, entity_used_in_calls_p *  p  )

static

SG: as a special extension, we allow return call for it is handled elsewhere

Definition at line 94 of file simplify.c.

{
    entity op = call_function(c);
    if(!ENTITY_FIELD_P(op)&&!ENTITY_POINT_TO_P(op))
    {
        FOREACH(EXPRESSION,exp,call_arguments(c))
        {
            if(expression_reference_p(exp) && same_entity_p(reference_variable(expression_reference(exp)),p->e) )
            {
                p->used=true;
            }
        }
        /* SG: as a special extension, we allow return call
         * for it is handled elsewhere*/
        if(p->used) {
            if(ENTITY_RETURN_P(op)||ENTITY_C_RETURN_P(op))
                p->used=false;
            else
                gen_recurse_stop(0);
        }
    }
}

References call_arguments, call_function, entity_used_in_calls_p::e, ENTITY_C_RETURN_P, ENTITY_FIELD_P, ENTITY_POINT_TO_P, ENTITY_RETURN_P, exp, EXPRESSION, expression_reference(), expression_reference_p(), FOREACH, gen_recurse_stop(), reference_variable, same_entity_p(), and entity_used_in_calls_p::used.

Referenced by entity_used_in_calls().

Here is the call graph for this function:

Here is the caller graph for this function:

has_address_of_operator_p()

static bool has_address_of_operator_p ( expression  exp )

static

look for an & in the expression

Definition at line 24 of file simplify.c.

{
    bool answer = false;
    gen_context_recurse(exp,&answer,call_domain,has_address_of_operator_walker_p,gen_null2);
    return answer;
}

References call_domain, exp, gen_context_recurse, gen_null2(), and has_address_of_operator_walker_p().

Referenced by simplify_subscript().

Here is the call graph for this function:

Here is the caller graph for this function:

has_address_of_operator_walker_p()

static bool has_address_of_operator_walker_p ( call  c, bool *  panswer  )

static

Definition at line 18 of file simplify.c.

{
    return !(*panswer|=ENTITY_ADDRESS_OF_P(call_function(c)));
}

References call_function, and ENTITY_ADDRESS_OF_P.

Referenced by has_address_of_operator_p().

Here is the caller graph for this function:

make_fields_assignment_instruction()

static instruction make_fields_assignment_instruction ( entity  var, list  fields, list  new_vars  )

static

this makes e.f

his makes udpated value of the fields

Definition at line 174 of file simplify.c.

{
    list fields_update = NIL;
    FOREACH(ENTITY,nv,new_vars)
    {
        entity f = ENTITY(CAR(fields));
        fields_update=CONS(STATEMENT,
                entity_scalar_p(nv) ?
                make_assign_statement(
                    MakeBinaryCall(
                        entity_intrinsic(type_struct_variable_p(entity_type(var))?FIELD_OPERATOR_NAME:POINT_TO_OPERATOR_NAME),
                        entity_to_expression(var),
                        entity_to_expression(f)
                        )
                    ,/* this makes e.f */
                    entity_to_expression(nv)/*this makes udpated value of the fields */
                    ):
                instruction_to_statement(
                    make_call_instruction(
                        entity_intrinsic(MEMCPY_FUNCTION_NAME),
                        make_expression_list(
                            MakeBinaryCall(
                                entity_intrinsic(type_struct_variable_p(entity_type(var))?FIELD_OPERATOR_NAME:POINT_TO_OPERATOR_NAME),
                                entity_to_expression(var),
                                entity_to_expression(f)
                                ),
                            entity_to_expression(nv),
                            make_expression(
                                make_syntax_sizeofexpression(make_sizeofexpression_expression(entity_to_expression(nv))),
                                normalized_undefined)
                            )
                        )
                    ),
                fields_update
                    );
        POP(fields);
    }
    return make_instruction_sequence(make_sequence(gen_nreverse(fields_update)));
}

References CAR, CONS, ENTITY, entity_intrinsic(), entity_scalar_p(), entity_to_expression(), entity_type, f(), FIELD_OPERATOR_NAME, FOREACH, gen_nreverse(), instruction_to_statement(), make_assign_statement(), make_call_instruction(), make_expression(), make_expression_list, make_instruction_sequence(), make_sequence(), make_sizeofexpression_expression(), make_syntax_sizeofexpression(), MakeBinaryCall(), MEMCPY_FUNCTION_NAME, NIL, normalized_undefined, POINT_TO_OPERATOR_NAME, POP, STATEMENT, and type_struct_variable_p().

Referenced by do_split_structure_return_hook(), and do_split_structure_return_hook_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

make_float_constant_expression()

expression make_float_constant_expression

(

float

)

replace_field_by_reference()

static void replace_field_by_reference ( entity  structure, entity  field, entity  new  )

static

Definition at line 161 of file simplify.c.

{
    rfr_param p = { structure, field,new };
    gen_context_recurse(get_current_module_statement(),&p,call_domain,gen_true2,replace_field_by_reference_walker);
}

References call_domain, gen_context_recurse, gen_true2(), get_current_module_statement(), and replace_field_by_reference_walker().

Referenced by do_split_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_field_by_reference_walker()

static void replace_field_by_reference_walker ( call  c, rfr_param *  p  )

static

Definition at line 132 of file simplify.c.

{
    entity op = call_function(c);
    if(ENTITY_POINT_TO_P(op) || ENTITY_FIELD_P(op))
    {
        expression lhs = binary_call_lhs(c);
        expression rhs = binary_call_rhs(c);
        if(expression_reference_p(lhs) && same_entity_p(reference_variable(expression_reference(lhs)),p->structure) &&
                expression_reference_p(rhs) && same_entity_p(reference_variable(expression_reference(rhs)),p->field) )
        {
            gen_chunk *ancestor = gen_get_recurse_ancestor(c);
            if(INSTANCE_OF(syntax,ancestor))
            {
                free_call(c);
                syntax s = (syntax)ancestor;
                syntax_tag(s) = is_syntax_reference;
                syntax_reference(s)=make_reference(p->new,NIL);
            }
            else
            {
                call_function(c)=entity_intrinsic(UNARY_PLUS_OPERATOR_NAME);
                gen_full_free_list(call_arguments(c));
                call_arguments(c)=make_expression_list(entity_to_expression(p->new));
            }
        }
    }
}

References binary_call_lhs, binary_call_rhs, call_arguments, call_function, ENTITY_FIELD_P, entity_intrinsic(), ENTITY_POINT_TO_P, entity_to_expression(), expression_reference(), expression_reference_p(), rfr_param::field, free_call(), gen_full_free_list(), gen_get_recurse_ancestor(), INSTANCE_OF, is_syntax_reference, make_expression_list, make_reference(), rfr_param::new, NIL, reference_variable, same_entity_p(), rfr_param::structure, syntax_reference, syntax_tag, and UNARY_PLUS_OPERATOR_NAME.

Referenced by replace_field_by_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_the_i()

static void reset_the_i ( )

static

Definition at line 407 of file simplify.c.

                          {
    THE_I = entity_undefined;
}

References entity_undefined, and THE_I.

Referenced by simplify_complex().

Here is the caller graph for this function:

reset_translation_mode()

static void reset_translation_mode ( )

static

Definition at line 429 of file simplify.c.

{ complex_translation=NULL;}

References complex_translation.

Referenced by simplify_complex().

Here is the caller graph for this function:

set_the_i()

static void set_the_i ( )

static

Definition at line 400 of file simplify.c.

                        {
    THE_I = make_new_scalar_variable_with_prefix("IM",get_current_module_entity(), make_basic_complex(DEFAULT_COMPLEX_TYPE_SIZE));
    free_value(entity_initial(THE_I));
    entity_initial(THE_I)=make_value_expression(MakeComplexConstantExpression(float_to_expression(0),float_to_expression(1)));
    AddEntityToCurrentModule(THE_I);
}

References AddEntityToCurrentModule(), DEFAULT_COMPLEX_TYPE_SIZE, entity_initial, float_to_expression(), free_value(), get_current_module_entity(), make_basic_complex(), make_new_scalar_variable_with_prefix(), make_value_expression(), MakeComplexConstantExpression(), and THE_I.

Referenced by simplify_complex().

Here is the call graph for this function:

Here is the caller graph for this function:

set_translation_mode()

static void set_translation_mode ( )

static

Definition at line 422 of file simplify.c.

{
    if(get_bool_property("SIMPLIFY_COMPLEX_USE_ARRAY_OF_STRUCTS"))
        complex_translation=complex_translation_array_of_structs;
    else
        complex_translation=complex_translation_struct_of_array;
}

References complex_translation, complex_translation_array_of_structs(), complex_translation_struct_of_array(), and get_bool_property().

Referenced by simplify_complex().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_c_operator()

void simplify_c_operator

(

statement

s

)

replace PLUS_C_OPERATOR_NAME by PLUS_OPERATOR_NAME when relevant

Definition at line 621 of file simplify.c.

                                      {
  gen_recurse(s,call_domain,gen_true, do_simplify_c_operator);
}

References call_domain, do_simplify_c_operator(), gen_recurse, and gen_true().

Referenced by reduction_propagation().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_complex()

bool simplify_complex

(

const char *

module_name

)

split complexes into an array with first element <> real part and second element <> imaginary part

prelude

change call to complex intrinsics

change other complex references

and all their declarations

validate

ostlude

Parameters

module_name

odule_name

Definition at line 578 of file simplify.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_the_i();
    set_translation_mode();
 
    /* change call to complex intrinsics */
    /* change other complex references*/
    simplify_complex_statements(get_current_module_statement());
    /* and all their declarations */
    simplify_complex_declaration(get_current_module_entity());
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
    /*postlude*/
    reset_translation_mode();
    reset_the_i();
    reset_current_module_entity();
    reset_current_module_statement();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, get_current_module_entity(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), reset_the_i(), reset_translation_mode(), set_current_module_entity(), set_current_module_statement(), set_the_i(), set_translation_mode(), simplify_complex_declaration(), and simplify_complex_statements().

Here is the call graph for this function:

simplify_complex_declaration()

static void simplify_complex_declaration ( entity  e )

static

Definition at line 451 of file simplify.c.

{
    FOREACH(ENTITY,c,entity_declarations(e))
        simplify_complex_entity(c);
    FOREACH(ENTITY,c,code_declarations(value_code(entity_initial(e))))
        simplify_complex_entity(c);
    FOREACH(PARAMETER,p,module_functional_parameters(e))
    {
        dummy d = parameter_dummy(p);
        if(dummy_identifier_p(d))
            simplify_complex_entity(dummy_identifier(d));
    }
    free(code_decls_text(entity_code(e)));
    code_decls_text(entity_code(e))=strdup("");
}

References code_declarations, code_decls_text, dummy_identifier, dummy_identifier_p, ENTITY, entity_code(), entity_declarations, entity_initial, FOREACH, free(), module_functional_parameters, PARAMETER, parameter_dummy, simplify_complex_entity(), strdup(), and value_code.

Referenced by simplify_complex().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_complex_entity()

static void simplify_complex_entity ( entity  c )

static

adds a dimension to all entity whose basic is complex , and change their basic to float

Definition at line 433 of file simplify.c.

{
    if(entity_variable_p(c) && basic_complex_p(entity_basic(c)))
    {
        variable v = type_variable(entity_type(c));
        complex_translation(
                &variable_dimensions(v),
                CONS(DIMENSION,
                     make_dimension(int_to_expression(0),
                                    int_to_expression(1),
                                    NIL),
                     NIL)
                );
        intptr_t old_basic = basic_complex(variable_basic(v));
        free_basic(variable_basic(v));
        variable_basic(v)=make_basic_float(old_basic);
    }
}

References basic_complex, basic_complex_p, complex_translation, CONS, DIMENSION, entity_basic(), entity_type, entity_variable_p, free_basic(), int_to_expression(), intptr_t, make_basic_float(), make_dimension(), NIL, type_variable, variable_basic, and variable_dimensions.

Referenced by simplify_complex_declaration().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_complex_expression()

static bool simplify_complex_expression ( expression  e )

static

replace |.| by sqrt(re^2+im^2)

replace REAL(.) by .[0]

ok let's do something

replace the call by a reference

replace AIMAG(.) by .[1]

ok let's do something

replace the call by a reference

more to come

Definition at line 489 of file simplify.c.

{
    basic b = basic_of_expression(e);
    if(expression_call_p(e))
    {
        call c = expression_call(e);
        entity op = call_function(c);
        expression arg = ENDP(call_arguments(c))?expression_undefined:EXPRESSION(CAR(call_arguments(c)));
        /* replace |.| by sqrt(re^2+im^2) */
        if(ENTITY_CABS_P(op))
        {
            call_function(c)=CreateIntrinsic(SQRT_OPERATOR_NAME);
            gen_free_list(call_arguments(c));
            call_arguments(c)=make_expression_list(
                    MakeBinaryCall(CreateIntrinsic(PLUS_OPERATOR_NAME),
                        MakeUnaryCall(CreateIntrinsic(REAL_GENERIC_CONVERSION_NAME),copy_expression(arg)),
                        MakeUnaryCall(CreateIntrinsic(AIMAG_CONVERSION_NAME),arg)
                        )
                    );
        }
        /* replace REAL(.) by .[0] */
        else if(same_entity_p( op, CreateIntrinsic(REAL_GENERIC_CONVERSION_NAME) ))
        {
            if(expression_reference_p(arg)) /* ok let's do something */
            {
                reference r = expression_reference(arg);
                complex_translation(&reference_indices(r),make_expression_list(int_to_expression(0)));
                /* replace the call by a reference */
                syntax_reference(expression_syntax(arg))=reference_undefined;
                free_syntax(expression_syntax(e));
                free_normalized(expression_normalized(e));
                expression_syntax(e)=make_syntax_reference(r);
                expression_normalized(e)=normalized_undefined;
            }
            else
                pips_user_warning("case unhandled, this would require an atomization in fortran i guess\n");
        }
        /* replace AIMAG(.) by .[1] */
        else if(same_entity_p( op, CreateIntrinsic(AIMAG_CONVERSION_NAME) ))
        {
            if(expression_reference_p(arg)) /* ok let's do something */
            {
                reference r = expression_reference(arg);
                complex_translation(&reference_indices(r),make_expression_list(int_to_expression(1)));
                /* replace the call by a reference */
                syntax_reference(expression_syntax(arg))=reference_undefined;
                free_syntax(expression_syntax(e));
                free_normalized(expression_normalized(e));
                expression_syntax(e)=make_syntax_reference(r);
                expression_normalized(e)=normalized_undefined;
            }
            else
                pips_user_warning("case unhandled, this would require an atomization in fortran i guess\n");
        }
        else if(basic_complex_p(b) && ENTITY_FIVE_OPERATION_P(op) )
        {
            expression e0 = binary_call_lhs(c),
                       e1 = binary_call_rhs(c);
            basic b0 = basic_of_expression(e0),
                  b1=basic_of_expression(e1);
            if(basic_complex_p(b0) && expression_reference_p(e0))
            {
                *e0=*split_complex_expression(e0);
                gen_recurse_stop(e0);
            }
            if(basic_complex_p(b1) && expression_reference_p(e1))
            {
                *e1=*split_complex_expression(e1);
                gen_recurse_stop(e1);
            }
            free_basic(b0);
            free_basic(b1);
 
        }
    }
    free_basic(b);
    /* more to come */
    return true;
 
}

References AIMAG_CONVERSION_NAME, b1, basic_complex_p, basic_of_expression(), binary_call_lhs, binary_call_rhs, call_arguments, call_function, CAR, complex_translation, copy_expression(), CreateIntrinsic(), ENDP, ENTITY_CABS_P, ENTITY_FIVE_OPERATION_P, EXPRESSION, expression_call(), expression_call_p(), expression_normalized, expression_reference(), expression_reference_p(), expression_syntax, expression_undefined, free_basic(), free_normalized(), free_syntax(), gen_free_list(), gen_recurse_stop(), int_to_expression(), make_expression_list, make_syntax_reference(), MakeBinaryCall(), MakeUnaryCall(), normalized_undefined, pips_user_warning, PLUS_OPERATOR_NAME, REAL_GENERIC_CONVERSION_NAME, reference_indices, reference_undefined, same_entity_p(), split_complex_expression(), SQRT_OPERATOR_NAME, and syntax_reference.

Referenced by simplify_complex_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_complex_statements()

static void simplify_complex_statements ( statement  s )

static

do the job

Definition at line 571 of file simplify.c.

{
    /* do the job */
    gen_recurse(s,expression_domain,simplify_complex_expression,gen_null);
}

References expression_domain, gen_null(), gen_recurse, and simplify_complex_expression().

Referenced by simplify_complex().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_constant_address_expressions()

bool simplify_constant_address_expressions

(

const char *

module_name

)

transforms *"aer" into 'a' do not take care of "aer"[2] but could be extended to

Parameters

module_name

odule_name

Definition at line 657 of file simplify.c.

                                                                    {
    set_current_module_entity(module_name_to_entity( module_name ));
    set_current_module_statement((statement) db_get_memory_resource(DBR_CODE, module_name, true) );
 
    gen_multi_recurse(get_current_module_statement(),
            expression_domain, gen_true, do_simplify_constant_address_expression,
            statement_domain, gen_true, do_simplify_constant_address_expression_in_decl,
            0
            );
    reset_current_module_entity();
    reset_current_module_statement();
    return true;
}

References db_get_memory_resource(), do_simplify_constant_address_expression(), do_simplify_constant_address_expression_in_decl(), expression_domain, gen_multi_recurse(), gen_true(), get_current_module_statement(), module_name(), module_name_to_entity(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

simplify_subscript()

static void simplify_subscript ( subscript  ss )

static

the walker

do nothing if an address-of is involved - over cautious indeed

create atomized_expression

create replacement reference

do the replacement

ree stuffs a bit less carefully than I should

we must do this now and not before

Definition at line 32 of file simplify.c.

{
    statement parent_statement = (statement)gen_get_ancestor(statement_domain,ss);
    expression ss_array = subscript_array(ss);
    /* do nothing if an address-of is involved - over cautious indeed */
    if( !has_address_of_operator_p(ss_array) )
    {
        /* create atomized_expression */
        basic exp_basic = basic_of_expression(ss_array);
        entity new_entity = make_new_scalar_variable(get_current_module_entity(),exp_basic);
        AddEntityToCurrentModule(new_entity);
        statement new_statement = make_assign_statement(entity_to_expression(new_entity),ss_array);
 
        /* create replacement reference */
        reference new_ref= make_reference(new_entity,subscript_indices(ss));
        /* do the replacement */
        expression parent_expression = (expression) gen_get_ancestor(expression_domain,ss);
        /*free stuffs a bit less carefully than I should*/
        expression_syntax(parent_expression)=syntax_undefined;
        update_expression_syntax(parent_expression,make_syntax_reference(new_ref));
        /* we must do this now and not before */
        insert_statement(parent_statement,new_statement,true);
    }
}

References AddEntityToCurrentModule(), basic_of_expression(), entity_to_expression(), expression_domain, expression_syntax, gen_get_ancestor(), get_current_module_entity(), has_address_of_operator_p(), insert_statement(), make_assign_statement(), make_new_scalar_variable(), make_reference(), make_syntax_reference(), statement_domain, subscript_array, subscript_indices, syntax_undefined, and update_expression_syntax().

Referenced by do_simplify_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_subscripts()

bool simplify_subscripts

(

const char *

module_name

)

atomize subscript expressions so that thay can be reprsetned as references

simplify.c

prelude

do the job

validate

ostlude

Parameters

module_name

odule_name

Definition at line 64 of file simplify.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) );
 
    /* do the job */
    do_simplify_subscripts(get_current_module_statement());
 
    /* 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();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_simplify_subscripts(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), and set_current_module_statement().

Here is the call graph for this function:

split_complex_expression()

static expression split_complex_expression ( expression  e )

static

Definition at line 467 of file simplify.c.

{
    reference r = expression_reference(e);
    list ri = reference_indices(r);
 
    list ri0 = gen_full_copy_list(ri);
    complex_translation(&ri0,make_expression_list(int_to_expression(0)));
    list ri1 = gen_full_copy_list(ri);
    complex_translation(&ri1,make_expression_list(int_to_expression(1)));
 
    expression new = MakeBinaryCall(
            CreateIntrinsic(PLUS_OPERATOR_NAME),
            reference_to_expression(make_reference(reference_variable(r),ri0)),
            MakeBinaryCall(
                CreateIntrinsic(MULTIPLY_OPERATOR_NAME),
                entity_to_expression(THE_I),
                reference_to_expression(make_reference(reference_variable(r),ri1))
                )
            );
    return new;
}

References complex_translation, CreateIntrinsic(), entity_to_expression(), expression_reference(), gen_full_copy_list(), int_to_expression(), make_expression_list, make_reference(), MakeBinaryCall(), MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, reference_indices, reference_to_expression(), reference_variable, and THE_I.

Referenced by simplify_complex_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

split_structures()

bool split_structures

(

const char *

module_name

)

prelude

do the job for declared structures

now do the job for parameter structures

change useless subscripts

validate

ostlude

Parameters

module_name

odule_name

Definition at line 365 of file simplify.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) );
 
    /* do the job for declared structures */
    gen_recurse(get_current_module_statement(),
            statement_domain,gen_true,do_split_structures);
    /* now do the job for parameter structures */
    FOREACH(ENTITY,e,entity_declarations(get_current_module_entity()))
        if(formal_parameter_p(e))
            do_split_structure_parameter(e);
 
    /* change useless subscripts */
    cleanup_subscripts(get_current_module_statement());
 
    /* 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();
    return true;
}

References cleanup_subscripts(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_split_structure_parameter(), do_split_structures(), ENTITY, entity_declarations, FOREACH, formal_parameter_p(), gen_recurse, gen_true(), get_current_module_entity(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

Variable Documentation

complex_translation

void(* complex_translation) (list *, list) ( list *  , list    ) =NULL

static

Definition at line 411 of file simplify.c.

Referenced by reset_translation_mode(), set_translation_mode(), simplify_complex_entity(), simplify_complex_expression(), and split_complex_expression().

THE_I

entity THE_I = entity_undefined

static

Definition at line 399 of file simplify.c.

Referenced by reset_the_i(), set_the_i(), and split_complex_expression().