continuation.c File Reference

#include <stdio.h>
#include <string.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "effects.h"
#include "database.h"
#include "ri-util.h"
#include "effects-util.h"
#include "constants.h"
#include "misc.h"
#include "text-util.h"
#include "text.h"
#include "effects-generic.h"
#include "transformer.h"
#include "semantics.h"
#include "pipsdbm.h"
#include "resources.h"
#include "continuation.h"

Include dependency graph for continuation.c:

Go to the source code of this file.

Functions
static void	module_continuation_conditions (statement mod_stat)
	statement stack More...
static void	statement_continuation_conditions (statement s)
	static void statement_continuation_conditions(statement s) input : the current instruction output : nothing modifies : continuation conditions maps comment : More...
static void	block_continuation_conditions (list l_stat)
static void	test_continuation_conditions (test t)
static void	loop_continuation_conditions (loop l)
static void	call_continuation_conditions (call c)
static void	unstructured_continuation_conditions (unstructured u)
static void	module_summary_continuation_conditions (statement mod_stat)
	INTERPROCEDURAL SUMMARIZATION. More...
bool	continuation_conditions (const string module_name)
	INTERFACE More...

Variables
static transformer	must_sum_cont_t = transformer_undefined
	package continuation : Be'atrice Creusillet, 1996 More...
static transformer	may_sum_cont_t = transformer_undefined

Function Documentation

block_continuation_conditions()

static void block_continuation_conditions ( list  l_stat )

static

Definition at line 218 of file continuation.c.

{
  pips_assert("true", l_stat==l_stat);
 
    statement s = current_stmt_head();
 
    store_statement_must_continuation(s,transformer_empty());
    store_statement_may_continuation(s,transformer_identity());
}

References current_stmt_head, pips_assert, store_statement_may_continuation(), store_statement_must_continuation(), transformer_empty(), and transformer_identity().

Referenced by statement_continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

call_continuation_conditions()

static void call_continuation_conditions ( call  c )

static

Definition at line 247 of file continuation.c.

{
  pips_assert("true", c==c);
 
    statement s = current_stmt_head();
    
    store_statement_must_continuation(s,transformer_empty());
    store_statement_may_continuation(s,transformer_identity());
}

References current_stmt_head, pips_assert, store_statement_may_continuation(), store_statement_must_continuation(), transformer_empty(), and transformer_identity().

Referenced by statement_continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

continuation_conditions()

bool continuation_conditions

(

const string

module_name

)

INTERFACE

Get the code of the module.

predicates defining summary regions from callees have to be translated into variables local to module

cumulated effects

Get the transformers of the module.

initialisation of local maps

Parameters

module_name

odule_name

Definition at line 91 of file continuation.c.

{
 
    /* Get the code of the module. */
    set_current_module_statement( (statement)
        db_get_memory_resource(DBR_CODE, module_name, true) );
    /* predicates defining summary regions from callees have to be 
       translated into variables local to module */
    set_current_module_entity( local_name_to_top_level_entity(module_name) );
    /* cumulated effects */
    set_cumulated_rw_effects((statement_effects)
           db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
    set_proper_rw_effects((statement_effects)
           db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
    module_to_value_mappings(get_current_module_entity());
    
    /* Get the transformers of the module. */
    set_transformer_map( (statement_mapping)
        db_get_memory_resource(DBR_TRANSFORMERS, module_name, true) );  
 
    /* initialisation of local maps */
    set_must_continuation_map( MAKE_STATEMENT_MAPPING() );
    set_may_continuation_map( MAKE_STATEMENT_MAPPING() );
 
    debug_on("CONTINUATION_DEBUG_LEVEL");
    module_continuation_conditions(get_current_module_statement());
    module_summary_continuation_conditions(get_current_module_statement());
    debug_off();
 
    DB_PUT_MEMORY_RESOURCE(DBR_MUST_CONTINUATION, 
                           strdup(module_name),
                           (char*) get_must_continuation_map() );
    DB_PUT_MEMORY_RESOURCE(DBR_MAY_CONTINUATION, 
                           strdup(module_name),
                           (char*) get_may_continuation_map() );
    DB_PUT_MEMORY_RESOURCE(DBR_MUST_SUMMARY_CONTINUATION, 
                           strdup(module_name),
                           (char*) must_sum_cont_t);
    DB_PUT_MEMORY_RESOURCE(DBR_MAY_SUMMARY_CONTINUATION, 
                           strdup(module_name),
                           (char*) may_sum_cont_t);
    reset_current_module_entity();
    reset_current_module_statement();
    reset_transformer_map();
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_must_continuation_map();
    reset_may_continuation_map();
    free_value_mappings();
 
    return(true);
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, free_value_mappings(), get_current_module_entity(), get_current_module_statement(), get_may_continuation_map(), get_must_continuation_map(), local_name_to_top_level_entity(), MAKE_STATEMENT_MAPPING, may_sum_cont_t, module_continuation_conditions(), module_name(), module_summary_continuation_conditions(), module_to_value_mappings(), must_sum_cont_t, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_may_continuation_map(), reset_must_continuation_map(), reset_proper_rw_effects(), reset_transformer_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_may_continuation_map(), set_must_continuation_map(), set_proper_rw_effects(), set_transformer_map(), and strdup().

Here is the call graph for this function:

loop_continuation_conditions()

static void loop_continuation_conditions ( loop  l )

static

Definition at line 237 of file continuation.c.

{
  pips_assert("true", l==l);
 
    statement s = current_stmt_head();
 
    store_statement_must_continuation(s,transformer_empty());
    store_statement_may_continuation(s,transformer_identity());
}

References current_stmt_head, pips_assert, store_statement_may_continuation(), store_statement_must_continuation(), transformer_empty(), and transformer_identity().

Referenced by statement_continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

module_continuation_conditions()

static void module_continuation_conditions ( statement  mod_stat )

static

statement stack

LOCAL FUNCTION

LOCAL FUNCTION HEADERS

INTRAPROCEDURAL PROPAGATION static void module_continuation_conditions(statement mod_stat) input : main statement of the current module output : nothing modifies : continuation conditions maps comment :

Definition at line 156 of file continuation.c.

{
    make_current_stmt_stack();
    gen_recurse(mod_stat, statement_domain, gen_true,
                statement_continuation_conditions);
    free_current_stmt_stack();
}

References gen_recurse, gen_true(), mod_stat, statement_continuation_conditions(), and statement_domain.

Referenced by continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

module_summary_continuation_conditions()

static void module_summary_continuation_conditions ( statement  mod_stat )

static

INTERPROCEDURAL SUMMARIZATION.

static void module_summary_continuation_conditions(statement mod_stat) input : main statement of the current module output : nothing modifies : continuation conditions maps comment :

Definition at line 294 of file continuation.c.

{
  pips_assert("true", mod_stat==mod_stat);
 
    must_sum_cont_t = transformer_empty();
    may_sum_cont_t = transformer_identity();   
}

References may_sum_cont_t, mod_stat, must_sum_cont_t, pips_assert, transformer_empty(), and transformer_identity().

Referenced by continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_continuation_conditions()

static void statement_continuation_conditions ( statement  s )

static

static void statement_continuation_conditions(statement s) input : the current instruction output : nothing modifies : continuation conditions maps comment :

Definition at line 172 of file continuation.c.

{
    instruction i = statement_instruction(s);
 
    pips_debug(1, "BEGIN: statement %03td\n", statement_number(s));
 
    current_stmt_push(s);
    switch(instruction_tag(i))
    {
    case is_instruction_goto:
        store_statement_must_continuation(s,transformer_identity());
        store_statement_may_continuation(s,transformer_identity());
        break;
 
    case is_instruction_block:
        pips_debug(3, "block\n");
        block_continuation_conditions(instruction_block(i));
        break;
 
    case is_instruction_test:
        pips_debug(3, "test\n");
        test_continuation_conditions(instruction_test(i));
        break;
 
    case is_instruction_loop:
        pips_debug(3, "loop\n");
        loop_continuation_conditions(instruction_loop(i));
        break;
 
    case is_instruction_call:
        pips_debug(3, "call\n");
        call_continuation_conditions(instruction_call(i));
        break;
 
    case is_instruction_unstructured:
        pips_debug(3, "unstructured\n");
        unstructured_continuation_conditions(instruction_unstructured( i ));
        break ;
 
    default:
        pips_debug(1, "unexpected tag %d\n", instruction_tag(i));
    }
    current_stmt_pop();
    pips_debug(1,"END: statement %03td\n", statement_number(s));
}

References block_continuation_conditions(), call_continuation_conditions(), instruction_block, instruction_call, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, is_instruction_block, is_instruction_call, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, loop_continuation_conditions(), pips_debug, statement_instruction, statement_number, store_statement_may_continuation(), store_statement_must_continuation(), test_continuation_conditions(), transformer_identity(), and unstructured_continuation_conditions().

Referenced by module_continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

test_continuation_conditions()

static void test_continuation_conditions ( test  t )

static

Definition at line 228 of file continuation.c.

{
  pips_assert("true", t==t);
    statement s = current_stmt_head();
 
    store_statement_must_continuation(s,transformer_empty());
    store_statement_may_continuation(s,transformer_identity());
}

References current_stmt_head, pips_assert, store_statement_may_continuation(), store_statement_must_continuation(), transformer_empty(), and transformer_identity().

Referenced by statement_continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

unstructured_continuation_conditions()

static void unstructured_continuation_conditions ( unstructured  u )

static

there is only one statement in u; no need for a fix-point

nothing clever for the moment - 28/2/96 - BC

Definition at line 257 of file continuation.c.

{
  pips_assert("true", u==u);
 
    statement s = current_stmt_head();
    transformer must_cont_t, may_cont_t;
    control c;
 
    c = unstructured_control( u );
 
    if(control_predecessors(c) == NIL && control_successors(c) == NIL)
    {
        /* there is only one statement in u; no need for a fix-point */
        must_cont_t = transformer_dup
            (load_statement_must_continuation(control_statement(c))); 
        may_cont_t = transformer_dup
            (load_statement_may_continuation(control_statement(c))); 
    }
    else
    {
        /* nothing clever for the moment - 28/2/96 - BC*/
        must_cont_t = transformer_empty();
        may_cont_t = transformer_identity();
    }    
    store_statement_must_continuation(s,must_cont_t);
    store_statement_may_continuation(s,may_cont_t);
}

References control_predecessors, control_statement, control_successors, current_stmt_head, load_statement_may_continuation(), load_statement_must_continuation(), NIL, pips_assert, store_statement_may_continuation(), store_statement_must_continuation(), transformer_dup(), transformer_empty(), transformer_identity(), and unstructured_control.

Referenced by statement_continuation_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

may_sum_cont_t

transformer may_sum_cont_t = transformer_undefined

static

Definition at line 68 of file continuation.c.

Referenced by continuation_conditions(), get_continuation_condition_text(), and module_summary_continuation_conditions().

must_sum_cont_t

transformer must_sum_cont_t = transformer_undefined

static

package continuation : Be'atrice Creusillet, 1996

This File contains the functions computing continuation conditions of a module (over- and under-approximations. LOCAL DEFINITIONS
CONTINUATION CONDITION MAPS AND SUMMARIES

Definition at line 67 of file continuation.c.

Referenced by continuation_conditions(), get_continuation_condition_text(), and module_summary_continuation_conditions().