interprocedural.c File Reference

#include <stdio.h>
#include <string.h>
#include <setjmp.h>
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "effects.h"
#include "database.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "constants.h"
#include "misc.h"
#include "semantics.h"
#include "text.h"
#include "text-util.h"
#include "sommet.h"
#include "ray_dte.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "transformer.h"
#include "pipsdbm.h"
#include "resources.h"
#include "effects-generic.h"
#include "effects-convex.h"
#include "effects-simple.h"

Include dependency graph for interprocedural.c:

Go to the source code of this file.

Macros
#define	IS_EG   true
	package regions : Alexis Platonoff, 22 Aout 1990, Be'atrice Creusillet 10/94 More...
#define	NOT_EG   false
#define	PHI_FIRST   true
#define	NOT_PHI_FIRST   false
#define	BACKWARD   true
#define	FORWARD   false
#define	min(a, b)   (((a)<(b))?(a):(b))
#define	max(a, b)   (((a)>(b))?(a):(b))

Functions
void	convex_regions_translation_init (entity callee, list real_args, bool backward_p)
	jmp_buf overflow_error; More...
void	convex_regions_translation_end ()
void	reset_out_summary_regions_list ()
void	update_out_summary_regions_list (list l_out)
list	get_out_summary_regions_list ()
static bool	stmt_filter (statement s)
list	out_regions_from_caller_to_callee (entity caller, entity callee)
void	out_regions_from_call_site_to_callee (call c)
	void out_regions_from_call_site_to_callee(call c) input : a potential call site for current_callee. More...
list	in_regions_of_external (entity func, list real_args, transformer context)
	list in_regions_of_external(entity func, list real_args, transformer context) input : an external function func, and the list of real arguments used in the calling function. More...
list	regions_of_external (entity func, list real_args, transformer context, bool proper)
	list regions_of_external(entity func, list real_args, transformer context) input : an external function func, and the list of real arguments used in the calling function. More...
list	convex_regions_backward_translation (entity func, list real_args, list l_reg, transformer context)
	of effects More...
list	convex_regions_forward_translation (entity callee, list real_args, list l_reg, transformer context)
	of effects More...
static list	formal_regions_backward_translation (entity func, list real_args, list func_regions, transformer context)
	static list formal_regions_backward_translation(entity func, list real_args, func_regions, transformer context) input : an external function func, its real arguments at call site (real_args), its summary regions (with formal args), and the calling context. More...
static list	common_regions_backward_translation (entity func, list func_regions)
static list	common_region_translation (entity callee, region reg, bool backward)
	static list common_region_translation(entity func, region reg, bool backward) input : func is the called function, real_args are the real arguments, reg is the region to translate (it concerns an array in a common), and backward indicates the direction of the translation. More...
list	regions_backward_translation (entity func, list real_args, list func_regions, transformer context, bool proper)
	list regions_backward_tranlation(entity func, list real_args, list func_regions, transformer context) input : an external function func, and the list of real arguments used in the calling function. More...
list	c_convex_effects_on_formal_parameter_backward_translation (list l_sum_eff, expression real_arg, transformer context)
static list	real_regions_forward_translation (entity func, list real_args, list l_reg, transformer context)
	static list real_regions_forward_translation(entity func, list real_args, l_reg, transformer context) input : the called function func, the real arguments of the call, the list of regions to translate, and the context of the call. More...
static list	common_regions_forward_translation (entity func, list real_regions)
	static list common_regions_forward_translation (entity func, list real_regions) input : the called function, the list of real arguments at call site, and the list of regions to translate. More...
list	regions_forward_translation (entity func, list real_args, list l_reg, transformer context)
	list regions_forward_translation(entity func, list real_args, l_reg, transformer context input : the called function func, the real arguments of the call, the list of regions to translate, and the context of the call. More...
list	c_convex_effects_on_actual_parameter_forward_translation (entity callee, expression real_exp, entity formal_ent, list l_reg, transformer context)

Variables
static statement	current_stmt = statement_undefined
static entity	current_callee = entity_undefined
static list	l_sum_out_reg = list_undefined

Macro Definition Documentation

BACKWARD

#define BACKWARD   true

Definition at line 85 of file interprocedural.c.

FORWARD

#define FORWARD   false

Definition at line 86 of file interprocedural.c.

IS_EG

#define IS_EG   true

package regions : Alexis Platonoff, 22 Aout 1990, Be'atrice Creusillet 10/94

interprocedural

This File contains the main functions that compute the interprocedural translation of regions (forward and backward).

Vocabulary : _ A variable refered as a "region" is in fact of the NEWGEN type "effect". The use of the word "region" allows to keep the difference with the effects package. _ The word "func" always refers to the external called subroutine. _ The word "real" always refers to the calling subroutine

Definition at line 79 of file interprocedural.c.

max

#define max	(		a,
			b
	)		(((a)>(b))?(a):(b))

Definition at line 89 of file interprocedural.c.

min

#define min	(		a,
			b
	)		(((a)<(b))?(a):(b))

Definition at line 88 of file interprocedural.c.

NOT_EG

#define NOT_EG   false

Definition at line 80 of file interprocedural.c.

NOT_PHI_FIRST

#define NOT_PHI_FIRST   false

Definition at line 83 of file interprocedural.c.

PHI_FIRST

#define PHI_FIRST   true

Definition at line 82 of file interprocedural.c.

Function Documentation

c_convex_effects_on_actual_parameter_forward_translation()

list c_convex_effects_on_actual_parameter_forward_translation	(	entity	callee,
		expression	real_exp,
		entity	formal_ent,
		list	l_reg,
		transformer	context
	)

it's an intrinsic : FI, cannot it be a constant?

first we compute a SIMPLE effect on the argument of the address_of operator. This is to distinguish between the general case and the case where the operand of the & operator is an array element. Simple effect indices are easier to retrieve.

there should be a FOREACH here to scan the whole list

there are indices but we don't know if they represent array dimensions, struct/union/enum fields, or pointer dimensions.

we build the constraint PHI_nb_phi_real >= last index of eff_real

well, not strictly necessary : forward propagation is only for OUT regions

now we compute a convex effect on the argument of the address_of operator and modify it's last dimension according to the fact that there is an addressing operator

here should be a FOREACH to handle all elements

array element operand : we replace the constraint on the last phi variable with

First we have to test if the eff_real access path leads to the eff_orig access path

to do that, if the entities are the same (well in fact we should also take care of aliasing), we add the constraints of eff_real to those of eff_orig, and the system must be feasible. We should also take care of linearization here.

I guess we could reuse convex_cell_reference_with_address_of_cell_reference_translation

At least part of the original effect corresponds to the actual argument : we need to translate it

first we translate the predicate in the callee's name space

Then we remove the phi variables common to the two regions except the last one if we are not in the general case

This is only valid when there is no linearization ; in the general case a translation system should be built

if not in the general case, we add the constraint phi_nb_phi_real == psi_nb_phi_real - exp_nb_phi_real

Finally, we must rename remaining phi variables from 2 add a PHI1==0 constraint in the general case, or, in the contrary, rename remaining phi variables from 1. We must also change the resulting region entity for the formal entity in all cases.

add PHI1 == 0

else of the if (sc_empty_p)

if(effect_entity(eff_orig) == effect_entity(eff_real) ...)

FOREACH

first we compute an effect on the real_arg

here should be a foreach to scan all the elements

First we have to test if the eff_real access path leads to the eff_orig access path

to do that, if the entities are the same (well in fact we should also take care of aliasing), we add the constraints of eff_real to those of eff_orig, and the system must be feasible.

At least part of the original effect corresponds to the actual argument : we need to translate it

first we perform the path translation

then we translate the predicate in the callee's name space

else of the if (sc_empty_p)

if(effect_entity(eff_orig) == effect_entity(eff_real) ...)

FOREACH

switch

Parameters

callee	allee
real_exp	eal_exp
formal_ent	ormal_ent
l_reg	_reg
context	ontext

Definition at line 1163 of file interprocedural.c.

{
  syntax real_s = expression_syntax(real_exp);
  list l_formal = NIL;
 
  pips_debug_effects(6,"initial regions :\n", l_reg);
 
 
  switch (syntax_tag(real_s))
  {
  case is_syntax_call:
  {
    call real_call = syntax_call(real_s);
    entity real_op = call_function(real_call);
    list args = call_arguments(real_call);
    type uet = ultimate_type(entity_type(real_op));
    value real_op_v = entity_initial(real_op);
 
    pips_debug(5, "call case, function %s \n", module_local_name(real_op));
    if(type_functional_p(uet))
    {
      if (value_code_p(real_op_v))
      {
        pips_debug(5, "external function\n");
        pips_user_warning("Nested function calls are ignored. Consider splitting the code before running PIPS\n");
        l_formal = NIL;
        break;
      }
      else /* it's an intrinsic : FI, cannot it be a constant? */
      {
        pips_debug(5, "intrinsic function\n");
 
        if (ENTITY_ASSIGN_P(real_op))
        {
          pips_debug(5, "assignment case\n");
          l_formal = c_convex_effects_on_actual_parameter_forward_translation
              (callee, EXPRESSION(CAR(CDR(args))), formal_ent, l_reg, context);
          break;
        }
        else if(ENTITY_ADDRESS_OF_P(real_op))
        {
          expression arg1 = EXPRESSION(CAR(args));
          list l_real_arg = NIL;
          effect eff_real;
          int nb_phi_real;
          Psysteme sc_nb_phi_real;
          expression exp_nb_phi_real = expression_undefined;
          bool general_case = true;
          bool in_out = in_out_methods_p();
 
          pips_debug(5, "address of case\n");
 
          /* first we compute a SIMPLE effect on the argument of the address_of operator.
           * This is to distinguish between the general case and the case where
           * the operand of the & operator is an array element.
           * Simple effect indices are easier to retrieve.
           */
          set_methods_for_proper_simple_effects();
          list l_eff_real = NIL;
          l_real_arg = generic_proper_effects_of_complex_address_expression
              (arg1, &l_eff_real, true);
 
          eff_real = EFFECT(CAR(l_eff_real)); /* there should be a FOREACH here to scan the whole list */
          gen_free_list(l_eff_real);
 
          nb_phi_real = (int) gen_length(reference_indices(effect_any_reference(eff_real)));
          gen_full_free_list(l_real_arg);
 
          /* there are indices but we don't know if they represent array dimensions,
           * struct/union/enum fields, or pointer dimensions.
           */
          if(nb_phi_real > 0)
          {
            reference eff_real_ref = effect_any_reference(eff_real);
            list l_inds_real = NIL, l_tmp = NIL;
            reference ref_tmp;
            type t = type_undefined;
 
            for(l_inds_real = reference_indices(eff_real_ref); !ENDP(CDR(l_inds_real)); POP(l_inds_real))
            {
              l_tmp = gen_nconc(l_tmp, CONS(EXPRESSION, copy_expression(EXPRESSION(CAR(l_inds_real))), NIL));
            }
 
            ref_tmp = make_reference(reference_variable(eff_real_ref), l_tmp);
            t = simple_effect_reference_type(ref_tmp);
            free_reference(ref_tmp);
 
            if (type_undefined_p(t))
              pips_internal_error("undefined type not expected ");
 
            if(type_variable_p(t) && !ENDP(variable_dimensions(type_variable(t))))
            {
              pips_debug(5,"array element or sub-array case\n");
              general_case = false;
              /* we build the constraint PHI_nb_phi_real >= last index of eff_real */
              exp_nb_phi_real = copy_expression(EXPRESSION(CAR(l_inds_real))); // copy necessary because eff_real is freed afterwards
              sc_nb_phi_real = sc_new();
              (void) sc_add_phi_equation(&sc_nb_phi_real,
                  copy_expression(exp_nb_phi_real),
                  nb_phi_real, NOT_EG, NOT_PHI_FIRST);
            }
            else
              pips_debug(5, "general case\n");
          }
 
          free_effect(eff_real);
          eff_real = effect_undefined;
          /* well, not strictly necessary : forward propagation is only for OUT regions */
          if (in_out)
            set_methods_for_convex_in_out_effects();
          else
            set_methods_for_convex_rw_effects();
          init_convex_inout_prettyprint(module_local_name(get_current_module_entity()));
 
          /* now we compute a *convex* effect on the argument of the
           * address_of operator and modify it's last dimension
           * according to the fact that there is an addressing operator
           */
 
          l_eff_real = NIL;
          l_real_arg = generic_proper_effects_of_complex_address_expression
              (arg1, &l_eff_real, true);
          eff_real = EFFECT(CAR(l_eff_real)); /*There should be a FOREACH to handle all elements */
          gen_free_list(l_eff_real);
 
          gen_full_free_list(l_real_arg);
 
          if (!general_case)
          {
            /* array element operand : we replace the constraint on the last
             * phi variable with */
            entity phi_nb_phi_real = make_phi_entity(nb_phi_real);
            region_exact_projection_along_variable(eff_real, phi_nb_phi_real);
            region_sc_append_and_normalize(eff_real, sc_nb_phi_real, 1);
            (void) sc_free(sc_nb_phi_real);
          }
 
          FOREACH(EFFECT, eff_orig, l_reg)
          {
            int nb_phi_orig = (int) gen_length(reference_indices(effect_any_reference(eff_orig)));
 
            /* First we have to test if the eff_real access path leads to the eff_orig access path */
 
            /* to do that, if the entities are the same (well in fact we should also
             * take care of aliasing), we add the constraints of eff_real to those of eff_orig,
             * and the system must be feasible.
             * We should also take care of linearization here.
             */
            bool exact_p;
            if(path_preceding_p(eff_real, eff_orig, transformer_undefined, false, &exact_p))
            {
              // functions that can be pointed by effect_dup_func:
              // simple_effect_dup
              // region_dup
              // copy_effect
              effect eff_formal = (*effect_dup_func)(eff_orig);
              region_sc_append_and_normalize(eff_formal, region_system(eff_real), 1);
 
              if (sc_empty_p(region_system(eff_formal)))
              {
                pips_debug(5, "the original effect does not correspond to the actual argument \n");
                free_effect(eff_formal);
              }
              else
              {
                /* I guess we could reuse convex_cell_reference_with_address_of_cell_reference_translation */
                /* At least part of the original effect corresponds to the actual argument :
                 * we need to translate it
                 */
                Psysteme sc_formal;
                reference ref_formal = effect_any_reference(eff_formal);
                reference new_ref;
                list new_inds = NIL;
                int i, min_phi, min_i;
 
                pips_debug_effect(5, "matching access paths, considered effect is : \n", eff_formal);
 
                /* first we translate the predicate in the callee's name space */
                convex_region_descriptor_translation(eff_formal);
                pips_debug_effect(5, "eff_formal after context translation: \n", eff_formal);
 
                /* Then we remove the phi variables common to the two regions
                 * except the last one if we are not in the general case */
                /* This is only valid when there is no linearization ; in the general case
                 * a translation system should be built
                 */
                sc_formal = region_system(eff_formal);
                for(i = 1; i <= nb_phi_real; i++)
                {
                  entity phi_i = make_phi_entity(i);
                  entity psi_i = make_psi_entity(i);
 
                  sc_formal = sc_variable_rename(sc_formal, (Variable) phi_i, (Variable) psi_i);
                }
                /* if not in the general case, we add the constraint
                 * phi_nb_phi_real == psi_nb_phi_real - exp_nb_phi_real
                 */
                if (!general_case)
                {
                  entity phi = make_phi_entity(nb_phi_real);
                  Pvecteur v_phi = vect_new((Variable) phi, VALUE_ONE);
                  entity psi = make_psi_entity(nb_phi_real);
                  Pvecteur v_psi = vect_new((Variable) psi, VALUE_ONE);
                  Pvecteur v = vect_substract(v_phi, v_psi);
                  normalized nexp = NORMALIZE_EXPRESSION(exp_nb_phi_real);
                  if (normalized_linear_p(nexp))
                  {
                    pips_debug(6, "normalized last index : "
                        "adding phi_nb_phi_real == psi_nb_phi_real - exp_nb_phi_real \n");
                    Pvecteur v1 = vect_copy(normalized_linear(nexp));
                    Pvecteur v2;
                    v2 = vect_add(v, v1);
                    sc_formal = sc_constraint_add(sc_formal, contrainte_make(v2), true);
                    vect_rm(v1);
                  }
                  vect_rm(v_psi);
                  vect_rm(v);
                }
                region_system(eff_formal) = sc_formal;
                pips_debug_effect(5, "eff_formal before removing psi variables: \n", eff_formal);
                region_remove_psi_variables(eff_formal);
                pips_debug_effect(5, "eff_formal after renaming common dimensions: \n", eff_formal);
 
                /* Finally, we must rename remaining phi variables from 2
                 * add a PHI1==0 constraint in the general case,
                 * or, in the contrary, rename remaining phi variables from 1.
                 * We must also change the resulting region
                 * entity for the formal entity in all cases.
                 */
                min_phi = general_case? 2:1;
                min_i = general_case ? nb_phi_real+1 : nb_phi_real;
                sc_formal = region_system(eff_formal);
 
                pips_debug(8, "nb_phi_real: %d, min_i: %d, min_phi: %d\n", nb_phi_real, min_i, min_phi);
                for(i = min_i; i <= nb_phi_orig; i++)
                {
                  pips_debug(8, "renaming %d-th index into %d-th\n", i, i-min_i+min_phi);
                  entity phi_i = make_phi_entity(i);
                  entity psi_formal = make_psi_entity(i-min_i+min_phi);
 
                  // the call to gen_nth is rather costly
                  expression original_index_exp =
                      EXPRESSION( gen_nth(i-1, cell_indices(effect_cell(eff_orig))));
 
                  pips_assert("index expression of an effect must be a reference",
                      expression_reference_p(original_index_exp));
                  if (entity_field_p(reference_variable(expression_reference(original_index_exp))))
                  {
                    pips_debug(8, "field expression (%s)\n",
                        entity_name(reference_variable(expression_reference(original_index_exp))));
                    new_inds = gen_nconc(new_inds,
                        CONS(EXPRESSION,
                            copy_expression(original_index_exp),
                            NIL));
                  }
                  else
                  {
                    pips_debug(8, "phi expression \n");
                    sc_formal = sc_variable_rename(sc_formal, (Variable) phi_i, (Variable) psi_formal);
 
                    new_inds = gen_nconc(new_inds,
                        CONS(EXPRESSION,
                            make_phi_expression(i-nb_phi_real+1),
                            NIL));
                  }
 
                }
                for(i=min_phi; i<= nb_phi_orig-min_i+min_phi; i++)
                {
                  entity phi_i = make_phi_entity(i);
                  entity psi_i = make_psi_entity(i);
                  sc_formal = sc_variable_rename(sc_formal, (Variable) psi_i, (Variable) phi_i);
                }
                region_system(eff_formal) = sc_formal;
                pips_debug_effect(5, "eff_formal after shifting dimensions: \n", eff_formal);
 
                if(general_case)
                {
                  /* add PHI1 == 0 */
                  sc_formal = region_system(eff_formal);
                  (void) sc_add_phi_equation(&sc_formal, int_to_expression(0), 1, IS_EG, PHI_FIRST);
                  region_system(eff_formal) = sc_formal;
                  new_inds = CONS(EXPRESSION, make_phi_expression(1), new_inds);
                }
 
                free_reference(ref_formal);
                new_ref = make_reference(formal_ent, new_inds);
                cell_reference(effect_cell(eff_formal)) = new_ref;
                pips_debug_effect(5, "final eff_formal : \n", eff_formal);
                l_formal = RegionsMustUnion(l_formal, CONS(EFFECT, eff_formal, NIL),
                    effects_same_action_p);
                pips_debug_effects(6,"l_formal after adding new effect : \n", l_formal);
 
              } /* else of the if (sc_empty_p) */
 
            } /* if(effect_entity(eff_orig) == effect_entity(eff_real) ...)*/
 
          } /* FOREACH */
 
          if (!expression_undefined_p(exp_nb_phi_real))
            free_expression(exp_nb_phi_real);
          break;
        }
        else
        {
          pips_debug(5, "Other intrinsic case : entering general case \n");
        }
      }
    }
    else if(type_variable_p(uet))
    {
      pips_user_warning("Effects of call thru functional pointers are ignored\n");
      l_formal = NIL;
      break;
    }
  }
  // entering general case which includes general calls
  _FALLTHROUGH_;
  case is_syntax_reference:
  case is_syntax_subscript:
  {
    effect eff_real = effect_undefined;
 
    pips_debug(5, "general case\n");
 
    /* first we compute an effect on the real_arg */
    if (syntax_reference_p(real_s))
      eff_real = make_reference_region(syntax_reference(real_s), make_action_write_memory());
    else
    {
      list l_eff_real = NIL;
      list l_real_arg = generic_proper_effects_of_complex_address_expression
          (real_exp, &l_eff_real, true);
      gen_full_free_list(l_real_arg);
      if (!ENDP(l_eff_real))
        eff_real = EFFECT(CAR(l_eff_real)); /*there should be a foreach to scan all the elements */
      gen_free_list(l_eff_real);
    }
 
    if (!effect_undefined_p(eff_real))
    {
      FOREACH(EFFECT, eff_orig, l_reg)
                  {
        int nb_phi_orig = (int) gen_length(reference_indices(effect_any_reference(eff_orig)));
        int nb_phi_real = (int) gen_length(reference_indices(effect_any_reference(eff_real)));
        /* First we have to test if the eff_real access path leads to the eff_orig access path */
 
        /* to do that, if the entities are the same (well in fact we should also
                   take care of aliasing), we add the constraints of eff_real to those of eff_orig,
                   and the system must be feasible.
         */
 
        bool exact_p;
        if(path_preceding_p(eff_real, eff_orig, transformer_undefined, true, &exact_p)
            &&  nb_phi_orig >= nb_phi_real)
        {
          effect eff_orig_dup = (*effect_dup_func)(eff_orig);
          region_sc_append_and_normalize(eff_orig_dup, region_system(eff_real), 1);
 
          if (sc_empty_p(region_system(eff_orig_dup)))
          {
            pips_debug(5, "the original effect does not correspond to the actual argument \n");
            free_effect(eff_orig_dup);
          }
          else
          {
            /* At least part of the original effect corresponds to the actual argument :
                           we need to translate it
             */
            reference ref_formal = make_reference(formal_ent, NIL);
            effect eff_formal = make_reference_region(ref_formal, copy_action(effect_action(eff_orig)));
 
            pips_debug_effect(5, "matching access paths, considered effect is : \n", eff_orig_dup);
 
            /* first we perform the path translation */
            reference n_eff_ref;
            descriptor n_eff_d;
            effect n_eff;
            bool exact_translation_p;
            convex_cell_reference_with_value_of_cell_reference_translation(effect_any_reference(eff_orig_dup),
                effect_descriptor(eff_orig_dup),
                ref_formal,
                effect_descriptor(eff_formal),
                nb_phi_real,
                &n_eff_ref, &n_eff_d,
                &exact_translation_p);
            n_eff = make_effect(make_cell_reference(n_eff_ref), copy_action(effect_action(eff_orig)),
                exact_translation_p? copy_approximation(effect_approximation(eff_orig)) : make_approximation_may(),
                    n_eff_d);
            pips_debug_effect(5, "final eff_formal : \n", n_eff);
 
            /* then  we translate the predicate in the callee's name space */
            convex_region_descriptor_translation(n_eff);
            pips_debug_effect(5, "eff_formal after context translation: \n", n_eff);
 
            l_formal = RegionsMustUnion(l_formal, CONS(EFFECT, n_eff, NIL),effects_same_action_p);
            pips_debug_effects(6, "l_formal after adding new effect : \n", l_formal);
          } /* else of the if (sc_empty_p) */
 
        } /* if(effect_entity(eff_orig) == effect_entity(eff_real) ...)*/
 
 
 
        /* */
 
                  } /* FOREACH */
    }
 
    break;
  }
  case is_syntax_application:
  {
    pips_internal_error("Application not supported yet");
    break;
  }
 
  case is_syntax_cast:
  {
    pips_debug(6, "cast expression\n");
    type formal_ent_type = entity_basic_concrete_type(formal_ent);
    expression cast_exp = cast_expression(syntax_cast(real_s));
    type cast_exp_type = expression_to_type(cast_exp);
    if (basic_concrete_types_compatible_for_effects_interprocedural_translation_p(cast_exp_type, formal_ent_type))
    {
      l_formal =
          c_convex_effects_on_actual_parameter_forward_translation
          (callee, cast_exp,
              formal_ent, l_reg, context);
    }
    else
    {
      expression formal_exp = entity_to_expression(formal_ent);
      l_formal = c_actual_argument_to_may_summary_effects(formal_exp, 'w');
      free_expression(formal_exp);
    }
    free_type(cast_exp_type);
    break;
  }
  case is_syntax_range:
  {
    pips_user_error("Illegal effective parameter: range\n");
    break;
  }
 
  case is_syntax_sizeofexpression:
  {
    pips_debug(6, "sizeofexpression : -> NIL");
    l_formal = NIL;
    break;
  }
  case is_syntax_va_arg:
  {
    pips_internal_error("va_arg not supported yet");
    break;
  }
  default:
    pips_internal_error("Illegal kind of syntax");
 
  } /* switch */
 
 
  pips_debug_effects(6,"resulting regions :\n", l_formal);
  return(l_formal);
 
}

References _FALLTHROUGH_, basic_concrete_types_compatible_for_effects_interprocedural_translation_p(), c_actual_argument_to_may_summary_effects(), c_convex_effects_on_actual_parameter_forward_translation(), call_arguments, call_function, callee, CAR, cast_expression, CDR, cell_indices(), cell_reference, CONS, contrainte_make(), convex_cell_reference_with_value_of_cell_reference_translation(), convex_region_descriptor_translation(), copy_action(), copy_approximation(), copy_expression(), EFFECT, effect_action, effect_any_reference, effect_approximation, effect_cell, effect_descriptor, effect_undefined, effect_undefined_p, effects_same_action_p(), ENDP, ENTITY_ADDRESS_OF_P, ENTITY_ASSIGN_P, entity_basic_concrete_type(), entity_field_p(), entity_initial, entity_name, entity_to_expression(), entity_type, EXPRESSION, expression_reference(), expression_reference_p(), expression_syntax, expression_to_type(), expression_undefined, expression_undefined_p, FOREACH, free_effect(), free_expression(), free_reference(), free_type(), gen_free_list(), gen_full_free_list(), gen_length(), gen_nconc(), gen_nth(), generic_proper_effects_of_complex_address_expression(), get_current_module_entity(), in_out_methods_p(), init_convex_inout_prettyprint(), int, int_to_expression(), IS_EG, is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, make_action_write_memory(), make_approximation_may(), make_cell_reference(), make_effect(), make_phi_entity(), make_phi_expression(), make_psi_entity(), make_reference(), make_reference_region(), module_local_name(), NIL, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, NOT_EG, NOT_PHI_FIRST, path_preceding_p(), PHI_FIRST, pips_assert, pips_debug, pips_debug_effect, pips_debug_effects, pips_internal_error, pips_user_error, pips_user_warning, POP, reference_indices, reference_variable, region_exact_projection_along_variable(), region_remove_psi_variables(), region_sc_append_and_normalize(), region_system, RegionsMustUnion(), sc_add_phi_equation(), sc_constraint_add(), sc_empty_p(), sc_free(), sc_new(), sc_variable_rename(), set_methods_for_convex_in_out_effects(), set_methods_for_convex_rw_effects(), set_methods_for_proper_simple_effects(), simple_effect_reference_type(), syntax_call, syntax_cast, syntax_reference, syntax_reference_p, syntax_tag, transformer_undefined, type_functional_p, type_undefined, type_undefined_p, type_variable, type_variable_p, ultimate_type(), value_code_p, VALUE_ONE, variable_dimensions, vect_add(), vect_copy(), vect_new(), vect_rm(), and vect_substract().

Referenced by c_convex_effects_on_actual_parameter_forward_translation(), set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the caller graph for this function:

c_convex_effects_on_formal_parameter_backward_translation()

list c_convex_effects_on_formal_parameter_backward_translation	(	list	l_sum_eff,
		expression	real_arg,
		transformer	context
	)

Parameters

l_sum_eff	is a list of effects on a C function formal parameter. These effects must be visible from the caller, which means that their reference has at leat one index.
real_arg	is an expression. It's the real argument corresponding to the formal parameter which memory effects are represented by l_sum_eff.
context	is the transformer translating the callee's neame space into the caller's name space.

Returns

a list of effects which are the translation of l_sum_eff in the caller's name space.

the result

if it's a pointer or a partially indexed array We should do more testing here to check if types are compatible...

the test here may not be right. I guess I should use basic_concrete_type here BC

Then we compute the region corresponding to the real argument

this could easily be made generic BC.

FI: I add the restriction on store regions, but they should have been eliminated before translation is attempted

we translate the initial region descriptor into the caller's name space

and then perform the translation

shouldn't it be a union ? BC

if (pointer_type_p(real_arg_t))

else

case is_syntax_reference

first we compute an effect on the argument of the address_of operator (to treat cases like &(n->m))

we translate the initial region descriptor into the caller's name space

if(!ENDP(eff_ind))

else du if (effect_undefined_p(eff_real) || ...)

FOREACH(EFFECT, eff, l_sum_eff)

FOREACH (EFFECT, eff_real, l_eff_real)

if it's a pointer or a partially indexed array We should do more testing here to check if types are compatible...

first compute the region corresponding to the real argument

this could easily be made generic BC.

FI: I add the restriction on store regions, but they should have been eliminated before translation is attempted

we translate the initial region descriptor into the caller's name space

and then perform the translation

shouldn't it be a union ? BC

if (pointer_type_p(real_arg_t))

else

first we compute an effect on the real_arg

first we translate the formal region predicate

Then we append the formal region to the real region

Well this is valid only in the general case : we should verify that types are compatible.

else du if (effect_undefined_p(eff_real))

shouldn't it be a union ? BC

FOREACH(EFFECT, eff, l_sum_eff)

BC : do not generate effects on HEAP

n_eff = heap_effect(get_current_module_entity(), copy_action(effect_action(eff)));

case is_syntax_call

we should test here the compatibility of the casted expression type with the formal entity type. It is not available here, however, I think it's equivalent to test the compatibility with the real arg expression type since the current function is called after testing the compatilibty between the real expression type and the formal parameter type.

let us at least generate effects on all memory locations reachable from the cast expression

switch

free_type(real_arg_t);

Parameters

l_sum_eff	_sum_eff
real_arg	eal_arg
context	ontext

Definition at line 523 of file interprocedural.c.

{
  list l_eff = NIL; /* the result */
  syntax real_s = expression_syntax(real_arg);
  type real_arg_t = expression_to_type(real_arg);
 
 
  ifdebug(5)
  {
    pips_debug(8, "begin for real arg %s, of type %s and effects :\n",
               expression_to_string(real_arg),
               type_to_string(real_arg_t));
    (*effects_prettyprint_func)(l_sum_eff);
  }
 
  switch (syntax_tag(real_s))
  {
  case is_syntax_reference:
  {
    reference real_ref = syntax_reference(real_s);
    entity real_ent = reference_variable(real_ref);
    list real_ind = reference_indices(real_ref);
 
    /* if it's a pointer or a partially indexed array
     * We should do more testing here to check if types
     * are compatible...
     */
 
    /* the test here may not be right. I guess I should use basic_concrete_type here BC */
    if (pointer_type_p(real_arg_t) ||
        gen_length(real_ind) < type_depth(entity_type(real_ent)))
    {
      FOREACH(EFFECT, eff, l_sum_eff) {
        reference new_ref = copy_reference(real_ref);
        effect real_eff = effect_undefined;
 
        pips_debug(8, "pointer type real arg reference\n");
 
        /* Then we compute the region corresponding to the
         * real argument
         */
        pips_debug(8, "effect on the pointed area : \n");
        // functions that can be pointed by reference_to_effect_func:
        // reference_to_simple_effect
        // reference_to_convex_region
        // reference_to_reference_effect
        real_eff = (*reference_to_effect_func)
                      (new_ref, copy_action(effect_action(eff)), false);
 
        /* this could easily be made generic BC. */
        /* FI: I add the restriction on store regions, but
         * they should have been eliminated before translation
         * is attempted */
        if(!anywhere_effect_p(real_eff) && store_effect_p(real_eff))
        {
          reference n_eff_ref;
          descriptor n_eff_d;
          effect n_eff;
          bool exact_translation_p;
          // functions that can be pointed by effect_dup_func:
          // simple_effect_dup
          // region_dup
          // copy_effect
          effect init_eff = (*effect_dup_func)(eff);
 
          /* we translate the initial region descriptor
           * into the caller's name space
           */
          convex_region_descriptor_translation(init_eff);
          /* and then perform the translation */
          convex_cell_reference_with_value_of_cell_reference_translation(effect_any_reference(init_eff),
              effect_descriptor(init_eff),
              effect_any_reference(real_eff),
              effect_descriptor(real_eff),
              0,
              &n_eff_ref, &n_eff_d,
              &exact_translation_p);
          n_eff = make_effect(make_cell_reference(n_eff_ref), copy_action(effect_action(eff)),
              exact_translation_p? copy_approximation(effect_approximation(eff)) : make_approximation_may(),
                  n_eff_d);
          /* shouldn't it be a union ? BC */
          l_eff = gen_nconc(l_eff, CONS(EFFECT, n_eff, NIL));
          free_effect(init_eff);
          free_effect(real_eff);
        }
      }
    } /*  if (pointer_type_p(real_arg_t)) */
    else
    {
      pips_debug(8, "real arg reference is not a pointer and is not a partially indexed array -> NIL \n");
 
    } /* else */
    break;
  } /* case is_syntax_reference */
  case is_syntax_subscript:
  {
    pips_debug(8, "Subscript not supported yet -> anywhere");
    bool read_p = false, write_p = false;
    FOREACH(EFFECT, eff, l_sum_eff)
    {
      if(effect_write_p(eff)) write_p = true;
      else read_p = true;
    }
 
    if (write_p)
      l_eff = gen_nconc(l_eff, CONS(EFFECT, make_anywhere_effect(make_action_write_memory()), NIL));
    if (read_p)
      l_eff = gen_nconc(l_eff, CONS(EFFECT, make_anywhere_effect(make_action_read_memory()), NIL));
    break;
  }
  case is_syntax_call:
  {
    call real_call = syntax_call(real_s);
    entity real_op = call_function(real_call);
    list args = call_arguments(real_call);
    effect n_eff = effect_undefined;
 
    if (ENTITY_ASSIGN_P(real_op))
    {
      l_eff = c_convex_effects_on_formal_parameter_backward_translation
          (l_sum_eff, EXPRESSION(CAR(CDR(args))), context);
    }
    else if(ENTITY_ADDRESS_OF_P(real_op))
    {
      expression arg1 = EXPRESSION(CAR(args));
      list l_real_arg = NIL;
      list l_eff_real;
 
      /* first we compute an effect on the argument of the
       * address_of operator (to treat cases like &(n->m))*/
      pips_debug(6, "addressing operator case \n");
 
      l_real_arg =
          generic_proper_effects_of_complex_address_expression
          (arg1, &l_eff_real, true);
 
      pips_debug_effects(6, "base effects :\n", l_eff_real);
 
      FOREACH(EFFECT, eff_real, l_eff_real)
      {
        FOREACH(EFFECT, eff, l_sum_eff) {
          reference eff_ref = effect_any_reference(eff);
          list eff_ind = reference_indices(eff_ref);
 
          pips_debug_effect(6, "current formal effect :\n", eff);
 
          if (effect_undefined_p(eff_real) || anywhere_effect_p(eff_real))
          {
            n_eff =  make_anywhere_effect(copy_action(effect_action(eff)));
          }
          else
          {
            if(!ENDP(eff_ind))
            {
              // functions that can be pointed by effect_dup_func:
              // simple_effect_dup
              // region_dup
              // copy_effect
              effect eff_init = (*effect_dup_func)(eff);
 
              /* we translate the initial region descriptor
               * into the caller's name space
               */
              convex_region_descriptor_translation(eff_init);
 
              reference output_ref;
              descriptor output_desc;
              bool exact;
 
              convex_cell_reference_with_address_of_cell_reference_translation
              (effect_any_reference(eff), effect_descriptor(eff_init),
                  effect_any_reference(eff_real), effect_descriptor(eff_real),
                  0,
                  &output_ref, &output_desc,
                  &exact);
 
              if (entity_all_locations_p(reference_variable(output_ref)))
              {
                free_reference(output_ref);
                n_eff = make_anywhere_effect(copy_action(effect_action(eff)));
              }
              else
              {
                n_eff = make_effect(make_cell_reference(output_ref),
                    copy_action(effect_action(eff)),
                    exact? copy_approximation(effect_approximation(eff)): make_approximation_may(),
                        output_desc);
                pips_debug_effect(6, "resulting effect: \n", n_eff);
              }
            } /* if(!ENDP(eff_ind))*/
          } /* else du if (effect_undefined_p(eff_real) || ...) */
 
          l_eff = gen_nconc(l_eff, CONS(EFFECT, n_eff, NIL));
        } /*  FOREACH(EFFECT, eff, l_sum_eff) */
      } /* FOREACH (EFFECT, eff_real, l_eff_real) */
 
      gen_free_list(l_real_arg);
      gen_full_free_list(l_eff_real);
 
    }
    else if(ENTITY_DEREFERENCING_P(real_op))
    {
      // expression arg1 = EXPRESSION(CAR(args));
 
      pips_debug(6, "dereferencing operator case \n");
 
      /* if it's a pointer or a partially indexed array
       * We should do more testing here to check if types
       * are compatible...
       */
      if (pointer_type_p(real_arg_t) ||
          !ENDP(variable_dimensions(type_variable(real_arg_t))))
      {
        pips_debug(8, "pointer type real arg\n");
        /* first compute the region corresponding to the
         * real argument
         */
        list l_real_eff = NIL;
        list l_real_arg =
            generic_proper_effects_of_complex_address_expression
            (real_arg, &l_real_eff, true);
 
        pips_debug_effects(6, "base effects :\n", l_real_eff);
 
        FOREACH(EFFECT, real_eff, l_real_eff)
        {
          FOREACH(EFFECT, eff, l_sum_eff) {
            /* this could easily be made generic BC. */
            /* FI: I add the restriction on store regions, but
             * they should have been eliminated before translation
             * is attempted */
            if(!anywhere_effect_p(real_eff) && store_effect_p(real_eff))
            {
              reference n_eff_ref;
              descriptor n_eff_d;
              effect n_eff;
              bool exact_translation_p;
              // functions that can be pointed by effect_dup_func:
              // simple_effect_dup
              // region_dup
              // copy_effect
              effect init_eff = (*effect_dup_func)(eff);
 
              /* we translate the initial region descriptor
               * into the caller's name space
               */
              convex_region_descriptor_translation(init_eff);
              /* and then perform the translation */
              convex_cell_reference_with_value_of_cell_reference_translation(effect_any_reference(init_eff),
                  effect_descriptor(init_eff),
                  effect_any_reference(real_eff),
                  effect_descriptor(real_eff),
                  0,
                  &n_eff_ref, &n_eff_d,
                  &exact_translation_p);
              n_eff = make_effect(make_cell_reference(n_eff_ref), copy_action(effect_action(eff)),
                  exact_translation_p? copy_approximation(effect_approximation(eff)) : make_approximation_may(),
                      n_eff_d);
              /* shouldn't it be a union ? BC */
              l_eff = gen_nconc(l_eff, CONS(EFFECT, n_eff, NIL));
              free_effect(init_eff);
            }
          }
        }
        gen_free_list(l_real_arg);
        gen_full_free_list(l_real_eff);
 
      } /*  if (pointer_type_p(real_arg_t)) */
      else
      {
        pips_debug(8, "real arg reference is not a pointer and is not a partially indexed array -> NIL \n");
      } /* else */
      break;
    }
    else if(ENTITY_POINT_TO_P(real_op)|| ENTITY_FIELD_P(real_op))
    {
      list l_real_arg = NIL;
      list l_eff_real = NIL;
      /* first we compute an effect on the real_arg */
 
      pips_debug(6, "point_to or field operator\n");
      l_real_arg = generic_proper_effects_of_complex_address_expression
          (real_arg, &l_eff_real, true);
 
      FOREACH(EFFECT, eff_real, l_eff_real)
      {
        FOREACH(EFFECT, eff, l_sum_eff) {
          // functions that can be pointed by effect_dup_func:
          // simple_effect_dup
          // region_dup
          // copy_effect
          effect eff_formal = (*effect_dup_func)(eff);
          effect new_eff;
 
          if (effect_undefined_p(eff_real))
            new_eff =  make_anywhere_effect(copy_action(effect_action(eff)));
          else
          {
            // functions that can be pointed by effect_dup_func:
            // simple_effect_dup
            // region_dup
            // copy_effect
            new_eff = (*effect_dup_func)(eff_real);
            effect_approximation_tag(new_eff) =
                effect_approximation_tag(eff);
            effect_action_tag(new_eff) =
                effect_action_tag(eff);
 
 
            /* first we translate the formal region predicate */
            convex_region_descriptor_translation(eff_formal);
 
            /* Then we append the formal region to the real region */
            /* Well this is valid only in the general case :
             * we should verify that types are compatible. */
            new_eff = region_append(new_eff, eff_formal);
            free_effect(eff_formal);
 
          } /* else du if (effect_undefined_p(eff_real)) */
 
          /* shouldn't it be a union ? BC */
          l_eff = gen_nconc(l_eff, CONS(EFFECT, new_eff, NIL));
        } /* FOREACH(EFFECT, eff, l_sum_eff) */
      }
      gen_free_list(l_real_arg);
      gen_full_free_list(l_eff_real);
 
    }
    else if(ENTITY_MALLOC_SYSTEM_P(real_op))
    {
      /* BC : do not generate effects on HEAP */
      /* n_eff = heap_effect(get_current_module_entity(),
       *         copy_action(effect_action(eff)));*/
    }
    else
    {
      l_eff = gen_nconc
          (l_eff,
              c_actual_argument_to_may_summary_effects(real_arg, 'x'));
    }
 
    if (n_eff != effect_undefined && l_eff == NIL)
      l_eff = CONS(EFFECT,n_eff, NIL);
    break;
  } /* case is_syntax_call */
  case is_syntax_cast :
  {
    pips_debug(5, "cast case\n");
    expression cast_exp = cast_expression(syntax_cast(real_s));
    type cast_t = expression_to_type(cast_exp);
    /* we should test here the compatibility of the casted expression type with
     * the formal entity type. It is not available here, however, I think it's
     * equivalent to test the compatibility with the real arg expression type
     * since the current function is called after testing the compatilibty between
     * the real expression type and the formal parameter type.
     */
    if (types_compatible_for_effects_interprocedural_translation_p(cast_t, real_arg_t))
    {
      l_eff = gen_nconc
          (l_eff,
              c_convex_effects_on_formal_parameter_backward_translation
              (l_sum_eff, cast_exp, context));
    }
    else if (!ENDP(l_sum_eff))
    {
      /* let us at least generate effects on all memory locations reachable from
       * the cast expression
       */
      bool read_p = false, write_p = false;
      FOREACH(EFFECT, eff, l_sum_eff)
      {
        if(effect_write_p(eff)) write_p = true;
        else read_p = false;
      }
      tag t = write_p ? (read_p ? 'x' : 'w') : 'r';
      l_eff = gen_nconc
          (l_eff,
              c_actual_argument_to_may_summary_effects(cast_exp, t));
    }
 
    break;
  }
  case is_syntax_sizeofexpression :
  {
    pips_debug(5,"sizeof expression -> NIL");
    break;
  }
  case is_syntax_va_arg :
  {
    pips_internal_error("va_arg() : should have been treated before");
    break;
  }
  case is_syntax_application :
  {
    bool read_p = false, write_p = false;
    pips_user_warning("Application not supported yet -> anywhere effect\n");
    FOREACH(EFFECT, eff, l_sum_eff)
    {
      if(effect_write_p(eff)) write_p = true;
      else read_p = true;
    }
    if (write_p)
      l_eff = gen_nconc(l_eff, CONS(EFFECT, make_anywhere_effect(make_action_write_memory()), NIL));
    if (read_p)
      l_eff = gen_nconc(l_eff, CONS(EFFECT, make_anywhere_effect(make_action_read_memory()), NIL));
    break;
  }
  case is_syntax_range :
  {
    pips_user_error("Illegal effective parameter: range\n");
    break;
  }
  default:
    pips_internal_error("Illegal kind of syntax");
    break;
  } /* switch */
 
  /* free_type(real_arg_t); */
 
  if (!transformer_undefined_p(context)) {
    // functions that can be pointed by effects_precondition_composition_op:
    // effects_composition_with_preconditions_nop
    // convex_regions_precondition_compose
    (*effects_precondition_composition_op)(l_eff, context, false);
  }
  ifdebug(8)
  {
    pips_debug(8, "end with effects :\n");
    print_regions(l_eff);
  }
 
  return(l_eff);
}

References anywhere_effect_p(), c_actual_argument_to_may_summary_effects(), c_convex_effects_on_formal_parameter_backward_translation(), call_arguments, call_function, CAR, cast_expression, CDR, CONS, convex_cell_reference_with_address_of_cell_reference_translation(), convex_cell_reference_with_value_of_cell_reference_translation(), convex_region_descriptor_translation(), copy_action(), copy_approximation(), copy_reference(), EFFECT, effect_action, effect_action_tag, effect_any_reference, effect_approximation, effect_approximation_tag, effect_descriptor, effect_undefined, effect_undefined_p, effect_write_p, ENDP, ENTITY_ADDRESS_OF_P, entity_all_locations_p(), ENTITY_ASSIGN_P, ENTITY_DEREFERENCING_P, ENTITY_FIELD_P, ENTITY_MALLOC_SYSTEM_P, ENTITY_POINT_TO_P, entity_type, EXPRESSION, expression_syntax, expression_to_string(), expression_to_type(), FOREACH, free_effect(), free_reference(), gen_free_list(), gen_full_free_list(), gen_length(), gen_nconc(), generic_proper_effects_of_complex_address_expression(), ifdebug, is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, make_action_read_memory(), make_action_write_memory(), make_anywhere_effect(), make_approximation_may(), make_cell_reference(), make_effect(), NIL, pips_debug, pips_debug_effect, pips_debug_effects, pips_internal_error, pips_user_error, pips_user_warning, pointer_type_p(), print_regions(), reference_indices, reference_variable, region_append(), store_effect_p(), syntax_call, syntax_cast, syntax_reference, syntax_tag, transformer_undefined_p, type_depth(), type_to_string(), type_variable, types_compatible_for_effects_interprocedural_translation_p(), and variable_dimensions.

Referenced by c_convex_effects_on_formal_parameter_backward_translation(), set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

common_region_translation()

static list common_region_translation ( entity  callee, region  reg, bool  backward  )

static

static list common_region_translation(entity func, region reg, bool backward) input : func is the called function, real_args are the real arguments, reg is the region to translate (it concerns an array in a common), and backward indicates the direction of the translation.

output : a list of regions, that are the translation of the initial region. modifies : nothing: duplicates the original region. comment : the algorithm is the following

Scan the variables of the common that belong to the target function For each variable do if it has elements in common with the variable of the initial region if both variables have the same layout in the common perform the translation using array_region-translation else use the subscript values, and take into account the relative offset of the variables in the common add to the translated region the declaration system of the target variable to have a smaller region. until all the elements of the initial variable have been translated.

If the entity is a top-level entity, no translation; It is the case for variables dexcribing I/O effects (LUNS).

First, we search if the common is declared in the target function; if not, we have to deterministically choose an arbitrary function in which the common is declared. It will be our reference. By deterministically, I mean that this function shall be chosen whenever we try to translate from this common to a routine where it is not declared.

If common not declared in caller, use the subroutine of the first entity that appears in the common layout. (not really deterministic: I should take the first name in lexical order. BC.

first, we calculate the offset and size of the region entity

then, we perform the translation

these entities have elements in common

Definition at line 1656 of file interprocedural.c.

{
    list new_regions = NIL;
    entity reg_ent = region_entity(reg);
    entity caller = get_current_module_entity();
    entity source_func = backward ? callee : caller;
    entity target_func = backward ? caller : callee;
    entity entity_target_func = target_func;
    entity ccommon;
    list l_tmp, l_com_ent;
    int reg_ent_size, total_size, reg_ent_begin_offset, reg_ent_end_offset;
    region new_reg;
    bool found = false;
 
 
    ifdebug(5)
    {
        pips_debug(5,"input region: \n%s\n", region_to_string(reg));
    }
 
    /* If the entity is a top-level entity, no translation;
     * It is the case for variables dexcribing I/O effects (LUNS).
     */
 
    if (top_level_entity_p(reg_ent) || io_entity_p(reg_ent)
        || rand_effects_entity_p(reg_ent))
    {
        pips_debug(5,"top-level entity.\n");
        new_reg = region_translation
                    (reg, source_func, reference_undefined,
                     reg_ent, target_func, reference_undefined,
                     0, backward);
        new_regions = CONS(EFFECT, new_reg, NIL);
        return(new_regions);
    }
 
 
 
    ifdebug(6)
    {
        pips_debug(5, "target function: %s (local name: %s)\n",
                   entity_name(target_func), module_local_name(target_func));
    }
 
    /* First, we search if the common is declared in the target function;
     * if not, we have to deterministically choose an arbitrary function
     * in which the common is declared. It will be our reference.
     * By deterministically, I mean that this function shall be chosen whenever
     * we try to translate from this common to a routine where it is not
     * declared.
     */
    ccommon = ram_section(storage_ram(entity_storage(reg_ent)));
    l_com_ent = area_layout(type_area(entity_type(ccommon)));
 
    pips_debug(6, "common name: %s\n", entity_name(ccommon));
 
    for( l_tmp = l_com_ent; !ENDP(l_tmp) && !found; l_tmp = CDR(l_tmp) )
    {
        entity com_ent = ENTITY(CAR(l_tmp));
        if (strcmp(entity_module_name(com_ent),
                   module_local_name(target_func)) == 0)
        {
            found = true;
        }
    }
 
    /* If common not declared in caller, use the subroutine of the first entity
     * that appears in the common layout. (not really deterministic: I should
     * take the first name in lexical order. BC.
     */
    if(!found)
    {
        entity ent = ENTITY(CAR(l_com_ent));
        entity_target_func =
            module_name_to_entity(entity_module_name(ent));
        ifdebug(6)
        {
            pips_debug(6, "common not declared in caller,\n"
                       "\t using %s declarations instead\n",
                       entity_name(entity_target_func));
        }
    }
 
    /* first, we calculate the offset and size of the region entity */
    reg_ent_size = array_size(reg_ent);
    reg_ent_begin_offset = ram_offset(storage_ram(entity_storage(reg_ent)));
    reg_ent_end_offset = reg_ent_begin_offset + reg_ent_size - 1;
 
    pips_debug(6,
               "\n\treg_ent: size = %d, offset_begin = %d, offset_end = %d\n",
               reg_ent_size, reg_ent_begin_offset, reg_ent_end_offset);
 
    /* then, we perform the translation */
    ccommon = ram_section(storage_ram(entity_storage(reg_ent)));
    l_com_ent = area_layout(type_area(entity_type(ccommon)));
    total_size = 0;
 
    for(; !ENDP(l_com_ent) && (total_size < reg_ent_size);
        l_com_ent = CDR(l_com_ent))
    {
        entity new_ent = ENTITY(CAR(l_com_ent));
 
        pips_debug(6, "current entity: %s\n", entity_name(new_ent));
 
        if (strcmp(entity_module_name(new_ent),
                   module_local_name(entity_target_func)) == 0)
        {
            int new_ent_size = array_size(new_ent);
            int new_ent_begin_offset =
                ram_offset(storage_ram(entity_storage(new_ent)));
            int new_ent_end_offset = new_ent_begin_offset + new_ent_size - 1;
 
            pips_debug(6, "\n\t new_ent: size = %d, "
                       "offset_begin = %d, offset_end = %d \n",
                     new_ent_size, new_ent_begin_offset, new_ent_end_offset);
 
            if ((new_ent_begin_offset <= reg_ent_end_offset) &&
                (reg_ent_begin_offset <= new_ent_end_offset ))
                /* these entities have elements in common */
            {
                int offset = reg_ent_begin_offset - new_ent_begin_offset;
 
                new_reg = region_translation
                    (reg, source_func, reference_undefined,
                     new_ent, target_func, reference_undefined,
                     (Value) offset, backward);
                new_regions = RegionsMustUnion(new_regions,
                                               CONS(EFFECT, new_reg, NIL),
                                               effects_same_action_p);
                total_size += min (reg_ent_begin_offset,new_ent_end_offset)
                    - max(reg_ent_begin_offset, new_ent_begin_offset) + 1;
            }
        }
    }
 
    ifdebug(5)
    {
        pips_debug(5, "output regions: \n");
        print_regions(new_regions);
    }
    return(new_regions);
}

References area_layout, array_size(), callee, CAR, CDR, CONS, EFFECT, effects_same_action_p(), ENDP, ENTITY, entity_module_name(), entity_name, entity_storage, entity_type, get_current_module_entity(), ifdebug, io_entity_p(), max, min, module_local_name(), module_name_to_entity(), NIL, offset, pips_debug, print_regions(), ram_offset, ram_section, rand_effects_entity_p(), reference_undefined, region, region_entity, region_to_string(), region_translation(), RegionsMustUnion(), storage_ram, top_level_entity_p(), and type_area.

Referenced by common_regions_backward_translation(), and common_regions_forward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

common_regions_backward_translation()

static list common_regions_backward_translation ( entity  func, list  func_regions  )

static

we are only interested in regions concerning common variables. They are the entities with a ram storage. They can not be dynamic variables, because these latter were eliminated of the code_regions (cf. region_of_module).

Definition at line 486 of file interprocedural.c.

{
    list real_regions = NIL;
 
    MAP(EFFECT, func_reg,
    {
        /* we are only interested in regions concerning common variables.
         * They are  the entities with a ram storage. They can not be dynamic
         * variables, because these latter were eliminated of the code_regions
         * (cf. region_of_module). */
        if (storage_ram_p(entity_storage(region_entity(func_reg))))
        {
            list regs = common_region_translation(func, func_reg, BACKWARD);
            real_regions = RegionsMustUnion(real_regions, regs,
                                            effects_same_action_p);
        }
    },
        func_regions);
 
    return(real_regions);
 
}

References BACKWARD, common_region_translation(), EFFECT, effects_same_action_p(), entity_storage, MAP, NIL, region_entity, RegionsMustUnion(), and storage_ram_p.

Referenced by regions_backward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

common_regions_forward_translation()

static list common_regions_forward_translation ( entity  func, list  real_regions  )

static

static list common_regions_forward_translation (entity func, list real_regions) input : the called function, the list of real arguments at call site, and the list of regions to translate.

output : the translated list of regions. modifies : nothing. comment :

we are only interested in regions concerning common variables. They are the entities with a ram storagethat are not dynamic variables

Definition at line 1138 of file interprocedural.c.

{
    list func_regions = NIL;
 
    MAP(EFFECT, real_reg,
    {
        storage real_s = entity_storage(region_entity(real_reg));
        /* we are only interested in regions concerning common variables.
         * They are  the entities with a ram storagethat are not dynamic
         * variables*/
        if (storage_ram_p(real_s) &&
            !dynamic_area_p(ram_section(storage_ram(real_s)))
            && !heap_area_p(ram_section(storage_ram(real_s)))
            && !stack_area_p(ram_section(storage_ram(real_s))))
        {
            list regs = common_region_translation(func, real_reg, FORWARD);
            func_regions = RegionsMustUnion(func_regions, regs,
                                            effects_same_action_p);
        }
    },
        real_regions);
 
    return(func_regions);
}

References common_region_translation(), dynamic_area_p(), EFFECT, effects_same_action_p(), entity_storage, FORWARD, heap_area_p(), MAP, NIL, ram_section, region_entity, RegionsMustUnion(), stack_area_p(), storage_ram, and storage_ram_p.

Referenced by regions_forward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

convex_regions_backward_translation()

list convex_regions_backward_translation	(	entity	func,
		list	real_args,
		list	l_reg,
		transformer	context
	)

of effects

Parameters

func	unc
real_args	eal_args
l_reg	_reg
context	ontext

Definition at line 298 of file interprocedural.c.

{
    list l_res = NIL;
 
    l_res = regions_backward_translation(func, real_args, l_reg, context, true);
 
    return l_res;
}

References NIL, and regions_backward_translation().

Referenced by set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

convex_regions_forward_translation()

list convex_regions_forward_translation	(	entity	callee,
		list	real_args,
		list	l_reg,
		transformer	context
	)

of effects

Parameters

callee	allee
real_args	eal_args
l_reg	_reg
context	ontext

Definition at line 309 of file interprocedural.c.

{
    list l_res = NIL;
 
    if(fortran_module_p(callee) && fortran_module_p(get_current_module_entity()))
      l_res = regions_forward_translation(callee, real_args, l_reg, context);
    else if (c_module_p(callee) && c_module_p(get_current_module_entity()))
      l_res = generic_c_effects_forward_translation(callee, real_args, l_reg, context);
    return l_res;
}

References c_module_p(), callee, fortran_module_p(), generic_c_effects_forward_translation(), get_current_module_entity(), NIL, and regions_forward_translation().

Referenced by set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

convex_regions_translation_end()

void convex_regions_translation_end

(

void

)

Definition at line 108 of file interprocedural.c.

{
    reset_translation_context_sc();
    reset_arguments_to_eliminate();
}

References reset_arguments_to_eliminate(), and reset_translation_context_sc().

Referenced by set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

convex_regions_translation_init()

void convex_regions_translation_init	(	entity	callee,
		list	real_args,
		bool	backward_p
	)

jmp_buf overflow_error;

interprocedural.c

Parameters

callee	allee
real_args	eal_args
backward_p	ackward_p

Definition at line 98 of file interprocedural.c.

{
 
  set_interprocedural_translation_context_sc(callee, real_args);
  if (backward_p)
    set_backward_arguments_to_eliminate(callee);
  else
    set_forward_arguments_to_eliminate();
}

References callee, set_backward_arguments_to_eliminate(), set_forward_arguments_to_eliminate(), and set_interprocedural_translation_context_sc().

Referenced by set_methods_for_convex_effects(), and set_methods_for_convex_rw_pointer_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

formal_regions_backward_translation()

static list formal_regions_backward_translation ( entity  func, list  real_args, list  func_regions, transformer  context  )

static

static list formal_regions_backward_translation(entity func, list real_args, func_regions, transformer context) input : an external function func, its real arguments at call site (real_args), its summary regions (with formal args), and the calling context.

output : the translated formal regions. modifies : ? comment :

Algorithm :

let func_regions be the list of the regions on variables of func let real_regions be the list of the translated regions on common variables

real_regions = empty FOR each expression real_exp IN real_args arg_num = number in the list of the function real arguments FOR each func_reg IN func_regions func_ent = entity of the region func_reg IF func_ent is the formal parameter numbered arg_num IF real_exp is an lhs (expression with one entity) real_reg = translation of the region func_reg real_regions = (real_regions) U {real_reg} ELSE real_regions = (real_regions) U (regions of the expression real_exp) ENDIF ENDIF ENDFOR ENDFOR

If the formal parameter corresponds to the real argument then we perform the translation.

If the real argument is a reference to an entity, then we translate the regions of the corresponding formal parameter

The indices of the reference are always evaluated

Else, the real argument is a complex expression, which is merely evaluated during execution of the program; Since Fortran forbids write effects on expressions passed as arguments, the regions on the formal parameter are merely ignored. The regions computed are those of the real parameter expression.

Definition at line 414 of file interprocedural.c.

{
    list real_regions = NIL, r_args;
    int arg_num;
 
    pips_debug(8, "begin\n");
 
    for (r_args = real_args, arg_num = 1; r_args != NIL;
         r_args = CDR(r_args), arg_num++)
    {
        MAP(EFFECT, func_reg,
         {
             entity func_ent = region_entity(func_reg);
 
             /* If the formal parameter corresponds to the real argument then
              * we perform the translation.
              */
             if (ith_parameter_p(func, func_ent, arg_num))
             {
                 expression real_exp = EXPRESSION(CAR(r_args));
                 syntax real_syn = expression_syntax(real_exp);
 
                 /* If the real argument is a reference to an entity, then we
                  * translate the regions of the corresponding formal parameter
                  */
                 if (syntax_reference_p(real_syn))
                 {
                    reference real_ref = syntax_reference(real_syn);
                    list real_inds = reference_indices(real_ref);
                    entity real_ent = reference_variable(real_ref);
                    region real_reg;
                    real_reg =
                        region_translation(func_reg, func, reference_undefined,
                                  real_ent, get_current_module_entity(), real_ref,
                                  VALUE_ZERO, BACKWARD);
 
                    real_regions = regions_add_region(real_regions, real_reg);
                    /* The indices of the reference are always evaluated */
                    if (! ENDP(real_inds))
                        real_regions = gen_nconc
                            (real_regions,
                             proper_regions_of_expressions(real_inds, context));
                }
                 /* Else, the real argument is a complex expression, which
                  * is merely evaluated during execution of the program;
                  * Since Fortran forbids write effects on expressions
                  * passed as arguments, the regions on the formal parameter
                  * are merely ignored. The regions computed are those of the
                  * real parameter expression.
                  */
                 else
                 {
                    real_regions =
                        gen_nconc(real_regions,
                                  generic_proper_effects_of_expression(real_exp));
                }
             }
         }, func_regions);
    }
 
    ifdebug(5)
    {
       pips_debug(5, "proper real regions\n");
       print_regions(real_regions);
    }
    return(real_regions);
}

References BACKWARD, CAR, CDR, EFFECT, ENDP, EXPRESSION, expression_syntax, gen_nconc(), generic_proper_effects_of_expression(), get_current_module_entity(), ifdebug, ith_parameter_p(), MAP, NIL, pips_debug, print_regions(), proper_regions_of_expressions(), reference_indices, reference_undefined, reference_variable, region, region_entity, region_translation(), regions_add_region(), syntax_reference, syntax_reference_p, and VALUE_ZERO.

Referenced by regions_backward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

get_out_summary_regions_list()

list get_out_summary_regions_list

(

void

)

Definition at line 135 of file interprocedural.c.

{
    return(l_sum_out_reg);
}

References l_sum_out_reg.

in_regions_of_external()

list in_regions_of_external	(	entity	func,
		list	real_args,
		transformer	context
	)

list in_regions_of_external(entity func, list real_args, transformer context) input : an external function func, and the list of real arguments used in the calling function.

output : the corresponding list of regions, at call site. modifies : nothing. comment : The effects of "func" are computed into externals effects, ie. ‘translated’. The translation is made in two phases : _ regions on formal parameters _ regions on common parameters

Get the regions of "func".

translate them

Parameters

func	unc
real_args	eal_args
context	ontext

Definition at line 232 of file interprocedural.c.

{
    list le = NIL;
    const char *func_name = module_local_name(func);
 
    pips_debug(4, "translation regions for %s\n", func_name);
 
    if (! entity_module_p(func))
    {
        pips_internal_error("%s: bad function", func_name);
    }
    else
    {
        list func_regions;
 
        /* Get the regions of "func". */
        func_regions = effects_to_list((effects)
            db_get_memory_resource(DBR_IN_SUMMARY_REGIONS, func_name, true));
        /* translate them */
        le = regions_backward_translation(func, real_args, func_regions, context,
                                          SUMMARY);
    }
    return le;
}

References db_get_memory_resource(), effects_to_list(), entity_module_p(), module_local_name(), NIL, pips_debug, pips_internal_error, regions_backward_translation(), and SUMMARY.

Here is the call graph for this function:

out_regions_from_call_site_to_callee()

void out_regions_from_call_site_to_callee

(

call

c

)

void out_regions_from_call_site_to_callee(call c) input : a potential call site for current_callee.

output : nothing modifies : l_sum_out_reg becomes the may union of l_sum_out_reg and the translated out regions of the current call site. comment :

Definition at line 205 of file interprocedural.c.

{
    transformer context;
    list l_out = NIL, l_tmp = NIL;
 
    if (call_function(c) != current_callee)
        return;
 
    context= load_statement_precondition(current_stmt);
    l_out = load_statement_out_regions(current_stmt);
 
    l_tmp = regions_forward_translation(current_callee, call_arguments(c), l_out,
                                        context);
    update_out_summary_regions_list(l_tmp);
}

References call_arguments, call_function, current_callee, current_stmt, load_statement_out_regions(), load_statement_precondition(), NIL, regions_forward_translation(), and update_out_summary_regions_list().

Referenced by out_regions_from_caller_to_callee().

Here is the call graph for this function:

Here is the caller graph for this function:

out_regions_from_caller_to_callee()

list out_regions_from_caller_to_callee	(	entity	caller,
		entity	callee
	)

All we need to perform the translation

Parameters

caller	aller
callee	allee

Definition at line 150 of file interprocedural.c.

{
    const char *caller_name;
    statement caller_statement;
 
    reset_current_module_entity();
    set_current_module_entity(caller);
    caller_name = module_local_name(caller);
    pips_debug(2, "begin for caller: %s\n", caller_name);
 
    /* All we need to perform the translation */
    set_current_module_statement( (statement)
        db_get_memory_resource(DBR_CODE, caller_name, true) );
    set_cumulated_rw_effects((statement_effects)
        db_get_memory_resource(DBR_CUMULATED_EFFECTS, caller_name, true));
    set_proper_rw_effects((statement_effects)
        db_get_memory_resource(DBR_PROPER_EFFECTS, caller_name, true));
    module_to_value_mappings(caller);
    set_precondition_map( (statement_mapping)
        db_get_memory_resource(DBR_PRECONDITIONS, caller_name, true));
 
    set_out_effects( (statement_effects)
        db_get_memory_resource(DBR_OUT_REGIONS, caller_name, true) );
 
    caller_statement = (statement)
        db_get_memory_resource (DBR_CODE, caller_name, true);
 
    current_callee = callee;
    gen_multi_recurse(caller_statement,
                      statement_domain, stmt_filter, gen_null,
                      call_domain, out_regions_from_call_site_to_callee, gen_null,
                      NULL);
 
    reset_current_module_entity();
    set_current_module_entity(callee);
 
    free_value_mappings();
 
    reset_cumulated_rw_effects();
    reset_proper_rw_effects();
    reset_precondition_map();
    reset_out_effects();
    reset_current_module_statement();
    //free_value_mappings();
    pips_debug(2, "end\n");
    return(l_sum_out_reg);
}

References call_domain, callee, caller_name, current_callee, db_get_memory_resource(), free_value_mappings(), gen_multi_recurse(), gen_null(), l_sum_out_reg, module_local_name(), module_to_value_mappings(), out_regions_from_call_site_to_callee(), pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_out_effects(), reset_precondition_map(), reset_proper_rw_effects(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_out_effects(), set_precondition_map(), set_proper_rw_effects(), statement_domain, and stmt_filter().

Here is the call graph for this function:

real_regions_forward_translation()

static list real_regions_forward_translation ( entity  func, list  real_args, list  l_reg, transformer  context  )

static

static list real_regions_forward_translation(entity func, list real_args, l_reg, transformer context) input : the called function func, the real arguments of the call, the list of regions to translate, and the context of the call.

output : the list of translated regions correponding to the formal arguments of the called function. modifies : l_reg and the regions it contains. comment : for each real argument in real_args if it is a reference for each region in l_reg if the current region concerns the current real argument if the corresponding formal parameter is a scalar the translated region is a scalar region, which reference is the formal argument, and which action and approximation are those of the initial region. else it is an array, and the tranlation is performed by another procedure. endfor else, it is a complex expression we search the regions in l_reg corresponding to the elements accessed in the complex expression. and we make a read region corresponding to the formal scalar parameter. endif endfor

for each actual parameter expression, we search in the actual regions the corresponding elements. If it exists, we make the corresponding regions, and translate them

if

REVOIR ICI

else

for

Definition at line 1045 of file interprocedural.c.

{
    entity caller = get_current_module_entity();
    int arg_num;
    list l_formal = NIL;
    list r_args = real_args;
 
    /* for each actual parameter expression, we search in the actual regions
     * the corresponding elements. If it exists, we make the corresponding
     * regions, and translate them */
 
    ifdebug(8)
    {
        pips_debug(8,"initial regions :\n");
        print_regions(l_reg);
    }
 
    for (arg_num = 1; !ENDP(r_args); r_args = CDR(r_args), arg_num++)
    {
        expression real_exp = EXPRESSION(CAR(r_args));
        entity formal_ent = find_ith_formal_parameter(func, arg_num);
 
        if (syntax_reference_p(expression_syntax(real_exp)))
        {
            reference real_ref = syntax_reference(expression_syntax(real_exp));
            entity real_ent = reference_variable(real_ref);
 
            MAP(EFFECT, reg,
             {
                 entity reg_ent = region_entity(reg);
 
                 pips_debug(8, " real = %s, formal = %s \n",
                            entity_name(real_ent), entity_name(reg_ent));
 
                 if (same_entity_p(reg_ent , real_ent))
                 {
                     region formal_reg;
                     formal_reg = region_translation(
                         reg, caller, real_ref,
                         formal_ent, func, reference_undefined,
                         VALUE_ZERO, FORWARD);
                     l_formal = RegionsMustUnion(
                         l_formal,
                         CONS(EFFECT, formal_reg, NIL),
                         effects_same_action_p);
                 }
             }, l_reg);
 
        } /* if */
        else
        {
            /* REVOIR ICI */
            list l_exp_reg = regions_of_expression(real_exp, context);
            list l_real_exp =
                RegionsIntersection(l_exp_reg, effects_dup(l_reg),
                                    effects_same_action_p);
 
            pips_debug(8, "real argument is a complex expression \n"
                "\tit can not correspond to a written formal parameter.\n");
 
            if (!ENDP(l_real_exp))
            {
        action r = make_action_read_memory();
        region  formal_reg =
          reference_whole_region(make_regions_reference(formal_ent), r);
        free_action(r);
                effect_to_may_effect(formal_reg);
                l_formal = RegionsMustUnion(l_formal,
                                            CONS(EFFECT, formal_reg, NIL),
                                            effects_same_action_p);
                regions_free(l_real_exp);
            }
 
        } /* else */
 
    } /* for */
 
 
    return(l_formal);
}

References CAR, CDR, CONS, EFFECT, effect_to_may_effect(), effects_dup(), effects_same_action_p(), ENDP, entity_name, EXPRESSION, expression_syntax, find_ith_formal_parameter(), FORWARD, free_action(), get_current_module_entity(), ifdebug, make_action_read_memory(), make_regions_reference(), MAP, NIL, pips_debug, print_regions(), reference_undefined, reference_variable, reference_whole_region(), region, region_entity, region_translation(), regions_free(), regions_of_expression(), RegionsIntersection(), RegionsMustUnion(), same_entity_p(), syntax_reference, syntax_reference_p, and VALUE_ZERO.

Referenced by regions_forward_translation().

Here is the call graph for this function:

Here is the caller graph for this function:

regions_backward_translation()

list regions_backward_translation	(	entity	func,
		list	real_args,
		list	func_regions,
		transformer	context,
		bool	proper
	)

list regions_backward_tranlation(entity func, list real_args, list func_regions, transformer context) input : an external function func, and the list of real arguments used in the calling function.

output : the corresponding list of regions, at call site. modifies : nothing. comment : The effects of "func" are computed into externals effects, ie. ‘translated’. The translation is made in two phases : _ regions on formal parameters _ regions on common parameters

Compute the regions on formal variables.

Compute the regions on common variables (static & global variables).

FI: add local precondition (7 December 1992)

Parameters

func	unc
real_args	eal_args
func_regions	unc_regions
context	ontext
proper	roper

Definition at line 341 of file interprocedural.c.

{
    list le = NIL;
    list tce, tfe;
 
    ifdebug(4)
    {
        pips_debug(4,"Initial regions\n");
        print_regions(func_regions);
    }
 
    set_interprocedural_translation_context_sc(func,real_args);
    set_backward_arguments_to_eliminate(func);
 
    /* Compute the regions on formal variables. */
    tfe = formal_regions_backward_translation(func,real_args,func_regions,context);
 
    /* Compute the regions on common variables (static & global variables). */
    tce = common_regions_backward_translation(func, func_regions);
 
    if (proper)
        le = gen_nconc(tce,tfe);
    else
        le = RegionsMustUnion(tce, tfe, effects_same_action_p);
 
    /* FI: add local precondition (7 December 1992) */
    le = regions_add_context(le, context);
 
    ifdebug(4)
    {
        pips_debug(4, " Translated_regions :\n");
        print_regions(le);
    }
 
    reset_translation_context_sc();
    reset_arguments_to_eliminate();
    return(le);
}

References common_regions_backward_translation(), effects_same_action_p(), formal_regions_backward_translation(), gen_nconc(), ifdebug, NIL, pips_debug, print_regions(), regions_add_context(), RegionsMustUnion(), reset_arguments_to_eliminate(), reset_translation_context_sc(), set_backward_arguments_to_eliminate(), and set_interprocedural_translation_context_sc().

Referenced by convex_regions_backward_translation(), in_regions_of_external(), and regions_of_external().

Here is the call graph for this function:

Here is the caller graph for this function:

regions_forward_translation()

list regions_forward_translation	(	entity	func,
		list	real_args,
		list	l_reg,
		transformer	context
	)

list regions_forward_translation(entity func, list real_args, l_reg, transformer context input : the called function func, the real arguments of the call, the list of regions to translate, and the context of the call.

output : the translated list of regions : real arguments are translated into formal arguments, and common variables of the caller into common variables of the callee. modifies : nothing. comment :

Parameters

func	unc
real_args	eal_args
l_reg	_reg
context	ontext

Definition at line 980 of file interprocedural.c.

{
    list l_t_reg = NIL;
    list l_form_reg, l_common_reg;
 
    ifdebug(3)
    {
        pips_debug(3,"initial regions :\n");
        print_regions(l_reg);
    }
 
    set_interprocedural_translation_context_sc(func,real_args);
    set_forward_arguments_to_eliminate();
 
    l_form_reg = real_regions_forward_translation
        (func, real_args, l_reg, context);
    l_common_reg = common_regions_forward_translation(func, l_reg);
    l_t_reg = RegionsMustUnion
        (l_form_reg, l_common_reg, effects_same_action_p);
 
    ifdebug(3)
    {
        pips_debug(3,"final regions : \n");
        print_regions(l_t_reg);
    }
 
    reset_translation_context_sc();
    reset_arguments_to_eliminate();
    return l_t_reg;
}

References common_regions_forward_translation(), effects_same_action_p(), ifdebug, NIL, pips_debug, print_regions(), real_regions_forward_translation(), RegionsMustUnion(), reset_arguments_to_eliminate(), reset_translation_context_sc(), set_forward_arguments_to_eliminate(), and set_interprocedural_translation_context_sc().

Referenced by convex_regions_forward_translation(), and out_regions_from_call_site_to_callee().

Here is the call graph for this function:

Here is the caller graph for this function:

regions_of_external()

list regions_of_external	(	entity	func,
		list	real_args,
		transformer	context,
		bool	proper
	)

list regions_of_external(entity func, list real_args, transformer context) input : an external function func, and the list of real arguments used in the calling function.

output : the corresponding list of regions, at call site. modifies : nothing. comment : The effects of "func" are computed into externals effects, ie. ‘translated’. The translation is made in two phases : _ regions on formal parameters _ regions on common parameters

Get the regions of "func".

translate them

Parameters

func	unc
real_args	eal_args
context	ontext
proper	roper

Definition at line 271 of file interprocedural.c.

{
    list le = NIL;
    const char *func_name = module_local_name(func);
 
    pips_debug(4, "translation regions for %s\n", func_name);
 
    if (! entity_module_p(func))
    {
        pips_internal_error("%s: bad function", func_name);
    }
    else
    {
        list func_regions;
 
        /* Get the regions of "func". */
        func_regions = effects_to_list((effects)
            db_get_memory_resource(DBR_SUMMARY_REGIONS, func_name, true));
        /* translate them */
        le = regions_backward_translation(func, real_args, func_regions, context,
                                          proper);
    }
    return le;
}

References db_get_memory_resource(), effects_to_list(), entity_module_p(), module_local_name(), NIL, pips_debug, pips_internal_error, and regions_backward_translation().

Here is the call graph for this function:

reset_out_summary_regions_list()

void reset_out_summary_regions_list

(

void

)

Definition at line 121 of file interprocedural.c.

{
    l_sum_out_reg = list_undefined;
}

References l_sum_out_reg, and list_undefined.

Referenced by regions_to_loops().

Here is the caller graph for this function:

stmt_filter()

static bool stmt_filter ( statement  s )

static

Definition at line 140 of file interprocedural.c.

{
    pips_debug(1, "statement %td\n", statement_number(s));
 
    current_stmt = s;
    return(true);
}

References current_stmt, pips_debug, and statement_number.

Referenced by out_regions_from_caller_to_callee().

Here is the caller graph for this function:

update_out_summary_regions_list()

void update_out_summary_regions_list

(

list

l_out

)

Parameters

l_out

_out

Definition at line 126 of file interprocedural.c.

{
    if (list_undefined_p(l_sum_out_reg))
        l_sum_out_reg = l_out;
    else
        l_sum_out_reg = RegionsMayUnion(l_sum_out_reg, l_out,
                                        effects_same_action_p);
}

References effects_same_action_p(), l_sum_out_reg, list_undefined_p, and RegionsMayUnion().

Referenced by out_regions_from_call_site_to_callee().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

current_callee

entity current_callee = entity_undefined

static

Definition at line 118 of file interprocedural.c.

Referenced by common_is_visible_p(), interprocedural_abc_arrays(), out_regions_from_call_site_to_callee(), and out_regions_from_caller_to_callee().

current_stmt

statement current_stmt = statement_undefined

static

Definition at line 117 of file interprocedural.c.

Referenced by live_in_paths_of_loop(), live_in_paths_of_whileloop(), live_out_paths_from_call_site_to_callee(), live_out_paths_from_forloop_to_body(), live_out_paths_from_loop_to_body(), live_out_paths_from_test_to_branches(), live_out_paths_from_unstructured_to_nodes(), live_out_paths_from_whileloop_to_body(), make_sensitivity_information(), out_regions_from_call_site_to_callee(), put_stmt_in_Block(), and stmt_filter().

l_sum_out_reg

list l_sum_out_reg = list_undefined

static

Definition at line 119 of file interprocedural.c.

Referenced by get_out_summary_regions_list(), out_regions_from_caller_to_callee(), reset_out_summary_regions_list(), and update_out_summary_regions_list().