if_conversion_init.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 "complexity_ri.h"
#include "text.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 "complexity.h"
#include "sac.h"

Include dependency graph for if_conversion_init.c:

Go to the source code of this file.

Functions
static statement	atomize_condition (statement cs)
	atomize the condition of a test and returns generated statements More...
static bool	check_if_conv_call (call c, bool *success)
	accept if conversion if the call is an assignment call More...
static bool	check_if_conv_test (test t, bool *success)
	checks if a test statement is suitable for if conversion, that is it only contains sequence of assignments More...
static bool	check_if_conv_walker (instruction i, bool *success)
static bool	check_if_conv (statement stat)
	checks if if conversion can be performed on test statement More...
static void	update_test_condition (test t, expression cond)
	adds More...
static statement	make_if_converted_test_statement (expression cond, statement branch)
	create a test statement with appropriate extension and a test under cond with a single true branch branch More...
static statement	do_transform_if_statements (statement branch, expression cond)
	merge content of a test with the test itself More...
static void	if_conv_init_statement (statement stat)
bool	if_conversion_init (char *mod_name)
	if_conversion_init.c More...

Function Documentation

atomize_condition()

static statement atomize_condition ( statement  cs )

static

atomize the condition of a test and returns generated statements

Parameters

cs	test statement

Returns

generated statement

Definition at line 66 of file if_conversion_init.c.

{
        test t = statement_test(cs);
        expression cond = test_condition(t);
        if(!expression_reference_p(cond))
            return simd_atomize_this_expression(make_new_scalar_variable, cond);
        return statement_undefined;
}

References expression_reference_p(), make_new_scalar_variable(), simd_atomize_this_expression(), statement_test(), statement_undefined, and test_condition.

Referenced by if_conv_init_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

check_if_conv()

static bool check_if_conv ( statement  stat )

static

checks if if conversion can be performed on test statement

Parameters

stat	test statement

Returns

true if conversion possible

Definition at line 127 of file if_conversion_init.c.

{
    test t = instruction_test(statement_instruction(stat));
 
    pips_assert("statement is a test", statement_test_p(stat));
 
    bool success = true;
    check_if_conv_test(t,&success);
    return success;
}

References check_if_conv_test(), instruction_test, pips_assert, statement_instruction, and statement_test_p().

Referenced by if_conv_init_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

check_if_conv_call()

static bool check_if_conv_call ( call  c, bool *  success  )

static

accept if conversion if the call is an assignment call

Definition at line 79 of file if_conversion_init.c.

{
    call tmp = copy_call(c);
    split_update_call(tmp);
    entity op = call_function(tmp);
    *success &=ENTITY_ASSIGN_P(op)||ENTITY_CONTINUE_P(op)||call_constant_p(c);
    free_call(tmp);
    return *success;
}

References call_constant_p, call_function, copy_call(), ENTITY_ASSIGN_P, ENTITY_CONTINUE_P, free_call(), and split_update_call().

Referenced by check_if_conv_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

check_if_conv_test()

static bool check_if_conv_test ( test  t, bool *  success  )

static

checks if a test statement is suitable for if conversion, that is it only contains sequence of assignments

Definition at line 110 of file if_conversion_init.c.

{
    statement branches[2] = { test_true(t), test_false(t) };
 
    for(size_t i=0;i<2;i++)
        gen_context_recurse(branches[i], success,
                instruction_domain, check_if_conv_walker, gen_null2);
    return false;
}

References check_if_conv_walker(), gen_context_recurse, gen_null2(), instruction_domain, test_false, and test_true.

Referenced by check_if_conv(), and check_if_conv_walker().

Here is the call graph for this function:

Here is the caller graph for this function:

check_if_conv_walker()

static bool check_if_conv_walker ( instruction  i, bool *  success  )

static

Definition at line 90 of file if_conversion_init.c.

{
    switch(instruction_tag(i))
    {
        case is_instruction_call:
            return check_if_conv_call(instruction_call(i),success);
        case is_instruction_test:
            return check_if_conv_test(instruction_test(i),success);
        case is_instruction_block:
            return true;
        default:
            return false;
    };
}

References check_if_conv_call(), check_if_conv_test(), instruction_call, instruction_tag, instruction_test, is_instruction_block, is_instruction_call, and is_instruction_test.

Referenced by check_if_conv_test().

Here is the call graph for this function:

Here is the caller graph for this function:

do_transform_if_statements()

static statement do_transform_if_statements ( statement  branch, expression  cond  )

static

merge content of a test with the test itself

Parameters

branch	content of the test
cond	condition of the test

Returns

merged statements

Definition at line 168 of file if_conversion_init.c.

{
    // only add the condition if content is a test
    if(statement_test_p(branch))
    {
        update_test_condition( statement_test(branch) ,cond);
        return copy_statement(branch);
    }
    // the big part : merge tests into a single block
    // the idea is too stack statements until a test is met.
    // stacked statements are put under condition, then the test is added and so on
    else if(statement_block_p(branch))
    {
        list block=NIL;
        list curr_block = NIL;
        FOREACH(STATEMENT,st,statement_block(branch))
        {
            if(statement_test_p(st))
            {
                update_test_condition( statement_test(st) ,cond);
                if(!ENDP(curr_block))
                    block=CONS(STATEMENT,make_if_converted_test_statement(copy_expression(cond),make_block_statement(gen_nreverse(curr_block))),block);
                block=CONS(STATEMENT,copy_statement(st),block);
                curr_block=NIL;
            }
            else
            {
                curr_block=CONS(STATEMENT,copy_statement(st),curr_block);
            }
        }
        if(!ENDP(curr_block))
            block=CONS(STATEMENT,make_if_converted_test_statement(copy_expression(cond),make_block_statement(gen_nreverse(curr_block))),block);
        return make_block_statement(gen_nreverse(block));
    }
    // not much to do there, ony allpy test condition
    else
        return make_if_converted_test_statement(copy_expression(cond),copy_statement(branch));
}

References CONS, copy_expression(), copy_statement(), ENDP, FOREACH, gen_nreverse(), make_block_statement(), make_if_converted_test_statement(), NIL, STATEMENT, statement_block(), statement_block_p, statement_test(), statement_test_p(), and update_test_condition().

Referenced by if_conv_init_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

if_conv_init_statement()

static void if_conv_init_statement ( statement  stat )

static

Definition at line 212 of file if_conversion_init.c.

{
    // Only interested in the test statements
    if(statement_test_p(stat))
    {
 
        gen_chunk * ancestor = gen_get_recurse_current_ancestor();
        if (ancestor && INSTANCE_OF(control, ancestor)) {
            // Hmmm, we are inside a control node
            control c = (control) ancestor;
            if (gen_length(control_successors(c)) == 2) {
                // A control node with 2 successors is an unstructured test:
                pips_user_warning("not converting a non structured test yet...\n");
                return;
            }
        }
 
        complexity stat_comp = load_statement_complexity(stat);
        if(stat_comp != (complexity) HASH_UNDEFINED_VALUE)
        {
 
            Ppolynome poly = complexity_polynome(stat_comp);
            if(polynome_constant_p(poly))
            {
                clean_up_sequences(stat);
                pips_debug(2,"analyzing statement:\n");
                ifdebug(2) {
                    print_statement(stat);
                }
 
                // Get the number of calls in the if statement
                int cost = polynome_TCST(poly);
                pips_debug(3,"cost %d\n", cost);
 
                // ensure the statement is valid
                bool success = check_if_conv(stat);
 
                // If the number of calls is smaller than IF_CONV_THRESH
                if(success && cost < get_int_property("IF_CONVERSION_INIT_THRESHOLD"))
                {
                    test t = statement_test(stat);
 
                    // Atomize the condition
                    statement atom = atomize_condition(stat);
 
                    expression not_test_condition=
                        MakeUnaryCall(
                                entity_intrinsic(NOT_OPERATOR_NAME),
                                copy_expression(test_condition(t))
                                );
                    list block = 
                        make_statement_list(
                                do_transform_if_statements(test_true(t),test_condition(t)),
                                do_transform_if_statements(test_false(t),not_test_condition)
                                );
                    if(!statement_undefined_p(atom))
                        block=CONS(STATEMENT,atom,block);
                    update_statement_instruction(stat,make_instruction_block(block));
                    ifdebug(3) {
                        pips_debug(3,"new test:\n");
                        print_statement(stat);
                    }
                }
            }
            else
                pips_user_warning("not converting a test, complexity too ... complex \n");
 
        }
        else
            pips_user_warning("not converting a test, complexity not available\n");
    }
}

References atomize_condition(), check_if_conv(), clean_up_sequences(), complexity_polynome(), CONS, control_successors, copy_expression(), do_transform_if_statements(), entity_intrinsic(), gen_get_recurse_current_ancestor(), gen_length(), get_int_property(), HASH_UNDEFINED_VALUE, ifdebug, INSTANCE_OF, load_statement_complexity(), make_instruction_block(), make_statement_list, MakeUnaryCall(), NOT_OPERATOR_NAME, pips_debug, pips_user_warning, polynome_constant_p(), polynome_TCST(), print_statement(), STATEMENT, statement_test(), statement_test_p(), statement_undefined_p, test_condition, test_false, test_true, and update_statement_instruction().

Referenced by if_conversion_init().

Here is the call graph for this function:

Here is the caller graph for this function:

if_conversion_init()

bool if_conversion_init

(

char *

mod_name

)

if_conversion_init.c

Parameters

mod_name

od_name

Definition at line 337 of file if_conversion_init.c.

{
    // get the resources
    set_current_module_entity(module_name_to_entity(mod_name));
    statement root = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
    statement fake = make_empty_block_statement();
 
    set_current_module_statement(fake);// to prevent a complex bug with gen_recurse and AddEntityToCurrentModule
    set_complexity_map( (statement_mapping) db_get_memory_resource(DBR_COMPLEXITIES, mod_name, true));
 
    debug_on("IF_CONVERSION_INIT_DEBUG_LEVEL");
 
    ifdebug(1) {
      pips_debug(1, "Code before if_conversion_init:\n");
      print_statement(root);
    }
 
    // Now do the job
    gen_recurse(root, statement_domain, gen_true, if_conv_init_statement);
 
    ifdebug(1) {
      pips_debug(1, "Code after if_conv_init_statement:\n");
      print_statement(root);
    }
 
    // and share decl
    FOREACH(STATEMENT,s,statement_block(fake))
        insert_statement_no_matter_what(root,copy_statement(s),true);
    free_statement(fake);
 
    ifdebug(1) {
      pips_debug(1, "Code after copying from fake statement:\n");
      print_statement(root);
    }
 
    // Reorder the module, because new statements have been added
    module_reorder(root);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, mod_name, root);
 
    // update/release resources
    reset_complexity_map();
    reset_current_module_statement();
    reset_current_module_entity();
 
    debug_off();
 
    return true;
}

References copy_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, FOREACH, free_statement(), gen_recurse, gen_true(), if_conv_init_statement(), ifdebug, insert_statement_no_matter_what(), make_empty_block_statement(), module_name_to_entity(), module_reorder(), pips_debug, print_statement(), reset_complexity_map(), reset_current_module_entity(), reset_current_module_statement(), set_complexity_map(), set_current_module_entity(), set_current_module_statement(), STATEMENT, statement_block(), and statement_domain.

Here is the call graph for this function:

make_if_converted_test_statement()

static statement make_if_converted_test_statement ( expression  cond, statement  branch  )

static

create a test statement with appropriate extension and a test under cond with a single true branch branch

Definition at line 150 of file if_conversion_init.c.

{
    statement s =  instruction_to_statement(
                                make_instruction_test(
                                    make_test(cond,branch,make_empty_statement())));
    extensions_extension(statement_extensions(s))=CONS(EXTENSION,make_extension_pragma(make_pragma_string(strdup(IF_TO_CONVERT))),NIL);
    return s;
}

References CONS, EXTENSION, extensions_extension, IF_TO_CONVERT, instruction_to_statement(), make_empty_statement, make_extension_pragma(), make_instruction_test(), make_pragma_string(), make_test(), NIL, statement_extensions, and strdup().

Referenced by do_transform_if_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

update_test_condition()

static void update_test_condition ( test  t, expression  cond  )

static

adds

Parameters

cond	to the condtion of
t

Definition at line 142 of file if_conversion_init.c.

{
    test_condition(t)=MakeBinaryCall(entity_intrinsic(AND_OPERATOR_NAME),copy_expression(cond),test_condition(t));
}

References AND_OPERATOR_NAME, copy_expression(), entity_intrinsic(), MakeBinaryCall(), and test_condition.

Referenced by do_transform_if_statements().

Here is the call graph for this function:

Here is the caller graph for this function: