simple_atomize.c File Reference

#include <stdio.h>
#include <string.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 "misc.h"
#include "properties.h"

Include dependency graph for simple_atomize.c:

Go to the source code of this file.

Functions
static void	atomize_object (gen_chunk *)
	void atomize_as_required(stat, ref_decide, call_decide, test_decide, range_decide, while_decide, new) statement stat; bool (*ref_decide)(ref r, expression e); bool (*call_decide)(call r, expression e); bool (*test_decide)(test t, expression e); bool (*range_decide)(range r, expression e), bool (*while_decide)(whileloop w, expression e), entity (*new)(entity m, basic b); More...
static void	simple_atomize_error_handler ()
	the stack of the encoutered statements is maintained to be able to insert the needed computations just before the very last statement encountered. More...
static void	insert_before_current_statement (statement s)
	s is inserted before the current statement. More...
statement	atomize_this_expression (entity(*create)(entity, basic), expression e)
	returns the assignment statement is moved, or NULL if not. More...
static void	compute_before_current_statement (expression *pe)
static void	ref_rwt (reference r)
static void	call_rwt (call c)
static void	exp_range_rwt (range r, expression *pe)
static void	range_rwt (range r)
static void	test_rwt (test t)
static void	whileloop_rwt (whileloop w)
static void	cleanup_subscript (expression e)
static void	cleanup_subscript_pre (expression exp)
void	cleanup_subscripts (void *obj)
void	atomize_as_required (statement stat, bool(*ref_decide)(reference, expression), bool(*call_decide)(call, expression), bool(*test_decide)(test, expression), bool(*range_decide)(range, expression), bool(*while_decide)(whileloop, expression), entity(*new)(entity, basic))

Variables
static bool(*	ref_atomize_decision )() = NULL
	static functions used More...
static bool(*	call_atomize_decision )() = NULL
static bool(*	test_atomize_decision )() = NULL
static bool(*	range_atomize_decision )() = NULL
static bool(*	while_atomize_decision )() = NULL
static entity(*	create_new_variable )() = NULL

Function Documentation

atomize_as_required()

void atomize_as_required	(	statement	stat,
		bool(*)(reference, expression)	ref_decide,
		bool(*)(call, expression)	call_decide,
		bool(*)(test, expression)	test_decide,
		bool(*)(range, expression)	range_decide,
		bool(*)(whileloop, expression)	while_decide,
		entity(*)(entity, basic)	new
	)

Parameters

stat	tat
call_decide	reference
test_decide	call
range_decide	test
while_decide	range
new	whileloop

Definition at line 392 of file simple_atomize.c.

{
  ifdebug(5) {
    pips_debug(5,
               "Statement at entry:\n");
    print_statement(stat);
  }
  reset_hooks_register(simple_atomize_error_handler);
  make_current_statement_stack();
  make_current_control_stack();
  ref_atomize_decision = ref_decide;
  call_atomize_decision = call_decide;
  test_atomize_decision = test_decide;
  range_atomize_decision = range_decide;
  while_atomize_decision = while_decide;
  create_new_variable = new;
 
  atomize_object((gen_chunkp) stat);
 
  ref_atomize_decision = NULL;
  call_atomize_decision = NULL;
  test_atomize_decision = NULL;
  range_atomize_decision = NULL;
  while_atomize_decision = NULL;
  create_new_variable = NULL;
  free_current_statement_stack();
  free_current_control_stack();
  reset_hooks_unregister(simple_atomize_error_handler);
 
  ifdebug(5) {
    pips_debug(5,
               "Statement at exit:\n");
    print_statement(stat);
  }
}

References atomize_object(), call_atomize_decision, create_new_variable, ifdebug, pips_debug, print_statement(), range_atomize_decision, ref_atomize_decision, reset_hooks_register(), reset_hooks_unregister(), simple_atomize_error_handler(), test_atomize_decision, and while_atomize_decision.

Referenced by normalize_wp65_code(), and NormalizeCodeForHpfc().

Here is the call graph for this function:

Here is the caller graph for this function:

atomize_object()

static void atomize_object ( gen_chunk *  obj )

static

void atomize_as_required(stat, ref_decide, call_decide, test_decide, range_decide, while_decide, new) statement stat; bool (*ref_decide)(ref r, expression e); bool (*call_decide)(call r, expression e); bool (*test_decide)(test t, expression e); bool (*range_decide)(range r, expression e), bool (*while_decide)(whileloop w, expression e), entity (*new)(entity m, basic b);

atomizes the given statement as driven by the given functions. ??? does not care of any side effect and so.

• ref_decide tells whether or not to atomize for reference r and expression indice e of this reference. If yes, expression e is computed outside.
• call_decide tells whether or not to atomize for call c and argument expression e...
• test_decide tells whether expression condition e of a test should be atomized or not.
• new creates a new entity in the current module, the basic type of which should be t.

CONTROL

STATEMENT

REFERENCE

TEST

CALL

RANGE

WHILELOOP

Definition at line 375 of file simple_atomize.c.

{
  gen_multi_recurse
    (obj,
     control_domain, current_control_filter,
     current_control_rewrite,     /* CONTROL */
     statement_domain, current_statement_filter,
     current_statement_rewrite,   /* STATEMENT */
     reference_domain, gen_true, ref_rwt,      /* REFERENCE */
     test_domain, gen_true, test_rwt,          /* TEST */
     call_domain, gen_true, call_rwt,          /* CALL */
     range_domain, gen_true, range_rwt,        /* RANGE */
     whileloop_domain, gen_true, whileloop_rwt,/* WHILELOOP */
     NULL);
  cleanup_subscripts(obj);
}

References call_domain, call_rwt(), cleanup_subscripts(), control_domain, gen_multi_recurse(), gen_true(), range_domain, range_rwt(), ref_rwt(), reference_domain, statement_domain, test_domain, test_rwt(), whileloop_domain, and whileloop_rwt().

Referenced by atomize_as_required().

Here is the call graph for this function:

Here is the caller graph for this function:

atomize_this_expression()

statement atomize_this_expression	(	entity(*)(entity, basic)	create,
		expression	e
	)

returns the assignment statement is moved, or NULL if not.

simple_atomize.c

it does not make sense to atomize a range...

Definition at line 181 of file simple_atomize.c.

{
    /* it does not make sense to atomize a range...
    */
    if (syntax_range_p(expression_syntax(e))) return NULL;
 
    basic bofe = basic_of_expression(e);
    statement out = NULL;
    if(!basic_undefined_p(bofe)) {
        if (!basic_overloaded_p(bofe))
        {
            bool skip_this_expression = false;
            if( get_bool_property("COMMON_SUBEXPRESSION_ELIMINATION_SKIP_ADDED_CONSTANT") && expression_call_p(e) )
            {
                call c = expression_call(e);
                entity op = call_function(c);
                if(ENTITY_PLUS_P(op) || ENTITY_PLUS_C_P(op) || ENTITY_PLUS_UPDATE_P(op))
                {
                    FOREACH(EXPRESSION,arg,call_arguments(c))
                        skip_this_expression|=expression_constant_p(arg);
                }
 
            }
 
            if(!skip_this_expression) {
                ifdebug(1) {
                    pips_debug(1,"atomizing expression:\n");
                    print_expression(e);
                }
                entity newvar = (*create)(get_current_module_entity(), copy_basic(bofe));
                AddEntityToCurrentModule(newvar);
                expression rhs = make_expression(expression_syntax(e), normalized_undefined);
                normalize_all_expressions_of(rhs);
 
                syntax ref = make_syntax_reference(make_reference(newvar, NIL));
 
                out = make_assign_statement(make_expression(copy_syntax(ref), normalized_undefined), rhs);
                expression_syntax(e) = ref;
            }
        }
    }
    free_basic(bofe);
    return out;
}

References AddEntityToCurrentModule(), basic_of_expression(), basic_overloaded_p, basic_undefined_p, call_arguments, call_function, copy_basic(), copy_syntax(), ENTITY_PLUS_C_P, ENTITY_PLUS_P, ENTITY_PLUS_UPDATE_P, EXPRESSION, expression_call(), expression_call_p(), expression_constant_p(), expression_syntax, FOREACH, free_basic(), get_bool_property(), get_current_module_entity(), ifdebug, make_assign_statement(), make_expression(), make_reference(), make_syntax_reference(), NIL, normalize_all_expressions_of(), normalized_undefined, out, pips_debug, print_expression(), ref, and syntax_range_p.

Referenced by atom_cse_expression(), atomize_or_associate_for_level(), compute_before_current_statement(), and do_atomize_if_different_level().

Here is the call graph for this function:

Here is the caller graph for this function:

call_rwt()

static void call_rwt ( call  c )

static

(panic mode:-)

syntax saved = expression_syntax(*pe);

atomize_object(saved);

Definition at line 252 of file simple_atomize.c.

{
  if (same_string_p(entity_local_name(call_function(c)), IMPLIED_DO_NAME))
    return; /* (panic mode:-) */
 
  MAPL(ce,
       {
         expression *pe = (expression*) REFCAR(ce);
 
         if ((*call_atomize_decision)(c, *pe))
         {
           /* syntax saved = expression_syntax(*pe);*/
 
           compute_before_current_statement(pe);
           /* atomize_object(saved); */
         }
       },
       call_arguments(c));
}

References call_arguments, call_atomize_decision, call_function, compute_before_current_statement(), entity_local_name(), IMPLIED_DO_NAME, MAPL, REFCAR, and same_string_p.

Referenced by atomize_object().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_subscript()

static void cleanup_subscript ( expression  e )

static

the subscript could be a reference !

update reference with additionnal indices

prepare to free subscript

transform subscript into reference

Definition at line 326 of file simple_atomize.c.

{
  if(syntax_subscript_p(expression_syntax(e)))
  {
    subscript s = syntax_subscript(expression_syntax(e));
    if(expression_reference_p(subscript_array(s)))
      /* the subscript could be a reference ! */
    {
      syntax sa = expression_syntax(subscript_array(s));
 
      /* update reference with additionnal indices */
      reference r = syntax_reference(sa);
      reference_indices(r)=gen_nconc(reference_indices(r),subscript_indices(s));
      /* prepare to free subscript */
      subscript_indices(s)=NIL;
      expression_syntax(subscript_array(s))=syntax_undefined;
      free_subscript(s);
      /* transform subscript into reference */
      syntax_tag(expression_syntax(e))=is_syntax_reference;
      syntax_reference(expression_syntax(e))=r;
    }
  }
}

References expression_reference_p(), expression_syntax, free_subscript(), gen_nconc(), is_syntax_reference, NIL, reference_indices, subscript_array, subscript_indices, syntax_reference, syntax_subscript, syntax_subscript_p, syntax_tag, and syntax_undefined.

Referenced by cleanup_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_subscript_pre()

static void cleanup_subscript_pre ( expression  exp )

static

Definition at line 350 of file simple_atomize.c.

{
  if(expression_call_p(exp)) {
    call c = expression_call(exp);
    if(ENTITY_DEREFERENCING_P(call_function(c))) {
      expression lhs = binary_call_lhs(c);
      if(expression_call_p(lhs)) {
        call c = expression_call(lhs);
        if(ENTITY_ADDRESS_OF_P(call_function(c))) {
          expression lhs = binary_call_lhs(c);
          syntax syn = expression_syntax(lhs);
          expression_syntax(lhs)=syntax_undefined;
          update_expression_syntax(exp,syn);
        }
      }
    }
  }
}

References binary_call_lhs, call_function, ENTITY_ADDRESS_OF_P, ENTITY_DEREFERENCING_P, exp, expression_call(), expression_call_p(), expression_syntax, syntax_undefined, and update_expression_syntax().

Referenced by cleanup_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_subscripts()

void cleanup_subscripts

(

void *

obj

)

Parameters

obj

bj

Definition at line 369 of file simple_atomize.c.

{
  gen_recurse(obj, expression_domain, gen_true, cleanup_subscript_pre);
  gen_recurse(obj, expression_domain, gen_true, cleanup_subscript);
}

References cleanup_subscript(), cleanup_subscript_pre(), expression_domain, gen_recurse, and gen_true().

Referenced by atomize_object(), convert_pointer_to_array(), do_linearize_prepatch_subscripts(), insert_before_statement(), linearize_array_generic(), perform_ac_cse(), and split_structures().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_before_current_statement()

static void compute_before_current_statement ( expression *  pe )

static

Definition at line 228 of file simple_atomize.c.

{
    statement stat = atomize_this_expression(create_new_variable,*pe);
    if (stat) insert_before_current_statement(stat);
}

References atomize_this_expression(), create_new_variable, and insert_before_current_statement().

Referenced by call_rwt(), exp_range_rwt(), ref_rwt(), test_rwt(), and whileloop_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

exp_range_rwt()

static void exp_range_rwt ( range  r, expression *  pe  )

static

syntax saved = expression_syntax(*pe);

atomize_object(saved);

Definition at line 273 of file simple_atomize.c.

{
  if ((*range_atomize_decision)(r, *pe))
  {
    /* syntax saved = expression_syntax(*pe); */
    compute_before_current_statement(pe);
    /* atomize_object(saved);*/
  }
}

References compute_before_current_statement(), and range_atomize_decision.

Referenced by range_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_before_current_statement()

static void insert_before_current_statement ( statement  s )

static

s is inserted before the current statement.

if it is a block, it is added just before the last statement of the block, else a block statement is created in place of the current statement.

it is in an unstructured, and s is to be inserted properly

update the other lists

new current statement, to avoid other control insertions

of statement

insert statement before the last one

Definition at line 100 of file simple_atomize.c.

{
  statement   cs = current_statement_head();
  instruction  i = statement_instruction(cs);
  control     cc = current_control_empty_p() ?
    control_undefined : current_control_head() ;
 
  if (!control_undefined_p(cc) && control_statement(cc)==cs)
  {
    /* it is in an unstructured, and s is to be inserted properly
     */
    bool seen;
    control newc;
 
    pips_debug(8, "unstructured\n");
 
    newc = make_control(s, control_predecessors(cc), 
                        CONS(CONTROL, cc, NIL));
    control_predecessors(cc) = CONS(CONTROL, newc, NIL);
 
    /*   update the other lists
     */
    MAPL(c1,
         {
           seen=false;
 
           MAPL(c2,
                {
                  if (CONTROL(CAR(c2))==cc) 
                  {
                    CONTROL_(CAR(c2))=newc;
                    seen=true;
                  }
                },
                control_successors(CONTROL(CAR(c1))));
 
           assert(seen);
         },
         control_predecessors(newc));
 
        /*   new current statement, to avoid other control insertions
         */
    current_statement_replace(s);
    gen_recurse_stop(newc);
  }
  else
  {
    pips_debug(7, "statement\n");
 
    if (instruction_block_p(i)) {
          list /* of statement */ block = instruction_block(i);
          /* insert statement before the last one */
          block = gen_insert_before(s,
                              STATEMENT(CAR(gen_last(block))),
                              block);
    }
    else {
      statement_instruction(cs) =
        make_instruction_block(
          CONS(STATEMENT, s,
               CONS(STATEMENT,
                    make_statement(statement_label(cs),
                                   statement_number(cs),
                                   statement_ordering(cs),
                                   statement_comments(cs),
                                   statement_instruction(cs),
                                   NIL, NULL,
                                   statement_extensions(cs),
                                   make_synchronization_none()),
                    NIL)));
      statement_label(cs) = entity_empty_label();
      statement_number(cs) = STATEMENT_NUMBER_UNDEFINED;
      statement_ordering(cs) = STATEMENT_ORDERING_UNDEFINED;
      statement_comments(cs) = empty_comments;
      statement_extensions(cs) = empty_extensions ();
    }
  }
}

References assert, CAR, CONS, CONTROL, CONTROL_, control_predecessors, control_statement, control_successors, control_undefined, control_undefined_p, empty_comments, empty_extensions(), entity_empty_label(), gen_insert_before(), gen_last(), gen_recurse_stop(), instruction_block, instruction_block_p, make_control(), make_instruction_block(), make_statement(), make_synchronization_none(), MAPL, NIL, pips_debug, seen, STATEMENT, statement_comments, statement_extensions, statement_instruction, statement_label, statement_number, STATEMENT_NUMBER_UNDEFINED, statement_ordering, and STATEMENT_ORDERING_UNDEFINED.

Referenced by compute_before_current_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

range_rwt()

static void range_rwt ( range  r )

static

lower

upper

increment

Definition at line 283 of file simple_atomize.c.

{
  /* lower */
  exp_range_rwt(r, &range_lower(r));
 
  /* upper */
  exp_range_rwt(r, &range_upper(r));
 
  /* increment */
  exp_range_rwt(r, &range_increment(r));
}

References exp_range_rwt(), range_increment, range_lower, and range_upper.

Referenced by atomize_object().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_rwt()

static void ref_rwt ( reference  r )

static

syntax saved = expression_syntax(*pe);

atomize_object(saved);

return(false);

Definition at line 234 of file simple_atomize.c.

{
  MAPL(ce,
       {
         expression *pe = (expression*) REFCAR(ce);
 
         if ((*ref_atomize_decision)(r, *pe))
         {
           /* syntax saved = expression_syntax(*pe);*/
           compute_before_current_statement(pe);
           /* atomize_object(saved); */
         }
       },
       reference_indices(r));
 
  /* return(false);*/
}

References compute_before_current_statement(), MAPL, ref_atomize_decision, REFCAR, and reference_indices.

Referenced by atomize_object().

Here is the call graph for this function:

Here is the caller graph for this function:

simple_atomize_error_handler()

static void simple_atomize_error_handler ( )

static

the stack of the encoutered statements is maintained to be able to insert the needed computations just before the very last statement encountered.

The use of a stack is not necessary, since there are no effective rewrite. but it could have been... It enables some recursive calls that would have required to save the current statement explicitely otherwise.

Definition at line 90 of file simple_atomize.c.

{
  error_reset_current_statement_stack();
  error_reset_current_control_stack();
}

Referenced by atomize_as_required().

Here is the caller graph for this function:

test_rwt()

static void test_rwt ( test  t )

static

syntax saved = expression_syntax(*pe);

else I have to break the condition and to complete the recursion.

atomize_object(saved);

Definition at line 296 of file simple_atomize.c.

{
  expression *pe = &test_condition(t);
 
  if ((*test_atomize_decision)(t, *pe))
  {
    /* syntax saved = expression_syntax(*pe);*/
    /*   else I have to break the condition
     *   and to complete the recursion.
     */
    compute_before_current_statement(pe);
    /* atomize_object(saved); */
  }
}

References compute_before_current_statement(), test_atomize_decision, and test_condition.

Referenced by atomize_object().

Here is the call graph for this function:

Here is the caller graph for this function:

whileloop_rwt()

static void whileloop_rwt ( whileloop  w )

static

syntax saved = expression_syntax(*pe);

else I have to break the condition and to complete the recursion.

atomize_object(saved);

Definition at line 311 of file simple_atomize.c.

{
  expression *pe = &whileloop_condition(w);
 
  if ((*while_atomize_decision)(w, *pe))
  {
    /* syntax saved = expression_syntax(*pe); */
    /*   else I have to break the condition
     *   and to complete the recursion.
     */
    compute_before_current_statement(pe);
    /* atomize_object(saved);*/
  }
}

References compute_before_current_statement(), while_atomize_decision, and whileloop_condition.

Referenced by atomize_object().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

call_atomize_decision

bool(* call_atomize_decision) () ( ) = NULL

static

Definition at line 71 of file simple_atomize.c.

Referenced by atomize_as_required(), and call_rwt().

create_new_variable

entity(* create_new_variable) () ( ) = NULL

static

Definition at line 76 of file simple_atomize.c.

Referenced by atomize_as_required(), and compute_before_current_statement().

range_atomize_decision

bool(* range_atomize_decision) () ( ) = NULL

static

Definition at line 73 of file simple_atomize.c.

Referenced by atomize_as_required(), and exp_range_rwt().

ref_atomize_decision

bool(* ref_atomize_decision) () ( ) = NULL

static

static functions used

Definition at line 70 of file simple_atomize.c.

Referenced by atomize_as_required(), and ref_rwt().

test_atomize_decision

bool(* test_atomize_decision) () ( ) = NULL

static

Definition at line 72 of file simple_atomize.c.

Referenced by atomize_as_required(), and test_rwt().

while_atomize_decision

bool(* while_atomize_decision) () ( ) = NULL

static

Definition at line 74 of file simple_atomize.c.

Referenced by atomize_as_required(), and whileloop_rwt().