freia_transformations.c File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "misc.h"
#include "ri-util.h"
#include "effects-util.h"
#include "callgraph.h"
#include "properties.h"
#include "resources.h"
#include "pipsdbm.h"
#include "control.h"
#include "effects-generic.h"
#include "freia.h"
#include "hwac.h"

Include dependency graph for freia_transformations.c:

Go to the source code of this file.

Data Structures
struct	vis_ctx
	look for a variable More...
struct	fcs_ctx
struct	subs_ctx
	util defined somewhere ?????? More...
struct	rssp_ctx
struct	shuffle_context

Macros
#define	starts_with(s1, s2)   (strncmp(s1, s2, strlen(s2))==0) /**a la java */
#define	entity_update_p(e)

Functions
static list	remove_register (list lq)
	remove "register" qualifier from qualifier list More...
static bool	sr_flt (statement s, int *number)
static void	stmt_renumber (statement s)
static void	vis_rwt (const reference r, vis_ctx *ctx)
static bool	variable_is_used (statement s, entity var)
static bool	fcs_count (statement s, fcs_ctx *ctx)
static bool	freia_convergence_sequence_p (sequence sq)
static void	ref_rwt (reference r, subs_ctx *ctx)
static void	substitute_reference_variable (statement s, entity ovar, entity nvar)
static void	maybe_unroll_while_rwt (whileloop wl, bool *changed)
static bool	freia_unroll_while_for_spoc (statement s)
bool	freia_unroll_while (const string module)
	freia_transformations.c More...
static entity	freia_reduction_variable (const statement s)
	return the freia reduction entity, or NULL if it does not apply More...
static void	sww_seq_rwt (const sequence sq, bool *changed)
bool	freia_remove_scalar_ww_deps (const string module)
static entity	address_of_scalar (expression e)
	"&v"? return v, else return NULL More...
static bool	pointer_candidate_p (entity var)
static void	rssp_ref (reference r, rssp_ctx *ctx)
bool	remove_simple_scalar_pointers (const string module)
static bool	sio_call_flt (call c, _UNUSED_ shuffle_context *ctx)
static void	sio_ref_rwt (reference r, shuffle_context *ctx)
static void	substitute_image_occurrences (void *s, shuffle_context *ctx)
static void	seq_rwt (sequence sq, shuffle_context *ctx)
static void	ref_count_rwt (reference r, hash_table counts)
static bool	call_count_flt (call c, _UNUSED_ hash_table counts)
void	freia_shuffle_move_forward (statement s)

Macro Definition Documentation

entity_update_p

#define entity_update_p

(

e

)

Value:

  (ENTITY_MULTIPLY_UPDATE_P(e) || ENTITY_DIVIDE_UPDATE_P(e) ||         \
   ENTITY_MODULO_UPDATE_P(e) || ENTITY_PLUS_UPDATE_P(e) ||             \
   ENTITY_MINUS_UPDATE_P(e) || ENTITY_LEFT_SHIFT_UPDATE_P(e) ||        \
   ENTITY_RIGHT_SHIFT_UPDATE_P(e) || ENTITY_BITWISE_AND_UPDATE_P(e) || \
   ENTITY_BITWISE_XOR_UPDATE_P(e) || ENTITY_BITWISE_OR_UPDATE_P(e))

Definition at line 704 of file freia_transformations.c.

starts_with

#define starts_with	(		s1,
			s2
	)		(strncmp(s1, s2, strlen(s2))==0) /**a la java */

Definition at line 702 of file freia_transformations.c.

Function Documentation

address_of_scalar()

static entity address_of_scalar ( expression  e )

static

"&v"? return v, else return NULL

Definition at line 484 of file freia_transformations.c.

{
  if (!expression_call_p(e)) return NULL;
  call c = expression_call(e);
  if (!ENTITY_ADDRESS_OF_P(call_function(c))) return NULL;
  list la = call_arguments(c);
  pips_assert("one argument to &", gen_length(la)==1);
  expression a = EXPRESSION(CAR(la));
  if (!expression_reference_p(a)) return NULL;
  reference r = expression_reference(a);
  if (reference_indices(r)) return NULL;
  entity v = reference_variable(r);
  if (entity_scalar_p(v))
    return v;
  return NULL;
}

References call_arguments, call_function, CAR, ENTITY_ADDRESS_OF_P, entity_scalar_p(), EXPRESSION, expression_call(), expression_call_p(), expression_reference(), expression_reference_p(), gen_length(), pips_assert, reference_indices, and reference_variable.

Referenced by remove_simple_scalar_pointers(), and rssp_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

call_count_flt()

static bool call_count_flt ( call  c, _UNUSED_ hash_table  counts  )

static

Definition at line 850 of file freia_transformations.c.

{
  if (ENTITY_ASSIGN_P(call_function(c)))
  {
    list args = call_arguments(c);
    pips_assert(gen_length(args) == 2, "2 args to assign");
    expression e1 = EXPRESSION(CAR(args));
    if (expression_reference_p(e1))
    {
      reference r1 = expression_reference(e1);
      gen_recurse_stop(r1);
      // deal with x = x
      expression e2 = EXPRESSION(CAR(CDR(args)));
      if (expression_reference_p(e2))
      {
        reference r2 = expression_reference(e2);
        if (reference_variable(r1) == reference_variable(r2) &&
            reference_indices(r1) == NIL &&
            reference_indices(r2) == NIL)
          return false;
      }
    }
  }
  return true;
}

References call_arguments, call_function, CAR, CDR, ENTITY_ASSIGN_P, EXPRESSION, expression_reference(), expression_reference_p(), gen_length(), gen_recurse_stop(), NIL, pips_assert, reference_indices, and reference_variable.

Referenced by freia_shuffle_move_forward().

Here is the call graph for this function:

Here is the caller graph for this function:

fcs_count()

static bool fcs_count ( statement  s, fcs_ctx *  ctx  )

static

Definition at line 142 of file freia_transformations.c.

{
  if (!statement_call_p(s))
  {
    ctx->bad_stuff = true;
    gen_recurse_stop(NULL);
  }
  else
  {
    call c = freia_statement_to_call(s);
    if (c)
    {
      const char* called = entity_local_name(call_function(c));
      // could be: dilate + inf + vol or erode + sup + vol
      if (same_string_p(called, AIPO "erode_8c") ||
          same_string_p(called, AIPO "erode_6c") ||
          same_string_p(called, AIPO "dilate_8c") ||
          same_string_p(called, AIPO "dilate_6c"))
        ctx->morpho++;
      else if (same_string_p(called, AIPO "inf") ||
               same_string_p(called, AIPO "sup"))
        ctx->comp++;
      else if (same_string_p(called, AIPO "global_vol"))
        ctx->vol++;
      // else { // should do more filtering!
      // ctx->bad_stuff = true;
      // gen_recurse_stop(NULL);
      // }
    }
  }
  return false;
}

References AIPO, fcs_ctx::bad_stuff, call_function, fcs_ctx::comp, entity_local_name(), freia_statement_to_call(), gen_recurse_stop(), fcs_ctx::morpho, same_string_p, statement_call_p(), and fcs_ctx::vol.

Referenced by freia_convergence_sequence_p().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_convergence_sequence_p()

static bool freia_convergence_sequence_p ( sequence  sq )

static

Returns

whether sq contains freia simple calls to E/D, </>, vol, = this is rather an over approximation of whether it is a convergence sequence, should be refined...

Definition at line 179 of file freia_transformations.c.

{
  fcs_ctx ctx = { 0, 0, 0, false };
  gen_context_recurse(sq, &ctx, statement_domain, fcs_count, gen_null2);
  return ctx.morpho==1 && ctx.comp==1 && ctx.vol==1 && !ctx.bad_stuff;
}

References fcs_ctx::bad_stuff, fcs_ctx::comp, fcs_count(), gen_context_recurse, gen_null2(), fcs_ctx::morpho, statement_domain, and fcs_ctx::vol.

Referenced by maybe_unroll_while_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_reduction_variable()

static entity freia_reduction_variable ( const statement  s )

static

return the freia reduction entity, or NULL if it does not apply

Definition at line 335 of file freia_transformations.c.

{
  if (freia_statement_aipo_call_p(s))
  {
    const call c = freia_statement_to_call(s);
    const string called = (const string) entity_local_name(call_function(c));
    if (same_string_p(called, AIPO "global_min") ||
        same_string_p(called, AIPO "global_max") ||
        same_string_p(called, AIPO "global_min_coord") ||
        same_string_p(called, AIPO "global_max_coord") ||
        same_string_p(called, AIPO "global_vol"))
    {
      const expression last = EXPRESSION(CAR(gen_last(call_arguments(c))));
      // should be a call to "&" operator
      if (expression_address_of_p(last))
      {
        const expression arg =
          EXPRESSION(CAR(call_arguments(expression_call(last))));
        if (syntax_reference_p(expression_syntax(arg)))
          return expression_variable(arg);
      }
    }
  }
  // not found!
  return NULL;
}

References AIPO, call_arguments, call_function, CAR, entity_local_name(), EXPRESSION, expression_address_of_p(), expression_call(), expression_syntax, expression_variable(), freia_statement_aipo_call_p(), freia_statement_to_call(), gen_last(), same_string_p, and syntax_reference_p.

Referenced by sww_seq_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_remove_scalar_ww_deps()

bool freia_remove_scalar_ww_deps

(

const string

module

)

Parameters

module

odule

Definition at line 430 of file freia_transformations.c.

{
  debug_on("PIPS_HWAC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
 
  // else do the stuff
  statement mod_stat =
    (statement) db_get_memory_resource(DBR_CODE, module, true);
  set_current_module_statement(mod_stat);
  set_current_module_entity(module_name_to_entity(module));
 
  // do the job
  bool changed = false;
  gen_context_recurse(mod_stat, &changed,
                      sequence_domain, gen_true2, sww_seq_rwt);
 
  // update database if changed
  if (changed)
    // stmt_renumber(mod_stat); module_reorder(mod_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, mod_stat);
 
  reset_current_module_statement();
  reset_current_module_entity();
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_context_recurse, gen_true2(), mod_stat, module, module_name_to_entity(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), sequence_domain, set_current_module_entity(), set_current_module_statement(), and sww_seq_rwt().

Here is the call graph for this function:

freia_shuffle_move_forward()

void freia_shuffle_move_forward

(

statement

s

)

Definition at line 876 of file freia_transformations.c.

{
  shuffle_context ctx = { 0, 0, NIL, NULL };
  // forward substitude simple image assignments
  gen_context_recurse(s, &ctx, sequence_domain, gen_true2, seq_rwt);
  // remove image assignments that are not used
  // TODO ??? initializations...
  // count image read references
  hash_table reads = hash_table_make(hash_pointer, 100); // entity -> _int
  gen_context_multi_recurse(s, reads,
                            call_domain, call_count_flt, gen_null2,
                            reference_domain, gen_true2, ref_count_rwt,
                            NULL);
  // cleanup assignments of unused images
  FOREACH(statement, sa, ctx.assigns)
  {
    // be safe
    pips_assert(statement_call_p(sa), "statement is a call");
    call c = statement_call(sa);
    pips_assert(ENTITY_ASSIGN_P(call_function(c)), "call is assign");
    list args = call_arguments(c);
    pips_assert(gen_length(args) == 2, "2 args to assign");
    expression e1 = EXPRESSION(CAR(args));
    pips_assert(expression_reference_p(e1), "expr is reference");
    reference r = expression_reference(e1);
    entity img = reference_variable(r);
    pips_assert(reference_indices(r) == NIL, "no array reference");
    pips_assert(freia_image_variable_p(img), "reference an image");
 
    // cleanup unused images
    if (!hash_defined_p(reads, img))
    {
      // remove assignment of unused image pointer
      free_instruction(statement_instruction(sa));
      statement_instruction(sa) = make_continue_instruction();
      // coldly cleanup corresponding effects... (free effects not needed?)
      delete_cumulated_rw_effects(sa);
      store_cumulated_rw_effects_list(sa, NIL);
      // ??? what about proper effects?
      // stats
      ctx.removed ++;
    }
  }
  hash_table_free(reads), reads = NULL;
 
  // be verbose because I'm not sure of the pass
  if (ctx.changed != 0 || ctx.removed != 0)
    pips_user_warning("%d subsitution(s) and %d assignment(s) removed",
                      ctx.changed, ctx.removed);
 
  gen_free_list(ctx.assigns), ctx.assigns = NIL;
}

References shuffle_context::assigns, call_arguments, call_count_flt(), call_domain, call_function, CAR, shuffle_context::changed, delete_cumulated_rw_effects(), ENTITY_ASSIGN_P, EXPRESSION, expression_reference(), expression_reference_p(), FOREACH, free_instruction(), freia_image_variable_p(), gen_context_multi_recurse(), gen_context_recurse, gen_free_list(), gen_length(), gen_null2(), gen_true2(), hash_defined_p(), hash_pointer, hash_table_free(), hash_table_make(), make_continue_instruction(), NIL, pips_assert, pips_user_warning, ref_count_rwt(), reference_domain, reference_indices, reference_variable, shuffle_context::removed, seq_rwt(), sequence_domain, statement_call(), statement_call_p(), statement_instruction, and store_cumulated_rw_effects_list().

Referenced by freia_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

freia_unroll_while()

bool freia_unroll_while

(

const string

module

)

freia_transformations.c

Parameters

module

odule

Definition at line 269 of file freia_transformations.c.

{
  // sanity check
  int factor = get_int_property(spoc_depth_prop);
  if (factor<=1)
  {
    pips_user_warning("cannot unroll with factor=%d\n", factor);
    return true;
  }
 
  // else, do the job
  debug_on("PIPS_HWAC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
 
  // else do the stuff
  statement mod_stat =
    (statement) db_get_memory_resource(DBR_CODE, module, true);
  set_current_module_statement(mod_stat);
  set_current_module_entity(module_name_to_entity(module));
 
  // do the job
  bool changed = freia_unroll_while_for_spoc(mod_stat);
 
  // update if changed
  if (changed)
  {
    stmt_renumber(mod_stat);
    module_reorder(mod_stat);
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, mod_stat);
  }
 
  // cleanup
  reset_current_module_statement();
  reset_current_module_entity();
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, freia_unroll_while_for_spoc(), get_int_property(), mod_stat, module, module_name_to_entity(), module_reorder(), pips_debug, pips_user_warning, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), spoc_depth_prop, and stmt_renumber().

Here is the call graph for this function:

freia_unroll_while_for_spoc()

static bool freia_unroll_while_for_spoc ( statement  s )

static

Definition at line 261 of file freia_transformations.c.

{
  bool changed = false;
  gen_context_recurse(s, &changed,
                      whileloop_domain, gen_true2, maybe_unroll_while_rwt);
  return changed;
}

References gen_context_recurse, gen_true2(), maybe_unroll_while_rwt(), and whileloop_domain.

Referenced by freia_unroll_while().

Here is the call graph for this function:

Here is the caller graph for this function:

maybe_unroll_while_rwt()

static void maybe_unroll_while_rwt ( whileloop  wl, bool *  changed  )

static

Definition at line 201 of file freia_transformations.c.

{
  if (statement_sequence_p(whileloop_body(wl)))
  {
    sequence sq = statement_sequence(whileloop_body(wl));
    if (freia_convergence_sequence_p(sq))
    {
      // unroll!
      int factor = get_int_property(spoc_depth_prop);
      pips_assert("some unrolling factor", factor>0);
      list ol = sequence_statements(sq);
 
      // sorry, just a hack to avoid a precise pattern matching
      statement first = STATEMENT(CAR(ol));
      pips_assert("s is an assignement", statement_call_p(first));
      gen_remove_once(&ol, first);
      list col = gen_copy_seq(ol), nl = NIL;
      list lass = call_arguments(statement_call(first));
      entity
        previous = expression_variable(EXPRESSION(CAR(lass))),
        current = expression_variable(EXPRESSION(CAR(CDR(lass))));
 
      // cleanup vol from col
      statement vols = statement_undefined;
      FOREACH(statement, s, col)
      {
        call c = freia_statement_to_call(s);
        if (c && same_string_p(entity_local_name(call_function(c)),
                               AIPO "global_vol"))
        {
          gen_remove_once(&col, s);
          vols = copy_statement(s);
          break;
        }
      }
      pips_assert("vol statement found", vols!=statement_undefined);
 
      // do factor-1
      while (--factor)
        nl = gen_nconc(gen_full_copy_list(col), nl);
 
      // compute "previous" volume for comparison
      substitute_reference_variable(vols, current, previous);
 
      // swith off "register" on previous, if need be...
      variable v = type_variable(entity_type(previous));
      variable_qualifiers(v) = remove_register(variable_qualifiers(v));
 
      // then reuse initial list for the last one
      sequence_statements(sq) = gen_nconc(nl, CONS(statement, vols, ol));
 
      // cleanup temporary list
      gen_free_list(col);
 
      // must renumber...
      *changed = true;
    }
  }
}

References AIPO, call_arguments, call_function, CAR, CDR, CONS, copy_statement(), current, entity_local_name(), entity_type, EXPRESSION, expression_variable(), FOREACH, freia_convergence_sequence_p(), freia_statement_to_call(), gen_copy_seq(), gen_free_list(), gen_full_copy_list(), gen_nconc(), gen_remove_once(), get_int_property(), NIL, pips_assert, remove_register(), same_string_p, sequence_statements, spoc_depth_prop, STATEMENT, statement_call(), statement_call_p(), statement_sequence(), statement_sequence_p(), statement_undefined, substitute_reference_variable(), type_variable, variable_qualifiers, and whileloop_body.

Referenced by freia_unroll_while_for_spoc().

Here is the call graph for this function:

Here is the caller graph for this function:

pointer_candidate_p()

static bool pointer_candidate_p ( entity  var )

static

Definition at line 501 of file freia_transformations.c.

{
  // other checks?
  pips_debug(5, "entity %s %d\n", entity_name(var), entity_pointer_p(var));
  return entity_pointer_p(var);
}

References entity_name, entity_pointer_p(), and pips_debug.

Referenced by remove_simple_scalar_pointers(), and rssp_ref().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_count_rwt()

static void ref_count_rwt ( reference  r, hash_table  counts  )

static

Definition at line 834 of file freia_transformations.c.

{
  entity v = reference_variable(r);
  if (freia_image_variable_p(v))
  {
    if (hash_defined_p(counts, v))
    {
      _int count = (_int) hash_get(counts, v) + 1;
      hash_update(counts, v, (void *) count);
    }
    else
      hash_put(counts, v, (void *) (_int) 1);
  }
}

References count, freia_image_variable_p(), hash_defined_p(), hash_get(), hash_put(), hash_update(), and reference_variable.

Referenced by freia_shuffle_move_forward().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_rwt()

static void ref_rwt ( reference  r, subs_ctx *  ctx  )

static

Definition at line 189 of file freia_transformations.c.

{
  if (reference_variable(r)==ctx->ovar)
    reference_variable(r)=ctx->nvar;
}

References subs_ctx::nvar, subs_ctx::ovar, and reference_variable.

Referenced by substitute_reference_variable().

Here is the caller graph for this function:

remove_register()

static list remove_register ( list  lq )

static

remove "register" qualifier from qualifier list

Definition at line 55 of file freia_transformations.c.

{
  FOREACH(qualifier, q, lq)
  {
    if (qualifier_register_p(q))
    {
      gen_remove_once(&lq, q);
      // register may be there once
      return lq;
    }
  }
  return lq;
}

References FOREACH, gen_remove_once(), and qualifier_register_p.

Referenced by maybe_unroll_while_rwt(), and sww_seq_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_simple_scalar_pointers()

bool remove_simple_scalar_pointers

(

const string

module

)

Parameters

module

odule

Definition at line 584 of file freia_transformations.c.

{
  debug_on("PIPS_HWAC_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module);
 
  // else do the stuff
  statement mod_stat =
    (statement) db_get_memory_resource(DBR_CODE, module, true);
  set_current_module_statement(mod_stat);
  set_current_module_entity(module_name_to_entity(module));
 
  rssp_ctx ctx;
  ctx.candidates = set_make(set_pointer);
  ctx.points_to = hash_table_make(hash_pointer, 0);
  ctx.defined = hash_table_make(hash_pointer, 0);
  ctx.dereferenced = hash_table_make(hash_pointer, 0);
  ctx.invalidated = set_make(set_pointer);
 
  // get candidates
  FOREACH(entity, var, entity_declarations(get_current_module_entity()))
  {
    if (pointer_candidate_p(var))
    {
      set_add_element(ctx.candidates, ctx.candidates, var);
      if (value_expression_p(entity_initial(var)))
      {
        expression e = value_expression(entity_initial(var));
        entity v2 = address_of_scalar(e);
        if (v2)
        {
          hash_put(ctx.points_to, var, v2);
          hash_put(ctx.defined, var, expression_call(e));
        }
      }
    }
  }
 
 
  // check condition
  gen_context_multi_recurse
    (mod_stat, &ctx,
     reference_domain, gen_true, rssp_ref,
     // ignore sizeof
     sizeofexpression_domain, gen_false, gen_null,
     NULL);
 
  bool changed = false;
  // apply transformation
  SET_FOREACH(entity, var, ctx.candidates)
  {
    pips_debug(2, "considering entity %s inv=%d dr=%d def=%d pt=%d\n",
               entity_name(var), set_belong_p(ctx.invalidated, var),
               hash_defined_p(ctx.dereferenced, var),
               hash_defined_p(ctx.defined, var),
               hash_defined_p(ctx.points_to, var));
 
    if (!set_belong_p(ctx.invalidated, var) &&
        hash_defined_p(ctx.dereferenced, var) &&
        hash_defined_p(ctx.defined, var) &&
        hash_defined_p(ctx.points_to, var))
    {
      changed = true;
      // replace use
      expression deref = (expression) hash_get(ctx.dereferenced, var);
      expression_syntax(deref) = make_syntax_reference
        (make_reference((entity) hash_get(ctx.points_to, var), NIL));
      // drop definition
      call definition = (call) hash_get(ctx.defined, var);
      gen_free_list(call_arguments(definition)),
        call_arguments(definition) = NIL;
      call_function(definition) = make_integer_constant_entity(0);
      // declaration cleanup?
    }
  }
 
  // result
  if (changed)
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module, mod_stat);
 
  // cleanup
  set_free(ctx.candidates);
  set_free(ctx.invalidated);
  hash_table_free(ctx.points_to);
  hash_table_free(ctx.dereferenced);
  hash_table_free(ctx.defined);
  reset_current_module_statement();
  reset_current_module_entity();
  debug_off();
 
  return true;
}

References address_of_scalar(), call_arguments, call_function, rssp_ctx::candidates, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, rssp_ctx::defined, rssp_ctx::dereferenced, entity_declarations, entity_initial, entity_name, expression_call(), expression_syntax, FOREACH, gen_context_multi_recurse(), gen_false(), gen_free_list(), gen_null(), gen_true(), get_current_module_entity(), hash_defined_p(), hash_get(), hash_pointer, hash_put(), hash_table_free(), hash_table_make(), rssp_ctx::invalidated, make_integer_constant_entity(), make_reference(), make_syntax_reference(), mod_stat, module, module_name_to_entity(), NIL, pips_debug, pointer_candidate_p(), rssp_ctx::points_to, reference_domain, reset_current_module_entity(), reset_current_module_statement(), rssp_ref(), set_add_element(), set_belong_p(), set_current_module_entity(), set_current_module_statement(), SET_FOREACH, set_free(), set_make(), set_pointer, sizeofexpression_domain, value_expression, and value_expression_p.

Here is the call graph for this function:

rssp_ref()

static void rssp_ref ( reference  r, rssp_ctx *  ctx  )

static

Definition at line 508 of file freia_transformations.c.

{
  string what = "unknown";
  entity var = reference_variable(r);
  pips_debug(8, "reference %p to %s\n", r, entity_name(var));
  if (pointer_candidate_p(var) && !reference_indices(r))
    set_add_element(ctx->candidates, ctx->candidates, var);
  if (set_belong_p(ctx->candidates, var))
  {
    expression enc = (expression) gen_get_ancestor(expression_domain, r);
    if (enc && expression_reference_p(enc) && expression_reference(enc)==r)
    {
      call called = (call) gen_get_ancestor(call_domain, enc);
 
      pips_debug(8, "called=%p %s\n", called, called?
                 entity_name(call_function(called)): "<nope>");
 
      if (called &&
          ENTITY_ASSIGN_P(call_function(called)) &&
          EXPRESSION(CAR(call_arguments(called)))==enc)
      {
        // is it a definition: var = ...
        list args = call_arguments(called);
        pips_assert("2 args to assign", gen_length(args)==2);
        entity v2 =
          address_of_scalar(EXPRESSION(CAR(CDR(call_arguments(called)))));
        if (v2)
        {
          if (!hash_defined_p(ctx->points_to, var))
            hash_put(ctx->points_to, var, v2),
              hash_put(ctx->defined, var, called),
              what="! var = &YYY";
          else
            set_add_element(ctx->invalidated, ctx->invalidated, var),
              what="already defined";
        }
        else
          set_add_element(ctx->invalidated, ctx->invalidated, var),
            what="no v2";
      }
      else if (called && ENTITY_DEREFERENCING_P(call_function(called)))
      {
        // *var ...
        call upper = (call) gen_get_ancestor(call_domain, called);
        expression first = (upper && call_arguments(upper))?
          EXPRESSION(CAR(call_arguments(upper))): NULL;
 
        pips_debug(8, "upper=%p first=%p %s\n", upper, first, upper?
                   entity_name(call_function(upper)): "<nope>");
 
        if (upper && first &&
            ENTITY_ASSIGN_P(call_function(upper)) &&
            expression_call_p(first) &&
            expression_call(first) == called &&
            !hash_defined_p(ctx->dereferenced, var))
          // *var = XXX
          hash_put(ctx->dereferenced, var, first),
            what="! *var = XXX";
        else
          set_add_element(ctx->invalidated, ctx->invalidated, var),
            what="not *var = ...";
      }
      else
        set_add_element(ctx->invalidated, ctx->invalidated, var),
          what="not = or *";
    }
    else
      set_add_element(ctx->invalidated, ctx->invalidated, var),
        what="not enc";
  }
  else
    what="not candidate";
  pips_debug(5, "candidate %s: %s\n", entity_name(var), what);
  //return true;
}

References address_of_scalar(), call_arguments, call_domain, call_function, rssp_ctx::candidates, CAR, CDR, rssp_ctx::defined, rssp_ctx::dereferenced, ENTITY_ASSIGN_P, ENTITY_DEREFERENCING_P, entity_name, EXPRESSION, expression_call(), expression_call_p(), expression_domain, expression_reference(), expression_reference_p(), gen_get_ancestor(), gen_length(), hash_defined_p(), hash_put(), rssp_ctx::invalidated, pips_assert, pips_debug, pointer_candidate_p(), rssp_ctx::points_to, reference_indices, reference_variable, set_add_element(), and set_belong_p().

Referenced by remove_simple_scalar_pointers().

Here is the call graph for this function:

Here is the caller graph for this function:

seq_rwt()

static void seq_rwt ( sequence  sq, shuffle_context *  ctx  )

static

Definition at line 748 of file freia_transformations.c.

{
  ctx->equal = hash_table_make(hash_pointer, 10);
 
  FOREACH(statement, s, sequence_statements(sq))
  {
    if (statement_call_p(s))
    {
      call c = statement_call(s);
      list args = call_arguments(c);
      if (ENTITY_ASSIGN_P(call_function(c)))
      {
        // ... = ...
        pips_assert("2 arguments", gen_length(args)==2);
        expression e1 = EXPRESSION(CAR(args)), e2 = EXPRESSION(CAR(CDR(args)));
        if (expression_reference_p(e1))
        {
          entity v1 = expression_variable(e1);
          if (freia_image_variable_p(v1))
          {
            // is the second image an image?
            entity v2 = NULL;
            if (expression_reference_p(e2))
            {
              v2 = expression_variable(e2);
              if (!freia_image_variable_p(v2))
                v2 = NULL;
            }
 
            // img = ...
            // cleanup all equalities with img, but not on img=img
            if (v1 != v2)
            {
              list delete = CONS(entity, v1, NIL);
              HASH_FOREACH(entity, k, entity, v, ctx->equal)
                // maybe could replace by other equal if any?
                if (v == v1)
                  delete = CONS(entity, k, delete);
              FOREACH(entity, e, delete)
                (void) hash_del(ctx->equal, e);
              gen_free_list(delete), delete = NIL;
            }
 
            // image assignement
            if (v2 != NULL)
            {
              // img1 = img2
              ctx->assigns = CONS(statement, s, ctx->assigns);
              if (v1 != v2) // distinct images
              {
                // point to prior image if any
                if (hash_defined_p(ctx->equal, v2))
                {
                  entity end = hash_get(ctx->equal, v2);
                  reference_variable(expression_reference(e2)) = end;
                  hash_put(ctx->equal, v1, end);
                }
                else
                  hash_put(ctx->equal, v1, v2);
              }
              // else skip silently "img = img;"
            }
            // else no image on rhs
          }
          else // not image assignment
          {
            substitute_image_occurrences(e2, ctx);
          }
        }
      }
      else // a call, but not an assignment
      {
        substitute_image_occurrences(s, ctx);
      }
    }
    else // not a call
    {
      // hmmm... safe option for now, cleanup current equalities
      // ??? could keep those on which there is no effect?
      hash_table_clear(ctx->equal);
    }
  }
  hash_table_free(ctx->equal); ctx->equal = NULL;
}

References shuffle_context::assigns, call_arguments, call_function, CAR, CDR, CONS, end, ENTITY_ASSIGN_P, shuffle_context::equal, EXPRESSION, expression_reference(), expression_reference_p(), expression_variable(), FOREACH, freia_image_variable_p(), gen_free_list(), gen_length(), hash_defined_p(), hash_del(), HASH_FOREACH, hash_get(), hash_pointer, hash_put(), hash_table_clear(), hash_table_free(), hash_table_make(), NIL, pips_assert, reference_variable, sequence_statements, statement_call(), statement_call_p(), and substitute_image_occurrences().

Referenced by freia_shuffle_move_forward().

Here is the call graph for this function:

Here is the caller graph for this function:

sio_call_flt()

static bool sio_call_flt ( call  c, _UNUSED_ shuffle_context *  ctx  )

static

Definition at line 712 of file freia_transformations.c.

{
  entity f = call_function(c);
  return ENTITY_ASSIGN_P(f) || entity_update_p(f) ||
    hwac_freia_api(entity_local_name(f)) != NULL ||
    // hmmm... also freia_common_ functions
    starts_with(entity_local_name(f), "freia_common_");
}

References call_function, ENTITY_ASSIGN_P, entity_local_name(), entity_update_p, f(), hwac_freia_api(), and starts_with.

Referenced by substitute_image_occurrences().

Here is the call graph for this function:

Here is the caller graph for this function:

sio_ref_rwt()

static void sio_ref_rwt ( reference  r, shuffle_context *  ctx  )

static

Definition at line 722 of file freia_transformations.c.

{
  if (reference_indices(r) != NIL)
    return;
  entity v = reference_variable(r);
  if (hash_defined_p(ctx->equal, v))
  {
    reference_variable(r) = hash_get(ctx->equal, v);
    ctx->changed++;
  }
}

References shuffle_context::changed, shuffle_context::equal, hash_defined_p(), hash_get(), NIL, reference_indices, and reference_variable.

Referenced by substitute_image_occurrences().

Here is the call graph for this function:

Here is the caller graph for this function:

sr_flt()

static bool sr_flt ( statement  s, int *  number  )

static

Definition at line 74 of file freia_transformations.c.

{
  instruction i = statement_instruction(s);
  if (instruction_sequence_p(i))
    // it seems that sequences are expected not to have a number
    // just in case, force the property
    statement_number(s) = STATEMENT_NUMBER_UNDEFINED;
  else if (statement_number(s)!=STATEMENT_NUMBER_UNDEFINED)
    // just add a number if none are available?
    // otherwise, the initial number is kept
    statement_number(s) = (*number)++;
  return true;
}

References instruction_sequence_p, statement_instruction, statement_number, and STATEMENT_NUMBER_UNDEFINED.

Referenced by stmt_renumber().

Here is the caller graph for this function:

stmt_renumber()

static void stmt_renumber ( statement  s )

static

Definition at line 88 of file freia_transformations.c.

{
  int number=1;
  gen_context_recurse(s, &number, statement_domain, sr_flt, gen_null2);
}

References gen_context_recurse, gen_null2(), sr_flt(), and statement_domain.

Referenced by freia_unroll_while().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_image_occurrences()

static void substitute_image_occurrences ( void *  s, shuffle_context *  ctx  )

static

Definition at line 735 of file freia_transformations.c.

{
  gen_context_multi_recurse(s, ctx,
                            call_domain, sio_call_flt, gen_null,
                            reference_domain, gen_true, sio_ref_rwt,
                            NULL);
}

References call_domain, gen_context_multi_recurse(), gen_null(), gen_true(), reference_domain, sio_call_flt(), and sio_ref_rwt().

Referenced by seq_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_reference_variable()

static void substitute_reference_variable ( statement  s, entity  ovar, entity  nvar  )

static

Definition at line 195 of file freia_transformations.c.

{
  subs_ctx ctx = { ovar, nvar };
  gen_context_recurse(s, &ctx, reference_domain, gen_true2, ref_rwt);
}

References gen_context_recurse, gen_true2(), ref_rwt(), and reference_domain.

Referenced by maybe_unroll_while_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

sww_seq_rwt()

static void sww_seq_rwt ( const sequence  sq, bool *  changed  )

static

Definition at line 362 of file freia_transformations.c.

{
  // current status of search
  statement previous_reduction = NULL;
  entity previous_variable = NULL;
  statement assignment = NULL;
  entity assigned = NULL;
 
  // this is a partial O(n) implementation
  // beware that we may have VERY LONG sequences...
  FOREACH(statement, s, sequence_statements(sq))
  {
    bool tocheck = true;
    entity red = freia_reduction_variable(s);
    if (red)
    {
      if (previous_reduction && assignment && red==previous_variable)
      {
        // matched!
        // replace variable in first reduction
        hash_table replacements = hash_table_make(hash_pointer, 0);
        hash_put(replacements, previous_variable, assigned);
        replace_entities(previous_reduction, replacements);
        hash_table_free(replacements);
        // and now useless remove assignment
        free_instruction(statement_instruction(assignment));
        statement_instruction(assignment) = make_continue_instruction();
        // make assigned NOT a register... just in case
        variable v = type_variable(entity_type(assigned));
        variable_qualifiers(v) = remove_register(variable_qualifiers(v));
        // we did something
        *changed = true;
      }
 
      // restart current status with new found reduction
      previous_reduction = s;
      previous_variable = red;
      assignment = NULL;
      assigned = NULL;
      tocheck = false;
    }
 
    // detect reduction variable assignment
    if (previous_reduction && !assignment &&
        instruction_assign_p(statement_instruction(s)))
    {
      list args = call_arguments(instruction_call(statement_instruction(s)));
      expression e1 = EXPRESSION(CAR(args)), e2 = EXPRESSION(CAR(CDR(args)));
      if (expression_reference_p(e1) && expression_reference_p(e2) &&
          reference_variable(expression_reference(e2))==previous_variable)
      {
        assignment = s;
        assigned = reference_variable(expression_reference(e1));
        tocheck = false;
      }
    }
 
    if (tocheck && previous_variable && variable_is_used(s, previous_variable))
    {
      // full cleanup
      previous_reduction = NULL;
      previous_variable = NULL;
      assignment = NULL;
      assigned = NULL;
    }
  }
}

References call_arguments, CAR, CDR, entity_type, EXPRESSION, expression_reference(), expression_reference_p(), FOREACH, free_instruction(), freia_reduction_variable(), hash_pointer, hash_put(), hash_table_free(), hash_table_make(), instruction_assign_p(), instruction_call, make_continue_instruction(), reference_variable, remove_register(), replace_entities(), sequence_statements, statement_instruction, type_variable, variable_is_used(), and variable_qualifiers.

Referenced by freia_remove_scalar_ww_deps().

Here is the call graph for this function:

Here is the caller graph for this function:

variable_is_used()

static bool variable_is_used ( statement  s, entity  var  )

static

Definition at line 111 of file freia_transformations.c.

{
  vis_ctx ctx = { false, var };
  gen_context_recurse(s, &ctx, reference_domain, gen_true2, vis_rwt);
  return ctx.used;
}

References gen_context_recurse, gen_true2(), reference_domain, vis_ctx::used, and vis_rwt().

Referenced by sww_seq_rwt().

Here is the call graph for this function:

Here is the caller graph for this function:

vis_rwt()

static void vis_rwt ( const reference  r, vis_ctx *  ctx  )

static

Definition at line 102 of file freia_transformations.c.

{
  if (reference_variable(r)==ctx->var)
  {
    ctx->used = true;
    gen_recurse_stop(NULL);
  }
}

References gen_recurse_stop(), reference_variable, vis_ctx::used, and vis_ctx::var.

Referenced by variable_is_used().

Here is the call graph for this function:

Here is the caller graph for this function: