filter_proper_effects.c File Reference

#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "misc.h"
#include "ri-util.h"
#include "effects-util.h"
#include "database.h"
#include "resources.h"
#include "pipsdbm.h"
#include "properties.h"
#include "effects-generic.h"
#include "effects-simple.h"

Include dependency graph for filter_proper_effects.c:

Go to the source code of this file.

Functions
static list	get_variables_to_filter ()
	of entity More...
static bool	there_is_a_conflict (entity var)
static void	reference_rwt (reference r)
	it should be a check on call arguments, whether they are W + ref for user define functions, use summary effects for intrinsics? =, implied-do, read... More...
static void	check_if_direct_reference (void *x)
static bool	direct_written_reference (statement s, entity var)
static bool	stmt_flt (statement s)
bool	filter_proper_effects (const char *module_name)
	filter_proper_effects.c More...

Variables
static list	variables_to_filter = NIL
	of entity More...
static bool	direct_reference_found = false
static entity	a_variable = NULL

Function Documentation

check_if_direct_reference()

static void check_if_direct_reference ( void *  x )

static

Definition at line 126 of file filter_proper_effects.c.

{
  gen_recurse(x, reference_domain, gen_true, reference_rwt);
}

References gen_recurse, gen_true(), reference_domain, reference_rwt(), and x.

Referenced by direct_written_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

direct_written_reference()

static bool direct_written_reference ( statement  s, entity  var  )

static

should not happen on a statement with proper effects

Definition at line 131 of file filter_proper_effects.c.

{
  instruction i = statement_instruction(s);
  direct_reference_found = false;
  a_variable = var;
 
  switch (instruction_tag(i))
  {
  case is_instruction_call:
    check_if_direct_reference(i);
    break;
  case is_instruction_loop:
    {
      loop l = instruction_loop(i);
      check_if_direct_reference(loop_range(l));
      if (!direct_reference_found && entities_may_conflict_p(loop_index(l), var))
        direct_reference_found = true;
      break;
    }
  case is_instruction_whileloop:
    check_if_direct_reference(whileloop_condition(instruction_whileloop(i)));
    break;
  case is_instruction_test:
    check_if_direct_reference(test_condition(instruction_test(i)));
    break;
  default:
    /* should not happen on a statement with proper effects */
    pips_internal_error("unexpected instruction tag...");
  }
 
  a_variable = NULL;
  return direct_reference_found;
}

References a_variable, check_if_direct_reference(), direct_reference_found, entities_may_conflict_p(), instruction_loop, instruction_tag, instruction_test, instruction_whileloop, is_instruction_call, is_instruction_loop, is_instruction_test, is_instruction_whileloop, loop_index, loop_range, pips_internal_error, statement_instruction, test_condition, and whileloop_condition.

Referenced by stmt_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_proper_effects()

bool filter_proper_effects

(

const char *

module_name

)

filter_proper_effects.c

gets what is needed from PIPS DBM

returns the result to the DBM...

Parameters

module_name

odule_name

Definition at line 201 of file filter_proper_effects.c.

{
  debug_on("FILTER_PROPER_EFFECTS_DEBUG_LEVEL");
  pips_debug(1, "considering module %s\n", module_name);
 
  /* gets what is needed from PIPS DBM
   */
  set_current_module_entity(local_name_to_top_level_entity(module_name));
  set_current_module_statement((statement)
            db_get_memory_resource(DBR_CODE, module_name, true));
  set_proper_rw_effects((statement_effects)
            db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
 
  variables_to_filter = get_variables_to_filter();
 
  if (variables_to_filter)
    gen_recurse(get_current_module_statement(),
                statement_domain, stmt_flt, gen_null);
 
  gen_free_list(variables_to_filter);
  variables_to_filter = NIL;
  
  /* returns the result to the DBM... */
  DB_PUT_MEMORY_RESOURCE
    (DBR_FILTERED_PROPER_EFFECTS, module_name, NULL);
  
  reset_proper_rw_effects();
  reset_current_module_entity();
  reset_current_module_statement();
  
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_free_list(), gen_null(), gen_recurse, get_current_module_statement(), get_variables_to_filter(), local_name_to_top_level_entity(), module_name(), NIL, pips_debug, reset_current_module_entity(), reset_current_module_statement(), reset_proper_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_proper_rw_effects(), statement_domain, stmt_flt(), and variables_to_filter.

Here is the call graph for this function:

get_variables_to_filter()

static list get_variables_to_filter ( )

static

of entity

Definition at line 46 of file filter_proper_effects.c.

{
  string names = strdup(get_string_property("EFFECTS_FILTER_ON_VARIABLE"));
  list le = NIL;
  entity var;
  string saved = names, s;
 
  pips_assert("property EFFECTS_FILTER_ON_VARIABLE is defined",
              !same_string_p(names, ""));
 
  for (s=names; *s; s++)
  {
    var = NULL;
    if (*s==',')
    {
      *s = '\0';
      var = gen_find_tabulated(names, entity_domain);
    
      if (!var || entity_undefined_p(var))
      {
        pips_user_warning("reference variable '%s' not found\n", names);
      }
      else
      {
        le = CONS(ENTITY, var, le);
      }
      *s = ',';
      names = s+1;
    }
  }
 
  var = gen_find_tabulated(names, entity_domain);
 
  if (!var || entity_undefined_p(var))
  {
    pips_user_warning("reference variable '%s' not found\n", names);
  }
  else
  {
    le = CONS(ENTITY, var, le);
  }
 
  free(saved), saved = NULL;
 
  return le;
}

References CONS, ENTITY, entity_domain, entity_undefined_p, free(), gen_find_tabulated(), get_string_property(), NIL, pips_assert, pips_user_warning, same_string_p, and strdup().

Referenced by filter_proper_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_rwt()

static void reference_rwt ( reference  r )

static

it should be a check on call arguments, whether they are W + ref for user define functions, use summary effects for intrinsics? =, implied-do, read...

Definition at line 117 of file filter_proper_effects.c.

{
  if (entities_may_conflict_p(reference_variable(r), a_variable))
  {
    direct_reference_found = true;
    gen_recurse_stop(NULL);
  }
}

References a_variable, direct_reference_found, entities_may_conflict_p(), gen_recurse_stop(), and reference_variable.

Referenced by check_if_direct_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

stmt_flt()

static bool stmt_flt ( statement  s )

static

of effect

Definition at line 167 of file filter_proper_effects.c.

{
  list /* of effect */ lpe = load_proper_rw_effects_list(s);
  MAP(EFFECT, e,
  {
    entity var = effect_variable(e);
    if (effect_write_p(e) && there_is_a_conflict(var))
    {
      if (direct_written_reference(s, var))
      {
        int order = statement_ordering(s);
        int on; int os;
        if (order!=STATEMENT_ORDERING_UNDEFINED)
        {
          on = ORDERING_NUMBER(order);
          os = ORDERING_STATEMENT(order);
        }
        else
        {
          on = -1;
          os = -1;
        }
 
        user_log("## %s o=(%d,%d)/n=%d\n", 
                 entity_name(var), on, os, statement_number(s));
      }
    }
  },
      lpe);
  return true;
}

References direct_written_reference(), EFFECT, effect_variable, effect_write_p, entity_name, load_proper_rw_effects_list(), MAP, ORDERING_NUMBER, ORDERING_STATEMENT, statement_number, statement_ordering, STATEMENT_ORDERING_UNDEFINED, there_is_a_conflict(), and user_log().

Referenced by filter_proper_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

there_is_a_conflict()

static bool there_is_a_conflict ( entity  var )

static

Definition at line 97 of file filter_proper_effects.c.

{
  MAP(ENTITY, v,
  {
    if (entities_may_conflict_p(var, v))
      return true;
  },
      variables_to_filter);
  return false;
}

References entities_may_conflict_p(), ENTITY, MAP, and variables_to_filter.

Referenced by stmt_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

a_variable

entity a_variable = NULL

static

Definition at line 111 of file filter_proper_effects.c.

Referenced by clone_variable_with_new_name(), create_parameter_variable_for_new_module(), create_private_variable_for_new_module(), direct_written_reference(), flint_check_uninitialized_variables_in_statement(), flint_initialize_statement_def_use_variables(), flint_variable_uninitialize_elsewhere(), make_assignement_statement(), reference_rwt(), statement_has_a_module_formal_argument_write_effect_p(), and variable_is_a_module_formal_parameter_p().

direct_reference_found

bool direct_reference_found = false

static

Definition at line 110 of file filter_proper_effects.c.

Referenced by direct_written_reference(), and reference_rwt().

variables_to_filter

list variables_to_filter = NIL

static

of entity

Definition at line 95 of file filter_proper_effects.c.

Referenced by filter_proper_effects(), and there_is_a_conflict().