if_conversion_compact.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 "ri-util.h"
#include "prettyprint.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 "effects-generic.h"
#include "effects-simple.h"
#include "properties.h"
#include "sac.h"
#include "ricedg.h"

Include dependency graph for if_conversion_compact.c:

Go to the source code of this file.

Functions
static bool	statement_phi_function_p (statement s)
	checks wether a statement is a phi function call of the form a=phi(cond, vt,vf) where phi is given by a property More...
static bool	compact_phi_functions (statement s0, statement s1)
	try to compact two phi-statements into a single one More...
static bool	statement_conflicts_p (statement sink, list source_successors)
	checks if there is a write-read conflict between source and sink according to dg successors source_successors More...
static void	if_conversion_compact_stats (statement stat, graph dg)
bool	if_conversion_compact (char *mod_name)
	cproto-generated files More...

Function Documentation

compact_phi_functions()

static bool compact_phi_functions ( statement  s0, statement  s1  )

static

try to compact two phi-statements into a single one

Parameters

s0	first statement to compact
s1	second statement to compact

Returns

true if compaction succeeded, false otherwise

all datas are handeled as pairs in an array of 2 elements we use i and !i to denote current index and its opposite

let's compare assignment part

ok it may be good, now let's compare both phi functions

first constraint : ref[i] == false_val[i]

second constraint : cond[0] == !cond[1]

yes, we have in s1 a = cond ? b:a; and in s2 a = !cond ? c: a; it will become a = cond ? b :c ;

1:replace false_val[i] by true_val[!i]

2:unlink true_val[!i]

3: replace s[!i] by a continue

Definition at line 89 of file if_conversion_compact.c.

{
    /* all datas are handeled as pairs in an array of 2 elements
     * we use i and !i to denote current index and its opposite
     */
    statement s [2] = { s0,s1 };
 
    expression lhs[2];
    for(size_t i=0;i<2;i++)
        lhs[i]=binary_call_lhs(statement_call(s[i]));
 
    /* let's compare assignment part */
    if(same_expression_p(lhs[0],lhs[1]) && expression_reference_p(lhs[0]))
    {
 
        /* ok it may be good, now
           let's compare both phi functions */
        call phis[2];
        reference ref[2];
        expression cond[2], true_val[2], false_val[2];
        for(size_t i=0;i<2;i++)
        {
            ref[i]=expression_reference(lhs[i]);
            phis[i]=expression_call(binary_call_rhs(statement_call(s[i])));
            cond[i]=EXPRESSION(CAR(call_arguments(phis[i])));
            true_val[i]=EXPRESSION(CAR(CDR(call_arguments(phis[i]))));
            false_val[i]=EXPRESSION(CAR(CDR(CDR(call_arguments(phis[i])))));
        }
 
        /* first constraint : ref[i] == false_val[i] */
        if( expression_reference_p(false_val[0]) && expression_reference_p(false_val[1]))
        {
            if(reference_equal_p(ref[0],expression_reference(false_val[0])) &&
                    reference_equal_p(ref[1],expression_reference(false_val[1])))
            {
                /* second constraint : cond[0] == !cond[1] */
                bool ok = false;
                size_t i;
                for(i =0;i<2;i++)
                {
                    if(expression_call(cond[!i]) && ENTITY_NOT_P(call_function(expression_call(cond[!i]))))
                    {
                        if((ok=expression_equal_p(EXPRESSION(CAR(call_arguments(expression_call(cond[!i])))),
                                        cond[i])))
                            break;
                    }
                }
                if(ok)
                {
                    /* yes, we have in s1 a = cond ? b:a; and in s2 a = !cond ? c: a;
                     * it will become a = cond ? b :c ;*/
 
                    /* 1:replace false_val[i] by true_val[!i]*/
                    free_expression(false_val[i]);
                    *REFCAR(CDR(CDR(call_arguments(phis[i]))))=(gen_chunkp)true_val[!i];
                    /* 2:unlink true_val[!i]*/
                    *REFCAR(CDR(call_arguments(phis[!i])))=gen_chunk_undefined;
                    /* 3: replace s[!i] by a continue */
                    update_statement_instruction(s[!i],make_continue_instruction());
                    return true;
                }
            }
        }
    }
    return false;
}

References binary_call_lhs, binary_call_rhs, call_arguments, call_function, CAR, CDR, ENTITY_NOT_P, EXPRESSION, expression_call(), expression_equal_p(), expression_reference(), expression_reference_p(), free_expression(), gen_chunk_undefined, make_continue_instruction(), ok, ref, REFCAR, reference_equal_p(), s1, same_expression_p(), statement_call(), and update_statement_instruction().

Referenced by if_conversion_compact_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

if_conversion_compact()

bool if_conversion_compact

(

char *

mod_name

)

cproto-generated files

if_conversion_compact.c

Parameters

mod_name

od_name

Definition at line 252 of file if_conversion_compact.c.

{
    // get the resources
    statement mod_stmt = (statement)
        db_get_memory_resource(DBR_CODE, mod_name, true);
 
    set_current_module_statement(mod_stmt);
    set_current_module_entity(module_name_to_entity(mod_name));
        set_ordering_to_statement(mod_stmt);
 
    graph dg = (graph) db_get_memory_resource(DBR_DG, mod_name, true);
 
    set_proper_rw_effects((statement_effects) 
            db_get_memory_resource(DBR_PROPER_EFFECTS, mod_name, true));
 
    debug_on("IF_CONVERSION_COMPACT_DEBUG_LEVEL");
    // Now do the job
 
    gen_context_recurse(mod_stmt, dg, statement_domain, gen_true2, if_conversion_compact_stats);
 
    // Reorder the module, because new statements have been added 
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
 
    // update/release resources
        reset_ordering_to_statement();
    reset_current_module_statement();
    reset_current_module_entity();
    reset_proper_rw_effects();
 
    debug_off();
 
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, dg, gen_context_recurse, gen_true2(), if_conversion_compact_stats(), module_name_to_entity(), module_reorder(), reset_current_module_entity(), reset_current_module_statement(), reset_ordering_to_statement(), reset_proper_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_ordering_to_statement(), set_proper_rw_effects(), and statement_domain.

Here is the call graph for this function:

if_conversion_compact_stats()

static void if_conversion_compact_stats ( statement  stat, graph  dg  )

static

iterate over the trailing statements to find a legal statement to compact we stop when a conflict is found or when we achived our goal

look for a write - read conflict between st and next

Definition at line 184 of file if_conversion_compact.c.

{
    // Only look at the sequence statements
    if(statement_block_p(stat))
    {
        hash_table successors = statements_to_successors(statement_block(stat),dg);
        
        for(list iter = statement_block(stat);!ENDP(iter);POP(iter))
        {
            statement st = STATEMENT(CAR(iter));
            if(statement_phi_function_p(st))
            {
                ifdebug(1) {
                    pips_debug(1,"checking statement:\n");
                    print_statement(st);
                }
                /* iterate over the trailing statements to find a legal statement to compact
                 * we stop when a conflict is found or when we achived our goal
                 */
                list succ = hash_get(successors,st);
                FOREACH(STATEMENT,next,CDR(iter))
                {
 
                    if(statement_phi_function_p(next))
                    {
                        if(compact_phi_functions(st,next))
                        {
                            ifdebug(1) {
                                pips_debug(1,"compacted into statement:\n");
                                print_statement(st);
                            }
                            break;
                        }
                    }
                    /* look for a write - read conflict between st and next */
                    else if(statement_conflicts_p(next, succ)) break;
                }
            }
        }
        hash_table_free(successors);
    }
}

References CAR, CDR, compact_phi_functions(), dg, ENDP, FOREACH, hash_get(), hash_table_free(), ifdebug, pips_debug, POP, print_statement(), STATEMENT, statement_block(), statement_block_p, statement_conflicts_p(), statement_phi_function_p(), statements_to_successors(), and successors().

Referenced by if_conversion_compact().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_conflicts_p()

static bool statement_conflicts_p ( statement  sink, list  source_successors  )

static

checks if there is a write-read conflict between source and sink according to dg successors source_successors

if there is a write-read conflict, we cannot do much

Definition at line 161 of file if_conversion_compact.c.

{
    FOREACH(SUCCESSOR,s,source_successors)
    {
        statement ss = vertex_to_statement(successor_vertex(s));
        if(ss==sink)
        {
            FOREACH(CONFLICT,c,dg_arc_label_conflicts(successor_arc_label(s)))
            {
                /* if there is a write-read conflict, we cannot do much */
                if ( (effect_write_p(conflict_source(c)) && effect_read_p(conflict_sink(c))) ||
                        (effect_read_p(conflict_source(c)) && effect_write_p(conflict_sink(c))) )
                    return true;
 
            }
        }
    }
    return false;
}

References CONFLICT, conflict_sink, conflict_source, dg_arc_label_conflicts, effect_read_p, effect_write_p, FOREACH, SUCCESSOR, successor_arc_label, successor_vertex, and vertex_to_statement().

Referenced by if_conversion_compact_stats().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_phi_function_p()

static bool statement_phi_function_p ( statement  s )

static

checks wether a statement is a phi function call of the form a=phi(cond, vt,vf) where phi is given by a property

Parameters

s	statement to check

Returns

result of the check

Definition at line 65 of file if_conversion_compact.c.

{
    if(assignment_statement_p(s))
    {
        expression rhs = binary_call_rhs(statement_call(s));
        if(expression_call_p(rhs))
        {
            const char* phi_name = get_string_property("IF_CONVERSION_PHI");
            entity phi = entity_intrinsic(phi_name);
            return same_entity_p(phi,call_function(expression_call(rhs)));
        }
    }
    return false;
}

References assignment_statement_p(), binary_call_rhs, call_function, entity_intrinsic(), expression_call(), expression_call_p(), get_string_property(), same_entity_p(), and statement_call().

Referenced by if_conversion_compact_stats().

Here is the call graph for this function:

Here is the caller graph for this function: