expression_substitution.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "database.h"
#include "ri-util.h"
#include "effects-util.h"
#include "pipsdbm.h"
#include "control.h"
#include "callgraph.h"
#include "misc.h"
#include "resources.h"
#include "properties.h"
#include "expressions.h"

Include dependency graph for expression_substitution.c:

Go to the source code of this file.

Functions
static bool	set_pattern ()
	retrieves the expression used as a pattern based on the one - statement function given in a property and sets static variables accordingly More...
static void	substitute_expression_walker (expression e, expression *pi)
void	substitute_expression (void *in, expression pattern, expression into)
	expression_substitution.c More...
static bool	replace_expression_similar_to_pattern (expression e)
static bool	replace_instruction_similar_to_pattern (instruction i)
bool	expression_substitution (const char *module_name)
	simple pass that performs substitution of expression by module call More...

Variables
static expression	pattern = expression_undefined
static const char *	pattern_module_name = string_undefined

Function Documentation

expression_substitution()

bool expression_substitution

(

const char *

module_name

)

simple pass that performs substitution of expression by module call

prelude

search pattern

validate

ostlude

Parameters

module_name

odule_name

Definition at line 157 of file expression_substitution.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) );
 
    /* search pattern*/
    bool pattern_set_p = set_pattern();
    if( pattern_set_p )
    {
        convert_to_standard_operators(get_current_module_statement());
        gen_multi_recurse(
            get_current_module_statement(),
            reference_domain, gen_false, gen_null,
            range_domain, gen_false, gen_null,
            expression_domain, replace_expression_similar_to_pattern, gen_null,
            instruction_domain, replace_instruction_similar_to_pattern, gen_null,
            0
        );
    }
 
    /* validate */
    module_reorder(get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, get_current_module_statement());
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES, module_name, compute_callees(get_current_module_statement()));
 
    /*postlude*/
    reset_current_module_entity();
    reset_current_module_statement();
    return pattern_set_p;
}

References compute_callees(), convert_to_standard_operators(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, expression_domain, gen_false(), gen_multi_recurse(), gen_null(), get_current_module_statement(), instruction_domain, module_name(), module_name_to_entity(), module_reorder(), range_domain, reference_domain, replace_expression_similar_to_pattern(), replace_instruction_similar_to_pattern(), reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), and set_pattern().

Here is the call graph for this function:

replace_expression_similar_to_pattern()

static bool replace_expression_similar_to_pattern ( expression  e )

static

recover pattern's arguments

fill the arguments

fix the expression field

Definition at line 101 of file expression_substitution.c.

{
    hash_table symbols; // contains the symbols gathered during the matching
    // match e against pattern and stocks symbols in hash_table
    if(expression_similar_get_context_p(e,pattern,&symbols)) 
    {
        entity pattern_entity = FindEntity(TOP_LEVEL_MODULE_NAME,pattern_module_name);
        expression_normalized(e) = normalized_undefined;
 
        /* recover pattern's arguments */
        list iter = NIL;
        FOREACH(ENTITY,e,code_declarations(value_code(entity_initial(pattern_entity))))
            if(entity_formal_p(e))
                iter=CONS(ENTITY,e,iter);
        iter=gen_nreverse(iter);
 
        /* fill the arguments */
        list args = NIL;
        FOREACH(ENTITY, arg, iter)
        {
            expression arge = hash_get(symbols,entity_name(arg));
            pips_assert("created map consistant with dynamic decl",arge != HASH_UNDEFINED_VALUE);
            args=CONS(EXPRESSION,copy_expression(arge),args);
 
        }
 
        free_syntax(expression_syntax(e));
 
        /* fix the expression field*/
        expression_syntax(e)=make_syntax_call(
                make_call(pattern_entity,gen_nreverse(args))
        );
        hash_table_free(symbols);
        return false;
    }
    return true;
}

References code_declarations, CONS, copy_expression(), ENTITY, entity_formal_p(), entity_initial, entity_name, EXPRESSION, expression_normalized, expression_similar_get_context_p(), expression_syntax, FindEntity(), FOREACH, free_syntax(), gen_nreverse(), hash_get(), hash_table_free(), HASH_UNDEFINED_VALUE, make_call(), make_syntax_call(), NIL, normalized_undefined, pattern_module_name, pips_assert, TOP_LEVEL_MODULE_NAME, and value_code.

Referenced by expression_substitution(), and replace_instruction_similar_to_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_instruction_similar_to_pattern()

static bool replace_instruction_similar_to_pattern ( instruction  i )

static

replacement successfull

Definition at line 139 of file expression_substitution.c.

{
    if(instruction_call_p(i))
    {
        expression exp = call_to_expression(instruction_call(i));
        if( !replace_expression_similar_to_pattern(exp) ) /* replacement successfull */
        {
            instruction_call(i)=expression_call(exp);
            expression_syntax(exp)=syntax_undefined;
            free_expression(exp);
            return false;
        }
    }
    return true;
}

References call_to_expression(), exp, expression_call(), expression_syntax, free_expression(), instruction_call, instruction_call_p, replace_expression_similar_to_pattern(), and syntax_undefined.

Referenced by expression_substitution().

Here is the call graph for this function:

Here is the caller graph for this function:

set_pattern()

static bool set_pattern ( )

static

retrieves the expression used as a pattern based on the one - statement function given in a property and sets static variables accordingly

Definition at line 58 of file expression_substitution.c.

{
    pattern_module_name = get_string_property("EXPRESSION_SUBSTITUTION_PATTERN");
    if( ! string_undefined_p(pattern_module_name) )
    {
 
        statement s = (statement) db_get_memory_resource(DBR_CODE, pattern_module_name, true);
        instruction i = statement_instruction(s);
        if( instruction_block_p(i))
        {
            list l = instruction_block(i);
            if(!ENDP(l)) i = statement_instruction(STATEMENT(CAR(l)));
        }
        if( return_instruction_p(i) )
            pattern = EXPRESSION(CAR(call_arguments(instruction_call(i))));
        else {
            pips_user_warning("%s used as pattern for expression substitution, but is not a module with a single return !\n", pattern_module_name);
            return false;
        }
        convert_to_standard_operators(pattern);
 
    }
    else
    {
        pips_user_warning("EXPRESSION_SUBSTITUTION_PATTERN undefined, but needed to perform expression substitution\n");
        return false;
    }
        return true;
}

References call_arguments, CAR, convert_to_standard_operators(), db_get_memory_resource(), ENDP, EXPRESSION, get_string_property(), instruction_block, instruction_block_p, instruction_call, pattern_module_name, pips_user_warning, return_instruction_p(), STATEMENT, statement_instruction, and string_undefined_p.

Referenced by expression_substitution().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_expression()

void substitute_expression	(	void *	in,
		expression	pattern,
		expression	into
	)

expression_substitution.c

Parameters

in	n
pattern	attern
into	nto

Definition at line 94 of file expression_substitution.c.

{
    expression arge [] = { pattern, into };
    gen_context_recurse(in, &arge[0], expression_domain, gen_true2, substitute_expression_walker);
}

References expression_domain, gen_context_recurse, gen_true2(), pattern, and substitute_expression_walker().

Referenced by do_terapix_argument_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_expression_walker()

static void substitute_expression_walker ( expression  e, expression *  pi  )

static

Definition at line 88 of file expression_substitution.c.

{
    if(same_expression_p(e,pi[0])) 
        update_expression_syntax(e,copy_syntax(expression_syntax(pi[1])));
}

References copy_syntax(), expression_syntax, same_expression_p(), and update_expression_syntax().

Referenced by substitute_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

pattern

expression pattern = expression_undefined

static

Definition at line 50 of file expression_substitution.c.

Referenced by substitute_expression().

pattern_module_name

const char* pattern_module_name = string_undefined

static

Definition at line 51 of file expression_substitution.c.

Referenced by replace_expression_similar_to_pattern(), and set_pattern().