declarations.c File Reference

#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "pipsdbm.h"
#include "misc.h"
#include "properties.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "effects-util.h"
#include "effects-generic.h"
#include "control.h"
#include "transformations.h"

Include dependency graph for declarations.c:

Go to the source code of this file.

Data Structures
struct	entity_used_somewhere_param

Functions
static void	remove_unread_variable (statement s, entity e)
static bool	entity_may_conflict_with_a_formal_parameter_p (entity e, entity module)
static void	entity_used_somewhere_walker (statement s, entity_used_somewhere_param *p)
static bool	entity_read_somewhere_p (entity e, statement in)
static void	remove_unread_variables (statement s)
void	module_clean_declarations (entity module, statement module_statement)
	declarations.c More...
bool	clean_declarations (const string module_name)
	A phase to remove the declaration of useless variables. More...

Function Documentation

clean_declarations()

bool clean_declarations

(

const string

module_name

)

A phase to remove the declaration of useless variables.

It recursively calls statement_remove_unused_declarations on all module statement

Parameters

[in]

module_name

is the name of the module to process

Returns

true because always successful

prelude

first remove any statement that writes only variable that are never read

body

ostlude

Parameters

module_name

odule_name

Definition at line 155 of file declarations.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_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS,module_name,true));
 
  debug_on("CLEAN_DECLARATIONS_DEBUG_LEVEL");
 
  /* first remove any statement that writes only variable that are never read */
  gen_recurse(get_current_module_statement(),statement_domain,gen_true,remove_unread_variables);
 
  /* body*/
  module_clean_declarations(get_current_module_entity(),get_current_module_statement());
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
  debug_off();
 
  /*postlude */
  reset_cumulated_rw_effects();
  reset_current_module_entity();
  reset_current_module_statement();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), get_current_module_entity(), get_current_module_statement(), module_clean_declarations(), module_name(), module_name_to_entity(), remove_unread_variables(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), and statement_domain.

Here is the call graph for this function:

entity_may_conflict_with_a_formal_parameter_p()

static bool entity_may_conflict_with_a_formal_parameter_p ( entity  e, entity  module  )

static

Definition at line 91 of file declarations.c.

{
    FOREACH(entity,d,entity_declarations(module))
        if(formal_parameter_p(d) && entities_may_conflict_p(e,d)) return true;
    return false;
}

References entities_may_conflict_p(), entity_declarations, FOREACH, formal_parameter_p(), and module.

Referenced by remove_unread_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_read_somewhere_p()

static bool entity_read_somewhere_p ( entity  e, statement  in  )

static

Definition at line 110 of file declarations.c.

{
    entity_used_somewhere_param p = { e, false };
    gen_context_recurse(in,&p,statement_domain,gen_true2,entity_used_somewhere_walker);
    return p.result;
}

References entity_used_somewhere_walker(), gen_context_recurse, gen_true2(), entity_used_somewhere_param::result, and statement_domain.

Referenced by remove_unread_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_used_somewhere_walker()

static void entity_used_somewhere_walker ( statement  s, entity_used_somewhere_param *  p  )

static

Definition at line 103 of file declarations.c.

{
    list effects =load_cumulated_rw_effects_list(s);
    if(effects_read_variable_p(effects,p->e))
        { p->result = true; gen_recurse_stop(0); }
}

References entity_used_somewhere_param::e, effects_read_variable_p(), gen_recurse_stop(), load_cumulated_rw_effects_list(), and entity_used_somewhere_param::result.

Referenced by entity_read_somewhere_p().

Here is the call graph for this function:

Here is the caller graph for this function:

module_clean_declarations()

void module_clean_declarations	(	entity	module,
		statement	module_statement
	)

declarations.c

Parameters

module	odule
module_statement	odule_statement

Definition at line 140 of file declarations.c.

                                                                          {
  entity_clean_declarations(module,module_statement);
 
  gen_recurse(module_statement,statement_domain, gen_true, statement_clean_declarations);
}

References entity_clean_declarations(), gen_recurse, gen_true(), module, module_statement, statement_clean_declarations(), and statement_domain.

Referenced by clean_declarations(), and do_scalar_renaming().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_unread_variable()

static void remove_unread_variable ( statement  s, entity  e  )

static

we only manage written entity in the form of e binary_op something else

Definition at line 50 of file declarations.c.

{
  if(statement_call_p(s)&&!declaration_statement_p(s))
  {
        list effects = load_cumulated_rw_effects_list(s);
        bool entity_written = false;
        FOREACH(EFFECT,eff,effects)
            if(effect_write_p(eff) && entities_must_conflict_p(reference_variable(effect_any_reference(eff)),e))
            { entity_written = true; break; }
        if(entity_written) /* we only manage written entity in the form of e binary_op something else */
        {
            call c = statement_call(s);
            expression lhs = binary_call_lhs(c);
            if(expression_reference_p(lhs) && entities_may_conflict_p(reference_variable(expression_reference(lhs)),e))
            {
                list next = CDR(call_arguments(c));
                if(ENDP(next))
                    call_function(c) = entity_intrinsic(CONTINUE_FUNCTION_NAME);
                else if( ENDP(CDR(next)) ) {
                    expression rhs =  binary_call_rhs(c);
                    if(expression_call_p(rhs))
                    {
                        call new_c = expression_call(rhs);
                        syntax_call(expression_syntax(rhs))=call_undefined;
                        free_call(c);
                        instruction_call(statement_instruction(s))=new_c;
                    }
                    else {
                        expression exp = copy_expression(rhs);
                        free_instruction(statement_instruction(s));
                        statement_instruction(s)=make_instruction_expression(exp);
                    }
                }
                else {
                    pips_internal_error("case unhandled yet\nfell free to contribute :-)");
                }
            }
        }
 
    }
}

References binary_call_lhs, binary_call_rhs, call_arguments, call_function, call_undefined, CDR, CONTINUE_FUNCTION_NAME, copy_expression(), declaration_statement_p(), EFFECT, effect_any_reference, effect_write_p, ENDP, entities_may_conflict_p(), entities_must_conflict_p(), entity_intrinsic(), exp, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), expression_syntax, FOREACH, free_call(), free_instruction(), instruction_call, load_cumulated_rw_effects_list(), make_instruction_expression(), pips_internal_error, reference_variable, statement_call(), statement_call_p(), statement_instruction, and syntax_call.

Referenced by remove_unread_variables().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_unread_variables()

static void remove_unread_variables ( statement  s )

static

it is useless to try to remove formal parameters

and we cannot afford removing something that may implies aliasing

the entity is never read, it is disposable

Definition at line 116 of file declarations.c.

{
    if(statement_block_p(s))
    {
        FOREACH(ENTITY,e,statement_declarations(s))
        {
            if(entity_variable_p(e)) {
                if(!entity_may_conflict_with_a_formal_parameter_p(e,get_current_module_entity()) && /* it is useless to try to remove formal parameters */
                        entity_scalar_p(e) ) /* and we cannot afford removing something that may implies aliasing */
                {
                    bool effects_read_variable = entity_read_somewhere_p(e,s);
                    if(!effects_read_variable) {
                        /* the entity is never read, it is disposable */
                        pips_debug(4,"Entity %s is never read, we can remove "
                                   "statements that only produce it.\n",
                                   entity_name(e));
                        gen_context_recurse(s,e,statement_domain,gen_true2,remove_unread_variable);
                    }
                }
            }
        }
    }
}

References ENTITY, entity_may_conflict_with_a_formal_parameter_p(), entity_name, entity_read_somewhere_p(), entity_scalar_p(), entity_variable_p, FOREACH, gen_context_recurse, gen_true2(), get_current_module_entity(), pips_debug, remove_unread_variable(), statement_block_p, statement_declarations, and statement_domain.

Referenced by clean_declarations().

Here is the call graph for this function:

Here is the caller graph for this function: