new_atomizer.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "dg.h"
#include "graph.h"
#include "ri-util.h"
#include "effects-util.h"
#include "text-util.h"
#include "database.h"
#include "misc.h"
#include "pipsdbm.h"
#include "resources.h"
#include "control.h"
#include "arithmetique.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "atomizer.h"

Include dependency graph for new_atomizer.c:

Go to the source code of this file.

Data Structures
struct	atomizer_param

Typedefs
typedef dg_arc_label	arc_label
	An atomizer that uses the one made by Fabien Coelho for HPFC, and is in fact just a hacked version of the one made by Ronan Keryell... More...
typedef dg_vertex_label	vertex_label

Functions
static void	atomize_call (expression, atomizer_param *)
static void	do_atomize_call (expression parent, atomizer_param *p, list expressions)
static bool	atomize_call_filter (expression parent, atomizer_param *p)
static void	atomize_all (void *v, atomizer_param *p)
static void	atomize_statement (statement stat)
	This function is called for all statements in the code. More...
bool	new_atomizer (char *mod_name)
	Mappings for the cumulated effects of statements. More...

Typedef Documentation

arc_label

typedef dg_arc_label arc_label

An atomizer that uses the one made by Fabien Coelho for HPFC, and is in fact just a hacked version of the one made by Ronan Keryell...

Definition at line 44 of file new_atomizer.c.

vertex_label

typedef dg_vertex_label vertex_label

Definition at line 45 of file new_atomizer.c.

Function Documentation

atomize_all()

static void atomize_all ( void *  v, atomizer_param *  p  )

static

Definition at line 137 of file new_atomizer.c.

{
    gen_context_multi_recurse(v,p,
            expression_domain,atomize_call_filter,atomize_call,
            0);
}

References atomize_call(), atomize_call_filter(), expression_domain, and gen_context_multi_recurse().

Referenced by atomize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

atomize_call()

static void atomize_call ( expression  parent, atomizer_param *  p  )

static

Definition at line 107 of file new_atomizer.c.

{
    if(expression_call_p(parent))
    {
        call c = expression_call(parent);
        do_atomize_call(parent,p,call_arguments(c));
    }
    else if(expression_reference_p(parent))
    {
        reference ref = expression_reference(parent);
        if(!ENDP(reference_indices(ref)))
            do_atomize_call(parent,p,reference_indices(ref));
    }
}

References call_arguments, do_atomize_call(), ENDP, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), ref, and reference_indices.

Referenced by atomize_all().

Here is the call graph for this function:

Here is the caller graph for this function:

atomize_call_filter()

static bool atomize_call_filter ( expression  parent, atomizer_param *  p  )

static

do not visit rhs of . and ->

Definition at line 123 of file new_atomizer.c.

{
  pips_assert("true", p==p);
    if(expression_call_p(parent))
    {
        call c= expression_call(parent);
        entity op = call_function(c);
        /* do not visit rhs of . and -> */
        if(ENTITY_POINT_TO_P(op) || ENTITY_FIELD_P(op)) gen_recurse_stop(binary_call_rhs(c));
        if(call_constant_p(c)) return false;
    }
    return true;
}

References binary_call_rhs, call_constant_p, call_function, ENTITY_FIELD_P, ENTITY_POINT_TO_P, expression_call(), expression_call_p(), gen_recurse_stop(), and pips_assert.

Referenced by atomize_all().

Here is the call graph for this function:

Here is the caller graph for this function:

atomize_statement()

static void atomize_statement ( statement  stat )

static

This function is called for all statements in the code.

SG: we could atomize condition in test, loops etc too

this may cause a useless atomization if i is an expression

Definition at line 146 of file new_atomizer.c.

{
    instruction i = statement_instruction(stat);
    /* SG: we could atomize condition in test, loops etc too */
    if(instruction_call_p(i) || instruction_expression_p(i))
    {
        atomizer_param p = { NIL, NIL };
        list weffects = effects_write_effects(load_cumulated_rw_effects_list(stat));
        FOREACH(EFFECT,weff,weffects)
            p.written_references=CONS(REFERENCE,effect_any_reference(weff),p.written_references);
        /* this may cause a useless atomization if i is an expression */
        atomize_all(i,&p);
        if(!ENDP(p.inserted_statements))
            insert_statement(stat,make_block_statement(gen_nreverse(p.inserted_statements)),true);
    }
 
}

References atomize_all(), CONS, EFFECT, effect_any_reference, effects_write_effects(), ENDP, FOREACH, gen_nreverse(), insert_statement(), atomizer_param::inserted_statements, instruction_call_p, instruction_expression_p, load_cumulated_rw_effects_list(), make_block_statement(), NIL, REFERENCE, statement_instruction, and atomizer_param::written_references.

Referenced by new_atomizer().

Here is the call graph for this function:

Here is the caller graph for this function:

do_atomize_call()

static void do_atomize_call ( expression  parent, atomizer_param *  p, list  expressions  )

static

stop if call directly involves a written reference

go on and atomize, that is

• create a variable to store call result
• recurse on call arguments

Definition at line 69 of file new_atomizer.c.

{
    bool safe=true;
    /* stop if call directly involves a written reference */
    FOREACH(EXPRESSION,arg,expressions)
    {
        if(expression_reference_p(arg)&&
                !entity_field_p(reference_variable(expression_reference(arg))))
        {
            list effects = proper_effects_of_expression(arg);
            FOREACH(REFERENCE,rw,p->written_references) {
                FOREACH(EFFECT,eff,effects)
                    if(references_may_conflict_p(rw,effect_any_reference(eff)))
                    { safe=false; break; }
                if(!safe) break;
            }
            gen_full_free_list(effects);
            if(!safe) break;
        }
    }
    /* go on and atomize, that is
     * - create a variable to store call result
     * - recurse on call arguments
     */
    if( safe )
    {
            basic bofe=basic_of_expression(parent);
            entity result = make_new_scalar_variable(get_current_module_entity(),bofe);
            AddEntityToCurrentModule(result);
            statement ass = make_assign_statement(
                    entity_to_expression(result),
                    make_expression(expression_syntax(parent),normalized_undefined));
            p->inserted_statements=CONS(STATEMENT,ass,p->inserted_statements);
            expression_syntax(parent)=syntax_undefined;
            update_expression_syntax(parent,make_syntax_reference(make_reference(result,NIL)));
    }
}

References AddEntityToCurrentModule(), basic_of_expression(), CONS, EFFECT, effect_any_reference, entity_field_p(), entity_to_expression(), EXPRESSION, expression_reference(), expression_reference_p(), expression_syntax, FOREACH, gen_full_free_list(), get_current_module_entity(), atomizer_param::inserted_statements, make_assign_statement(), make_expression(), make_new_scalar_variable(), make_reference(), make_syntax_reference(), NIL, normalized_undefined, proper_effects_of_expression(), REFERENCE, reference_variable, references_may_conflict_p(), STATEMENT, syntax_undefined, update_expression_syntax(), and atomizer_param::written_references.

Referenced by atomize_call().

Here is the call graph for this function:

Here is the caller graph for this function:

new_atomizer()

bool new_atomizer

(

char *

mod_name

)

Mappings for the cumulated effects of statements.

extern statement_mapping cumulated_effects_map; cproto-generated files new_atomizer.c

get the resources

Now do the job

Reorder the module, because new statements have been added

update/release resources

Parameters

mod_name

od_name

Definition at line 164 of file new_atomizer.c.

{
    /* get the resources */
    set_current_module_entity(module_name_to_entity(mod_name));
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE, mod_name,true));
    set_cumulated_rw_effects((statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, mod_name, true));
    debug_on("NEW_ATOMIZER_DEBUG_LEVEL");
 
 
    /* Now do the job */
    gen_recurse(get_current_module_statement(), statement_domain, gen_true, atomize_statement);
 
    /* Reorder the module, because new statements have been added */  
    clean_up_sequences(get_current_module_statement());
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, get_current_module_statement());
 
    /* update/release resources */
    reset_cumulated_rw_effects();
    reset_current_module_statement();
    reset_current_module_entity();
    debug_off();
 
    return true;
}

References atomize_statement(), clean_up_sequences(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), get_current_module_statement(), module_name_to_entity(), module_reorder(), 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: