if_conversion.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 "transformations.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "properties.h"
#include "callgraph.h"
#include "sac.h"

Include dependency graph for if_conversion.c:

Go to the source code of this file.

Functions
static instruction	make_phi_assign_instruction (reference lRef, expression cond, expression ref1, expression ref2)
	creates a phi-instruction using the entity given in property the generated instruction as the form lRef = PHI(cond,ref1, ref2) all parameters are copied More...
static bool	simd_supported_stat_p (statement stat)
static bool	process_true_call_stat (expression cond, statement stat)
	converts statement stat into a phi-statement if possible More...
static void	process_true_stat (statement parent, expression cond, statement stat)
static void	if_conv_statement (statement cs)
bool	if_conversion (char *mod_name)
	if_conversion.c More...
static statement	do_loop_nest_unswitching_purge (statement adam, list conditions)
static void	do_loop_nest_unswitching (statement st, list *conditions)
bool	loop_nest_unswitching (const char *module_name)

Function Documentation

do_loop_nest_unswitching()

static void do_loop_nest_unswitching ( statement  st, list *  conditions  )

static

will help for partial eval later

some conditions left

parent is a loop : check for a conflict

Definition at line 329 of file if_conversion.c.

                                                                    {
    if(statement_loop_p(st)) {
        loop l =statement_loop(st);
        range r = loop_range(l);
        expression u = range_upper(r);
        if(expression_minmax_p(u)) {//only handle the case of two args right now ... */
            call c = expression_call(u);
            if(gen_length(call_arguments(c)) > 2 ) pips_internal_error("do not handle more than 2 args");
            expression hs[]= {
                binary_call_lhs(c),
                binary_call_rhs(c)
                    };
            for(int i=0;i<(int)(sizeof(hs)/sizeof(hs[0]));i++) {
                expression hss = hs[i];
                hs[i]=copy_expression(hs[i]);
                NORMALIZE_EXPRESSION(hs[i]);
                if(normalized_complex_p(expression_normalized(hs[i]))) {
                    /* will help for partial eval later */
                    entity etmp = make_new_scalar_variable(get_current_module_entity(),basic_of_expression(hs[i]));
                    AddEntityToCurrentModule(etmp);
                    hs[i]=make_assign_expression(entity_to_expression(etmp),hs[i]);
                    update_expression_syntax(hss,expression_syntax(entity_to_expression(etmp)));
                }
            }
 
            *conditions=
                CONS(EXPRESSION,
                        binary_intrinsic_expression(GREATER_THAN_OPERATOR_NAME,hs[0],hs[1]),
                        *conditions);
        }
 
        statement sparent = (statement)gen_get_ancestor(statement_domain,st);
        /* some conditions left */
        if(!ENDP(*conditions) && (!statement_loop_p(sparent) || !sparent)) {
            *st = *(do_loop_nest_unswitching_purge(st,*conditions));
            //add_pragma_str_to_statement(st,get_string_property("OUTLINE_PRAGMA"),true);
            gen_full_free_list(*conditions);
            *conditions=NIL;
        }
        /* parent is a loop : check for a conflict */
        else {
            list toremove=NIL;
            list tconditions=gen_copy_seq(*conditions);
            FOREACH(EXPRESSION,cond,tconditions) {
                set s = get_referenced_entities(cond);
                if(set_belong_p(s,loop_index(statement_loop(sparent)))) {
                    toremove=CONS(EXPRESSION,cond,toremove);
                    gen_remove_once(conditions,cond);
                }
                set_free(s);
            }
            gen_free_list(tconditions);
            if(!ENDP(toremove)) {
                *st = *(do_loop_nest_unswitching_purge(st,toremove));
                //add_pragma_str_to_statement(st,get_string_property("OUTLINE_PRAGMA"),true);
            }
            gen_full_free_list(toremove);
        }
    }
    else pips_assert("everything is ok",ENDP(*conditions));
}

References AddEntityToCurrentModule(), basic_of_expression(), binary_call_lhs, binary_call_rhs, binary_intrinsic_expression, call_arguments, CONS, copy_expression(), do_loop_nest_unswitching_purge(), ENDP, entity_to_expression(), EXPRESSION, expression_call(), expression_minmax_p(), expression_normalized, expression_syntax, FOREACH, gen_copy_seq(), gen_free_list(), gen_full_free_list(), gen_get_ancestor(), gen_length(), gen_remove_once(), get_current_module_entity(), get_referenced_entities(), GREATER_THAN_OPERATOR_NAME, int, loop_index, loop_range, make_assign_expression(), make_new_scalar_variable(), NIL, NORMALIZE_EXPRESSION, normalized_complex_p, pips_assert, pips_internal_error, range_upper, set_belong_p(), set_free(), statement_domain, statement_loop(), statement_loop_p(), and update_expression_syntax().

Referenced by loop_nest_unswitching().

Here is the call graph for this function:

Here is the caller graph for this function:

do_loop_nest_unswitching_purge()

static statement do_loop_nest_unswitching_purge ( statement  adam, list  conditions  )

static

Definition at line 310 of file if_conversion.c.

                                                                                 {
    if(ENDP(conditions)) {
            clone_context cc = make_clone_context(get_current_module_entity(),get_current_module_entity(),NIL,get_current_module_statement());
            statement eve = clone_statement(adam,cc);
            free_clone_context(cc);
            return eve;
    }
    statement eve =  instruction_to_statement(
                    make_instruction_test(
                            make_test(
                                    copy_expression(EXPRESSION(CAR(conditions))),
                                    do_loop_nest_unswitching_purge(adam,CDR(conditions)),
                                    do_loop_nest_unswitching_purge(adam,CDR(conditions))
                                    )
                            )
            );
    return eve;
}

References CAR, CDR, clone_statement(), copy_expression(), ENDP, EXPRESSION, free_clone_context(), get_current_module_entity(), get_current_module_statement(), instruction_to_statement(), make_clone_context(), make_instruction_test(), make_test(), and NIL.

Referenced by do_loop_nest_unswitching().

Here is the call graph for this function:

Here is the caller graph for this function:

if_conv_statement()

static void if_conv_statement ( statement  cs )

static

Definition at line 244 of file if_conversion.c.

{
    // If the statement comment contains the string IF_TO_CONVERT,
    // then it means that this statement must be converted ...
    extension ex;
    if ( (ex = get_extension_from_statement_with_pragma(cs, IF_TO_CONVERT)) )
    {
        // remove the pragma
        gen_remove(&extensions_extension(statement_extensions(cs)),ex);
 
        // Process the "true statements" (test_false(t) is empty because if_conversion
        // phase is done after if_conversion_init phase).
        test t = instruction_test(statement_instruction(cs));
        process_true_stat(cs,test_condition(t), test_true(t));
    }
}

References extensions_extension, gen_remove(), get_extension_from_statement_with_pragma(), IF_TO_CONVERT, instruction_test, process_true_stat(), statement_extensions, statement_instruction, test_condition, and test_true.

Referenced by if_conversion().

Here is the call graph for this function:

Here is the caller graph for this function:

if_conversion()

bool if_conversion

(

char *

mod_name

)

if_conversion.c

Parameters

mod_name

od_name

Definition at line 281 of file if_conversion.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));
 
    debug_on("IF_CONVERSION_DEBUG_LEVEL");
    // Now do the job
 
    gen_recurse(mod_stmt, statement_domain, gen_true, if_conv_statement);
 
    // Reorder the module, because new statements have been added 
    module_reorder(mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, mod_stmt);
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, mod_name, 
            compute_callees(mod_stmt));
 
    // update/release resources
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), if_conv_statement(), 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:

loop_nest_unswitching()

bool loop_nest_unswitching

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 391 of file if_conversion.c.

                                                    {
    set_current_module_statement((statement)db_get_memory_resource(DBR_CODE, module_name,true));
    set_current_module_entity(module_name_to_entity(module_name));
 
    list l=NIL;
    gen_context_recurse(get_current_module_statement(), &l,
            statement_domain, gen_true2, do_loop_nest_unswitching);
    pips_assert("everything went well\n",ENDP(l));
 
 
    // Reorder the module, because new statements have been added 
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
 
    reset_current_module_statement();
    reset_current_module_entity();
    return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, do_loop_nest_unswitching(), ENDP, gen_context_recurse, gen_true2(), get_current_module_statement(), module_name(), module_name_to_entity(), module_reorder(), NIL, pips_assert, 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:

make_phi_assign_instruction()

static instruction make_phi_assign_instruction ( reference  lRef, expression  cond, expression  ref1, expression  ref2  )

static

creates a phi-instruction using the entity given in property the generated instruction as the form lRef = PHI(cond,ref1, ref2) all parameters are copied

Definition at line 64 of file if_conversion.c.

{
    entity phiEntity = module_name_to_runtime_entity(get_string_property("IF_CONVERSION_PHI"));
    expression phiExp = MakeTernaryCall(
            phiEntity,
            copy_expression(cond),
            copy_expression(ref1),
            copy_expression(ref2)
            );
 
    return make_assign_instruction(reference_to_expression(copy_reference(lRef)), phiExp);
}

References copy_expression(), copy_reference(), get_string_property(), make_assign_instruction(), MakeTernaryCall(), module_name_to_runtime_entity(), and reference_to_expression().

Referenced by process_true_call_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

process_true_call_stat()

static bool process_true_call_stat ( expression  cond, statement  stat  )

static

converts statement stat into a phi-statement if possible

Parameters

cond	condition of the potential new phi - statement
stat	statement to check

Returns

true if processing was ok (sg:unclean, event to me :))

to prevent side effect from further inplace modification

Definition at line 113 of file if_conversion.c.

{
 
    // Only the assign statements with no side effects are supported
    if(simd_supported_stat_p(stat))
    {
        call c = copy_call(instruction_call(statement_instruction(stat)));
 
        // lRef is the left reference of the assign call
        expression lhs = binary_call_lhs(c);
        reference lhs_ref = expression_reference(lhs);
        lhs=copy_expression(lhs); /* to prevent side effect from further inplace modification */
        entity e = reference_variable(lhs_ref);
 
        basic newBas = basic_of_reference(lhs_ref);
 
        if(!basic_undefined_p(newBas))
        {
            ifdebug(1) {
                pips_debug(1,"converting statement\n");
                print_statement(stat);
            }
            // Create a new entity if rhs is not a reference or a constant itself
            expression rhs = binary_call_rhs(c);
            expression ref = expression_undefined;
            statement to_add = statement_undefined;
            if(expression_reference_p(rhs)||expression_constant_p(rhs))
                ref = rhs;
            else {
                entity newVar = make_new_scalar_variable_with_prefix(entity_local_name(e),
                        get_current_module_entity(),
                        newBas);
                AddEntityToCurrentModule(newVar);
 
                syntax_reference(expression_syntax(binary_call_lhs(c))) = make_reference(newVar, NIL);
                ref=reference_to_expression(make_reference(newVar,NIL));
                to_add = call_to_statement(c);
            }
            // Make an assign statement to insert before the phi-statement
            instruction assign = make_phi_assign_instruction(lhs_ref, cond, ref, lhs);
            update_statement_instruction(stat,assign);
            if(!statement_undefined_p(to_add))
                insert_statement(stat,to_add,true);
            ifdebug(1) {
                pips_debug(1,"into statement\n");
                print_statement(stat);
            }
            free_expression(lhs);
            return true;
        }
        free_expression(lhs);
 
    }
    else if(declaration_statement_p(stat))
        return true;// leave statement untouched
    return false;
}

References AddEntityToCurrentModule(), basic_of_reference(), basic_undefined_p, binary_call_lhs, binary_call_rhs, call_to_statement, copy_call(), copy_expression(), declaration_statement_p(), entity_local_name(), expression_constant_p(), expression_reference(), expression_reference_p(), expression_syntax, expression_undefined, free_expression(), get_current_module_entity(), ifdebug, insert_statement(), instruction_call, make_new_scalar_variable_with_prefix(), make_phi_assign_instruction(), make_reference(), NIL, pips_debug, print_statement(), ref, reference_to_expression(), reference_variable, simd_supported_stat_p(), statement_instruction, statement_undefined, statement_undefined_p, syntax_reference, and update_statement_instruction().

Referenced by process_true_stat().

Here is the call graph for this function:

Here is the caller graph for this function:

process_true_stat()

static void process_true_stat ( statement  parent, expression  cond, statement  stat  )

static

Definition at line 189 of file if_conversion.c.

{
 
    // It must have been verified in the if_conversion_init phase
    pips_assert("stat is a call or a sequence statement", 
            (instruction_call_p(statement_instruction(stat)) ||
             instruction_sequence_p(statement_instruction(stat)) ||
             statement_loop_p(stat)));
 
    // If stat is a call statement, ...
    if(instruction_call_p(statement_instruction(stat)))
    {
        if(process_true_call_stat(cond, stat))
        {
            statement_instruction(parent)=instruction_undefined;
            update_statement_instruction(parent,statement_instruction(stat));
            statement_instruction(stat)=instruction_undefined;
            free_statement(stat);
        }
 
    }
    // recurse for for loops
    else if( statement_loop_p(stat))
        process_true_stat(stat,cond,loop_body(statement_loop(stat)));
 
    // If stat is a sequence statement, ...
    else if(statement_block_p(stat))
    {
        // first split initalizations
        statement_split_initializations(stat);
 
        // then do the processing
        bool something_bad_p=false;
        if(statement_block_p(stat))
        {
            FOREACH(STATEMENT,st,statement_block(stat))
            {
                something_bad_p|=!process_true_call_stat(cond, st);
            }
        }
        else
            something_bad_p|=!process_true_call_stat(cond, stat);
        if(!something_bad_p)
        {
            statement_instruction(parent)=instruction_undefined;
            update_statement_instruction(parent,statement_instruction(stat));
            statement_instruction(stat)=instruction_undefined;
            free_statement(stat);
        }
    }
}

References FOREACH, free_statement(), instruction_call_p, instruction_sequence_p, instruction_undefined, loop_body, pips_assert, process_true_call_stat(), STATEMENT, statement_block(), statement_block_p, statement_instruction, statement_loop(), statement_loop_p(), statement_split_initializations(), and update_statement_instruction().

Referenced by if_conv_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

simd_supported_stat_p()

static bool simd_supported_stat_p ( statement  stat )

static

Definition at line 84 of file if_conversion.c.

{
    if(instruction_call_p(statement_instruction(stat)))
    {
        call c = instruction_call(statement_instruction(stat));
        split_update_call(c); // this will take car of splitting a+=2 into a = a+2
        entity op = call_function(c);
        // Only the assign statements with no side effects are supported
        if(ENTITY_ASSIGN_P(op) )
        {
            expression rExp = EXPRESSION(CAR(CDR(call_arguments(c))));
            list effects = expression_to_proper_effects(rExp);
            bool has_write_effect_p = effects_write_at_least_once_p(effects);
            free(effects);
            return !has_write_effect_p;
        }
    }
    return false;
}

References call_arguments, call_function, CAR, CDR, effects_write_at_least_once_p(), ENTITY_ASSIGN_P, EXPRESSION, expression_to_proper_effects(), free(), instruction_call, instruction_call_p, split_update_call(), and statement_instruction.

Referenced by process_true_call_stat().

Here is the call graph for this function:

Here is the caller graph for this function: