type.c File Reference

#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "ri.h"
#include "effects.h"
#include "ri-util.h"
#include "prettyprint.h"
#include "effects-util.h"
#include "text-util.h"
#include "effects-simple.h"
#include "pips-libs.h"
#include "transformer.h"
#include "semantics.h"

Include dependency graph for type.c:

Go to the source code of this file.

Macros
#define	unsigned_char   11
#define	unsigned_short_int   12
#define	unsigned_int   14
#define	unsigned_long_int   16
#define	unsigned_long_long_int   18

Functions
static void	add_type_information (transformer tf)
	Add some of the constraints linked to the type of a variable. More...
void	transformer_add_type_information (transformer tf)
	type.c More...
void	transformer_add_variable_type_information (transformer tf, entity v)

Macro Definition Documentation

unsigned_char

#define unsigned_char   11

Definition at line 54 of file type.c.

unsigned_int

#define unsigned_int   14

Definition at line 56 of file type.c.

unsigned_long_int

#define unsigned_long_int   16

Definition at line 57 of file type.c.

unsigned_long_long_int

#define unsigned_long_long_int   18

Definition at line 58 of file type.c.

unsigned_short_int

#define unsigned_short_int   12

Definition at line 55 of file type.c.

Function Documentation

add_type_information()

static void add_type_information ( transformer  tf )

static

Add some of the constraints linked to the type of a variable.

lb = 0

We assume exists lambda s.t. e = ep + period*lambda

Compute the value of lambda

Now we must get rid of lambda and e and possibly e's old value

Transformer projection removes variables from the argument list as well as from the contraint system.

Now we must substitute ep by e

Definition at line 61 of file type.c.

{
  Psysteme ps = predicate_system(transformer_relation(tf));
  Pbase b = vect_copy(sc_base(ps)); // FI: the basis may evolve when
                                    // new constraints are added
  Pbase cb = BASE_NULLE;
 
  for(cb=b; !BASE_NULLE_P(cb); cb = vecteur_succ(cb)) {
    Variable v = vecteur_var(cb);
    //entity ev = (entity) v;
    if(v!=TCST && !local_old_value_entity_p(v)) { // FI: TCST check should be useless in a basis
      entity e = value_to_variable(v);
      type t = entity_basic_concrete_type(e);
      if(unsigned_type_p(t)) {
        basic tb = variable_basic(type_variable(t));
        int s = basic_int(tb);
        // FI: the lower bound, lb, could also be defined, e.g. for "char"
        long long int ub = -1/*, lb = 0*/;
        long long int period = 0;
        switch(s) {
        case unsigned_char:
          ub = 256-1, period = 256;
          break;
        case unsigned_short_int:
          ub = 256*256-1, period = 256*256;
          break;
        case unsigned_int:
          // We go straight to the overflows!
          // ub = 256L*256L*256L*256L-1;
          ub = 0, period = 256L*256L*256L*256L;
          break;
        case unsigned_long_int:
          // We go straight to the overflows!
          // ub = 256L*256L*256L*256L-1;
          ub = 0, period = 256L*256L*256L*256L;
          break;
        case unsigned_long_long_int:
          // We go straight to the overflows!
          //ub = 256*256*256*256*256*256*256*256-1;
          //ub = 0; // FI: too dangerous
          break;
        default:
          ub=-1; // do nothing
          break;
        }
        if(ub>=0) { 
          /* We assume exists lambda s.t. e = ep + period*lambda */
          entity ep = make_local_temporary_value_entity(t);
          entity lambda = make_local_temporary_integer_value_entity();
          tf = transformer_add_inequality_with_integer_constraint(tf, ep, 0, false);
          if(ub>0) {
            // Without this dangerous upperbound, we lose information
            // but avoid giving wrong results.
            // FI: The upperbound is dangerous because linear does not
            // expect such large constants, especially my bounded normalization
            // that should be itself bounded! See
            // check_coefficient_reduction() and the stack allocation
            // of arrays a, b and c!
            tf = transformer_add_inequality_with_integer_constraint(tf, ep, ub, true);
          }
          Pvecteur eq =
            vect_make(vect_new(e, VALUE_MONE),
                      ep, VALUE_ONE,
                      lambda, (Value) period, TCST, VALUE_ZERO, NULL);
          tf = transformer_equality_add(tf, eq);
          /* Compute the value of lambda */
          Value pmin, pmax;
          if(precondition_minmax_of_value(lambda, tf, (intptr_t*) &pmin, (intptr_t*) &pmax)) {
            if(pmin==pmax) 
              tf = transformer_add_equality_with_integer_constant(tf, lambda, pmin);
          }
          /* Now we must get rid of lambda and e and possibly e's old value */
          list p =
            CONS(ENTITY, e, CONS(ENTITY, lambda, NIL));
          pips_assert("ep is in tf basis",
                      base_contains_variable_p(sc_base(ps), ep));
          pips_assert("lambda is in tf basis",
                      base_contains_variable_p(sc_base(ps), lambda));
          if(entity_is_argument_p(e, transformer_arguments(tf))) {
            entity old_e = entity_to_old_value(e);
            p = CONS(ENTITY, old_e, p);
            pips_assert("old_e is in tf basis",
                        base_contains_variable_p(sc_base(ps), ep));
          }
          /* Transformer projection removes variables from the
             argument list as well as from the contraint system. */
          list args = gen_copy_seq(transformer_arguments(tf));
          tf = safe_transformer_projection(tf, p);
          gen_free_list(transformer_arguments(tf));
          transformer_arguments(tf) = args;
          gen_free_list(p);
          /* Now we must substitute ep by e */
          tf = transformer_value_substitute(tf, ep, e);
        }
      }
    }
  }
  vect_rm(b);
  return;
}

References base_contains_variable_p(), BASE_NULLE, BASE_NULLE_P, basic_int, CONS, ENTITY, entity_basic_concrete_type(), entity_is_argument_p(), entity_to_old_value(), eq, gen_copy_seq(), gen_free_list(), intptr_t, local_old_value_entity_p(), make_local_temporary_integer_value_entity(), make_local_temporary_value_entity(), NIL, pips_assert, precondition_minmax_of_value(), predicate_system, safe_transformer_projection(), TCST, transformer_add_equality_with_integer_constant(), transformer_add_inequality_with_integer_constraint(), transformer_arguments, transformer_equality_add(), transformer_relation, transformer_value_substitute(), type_variable, unsigned_char, unsigned_int, unsigned_long_int, unsigned_long_long_int, unsigned_short_int, unsigned_type_p(), VALUE_MONE, VALUE_ONE, value_to_variable(), VALUE_ZERO, variable_basic, vect_copy(), vect_make(), vect_new(), vect_rm(), vecteur_succ, and vecteur_var.

Referenced by transformer_add_type_information().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_type_information()

void transformer_add_type_information

(

transformer

tf

)

type.c

Parameters

tf

f

Definition at line 162 of file type.c.

{
  add_type_information(tf);
  return;
}

References add_type_information().

Referenced by module_name_to_preconditions(), precondition_add_type_information(), statement_to_postcondition(), statement_to_transformer(), and transformer_add_variable_type_information().

Here is the call graph for this function:

Here is the caller graph for this function:

transformer_add_variable_type_information()

void transformer_add_variable_type_information	(	transformer	tf,
		entity	v
	)

Parameters

tf

f

Definition at line 168 of file type.c.

{
  pips_assert("entity has values", entity_has_values_p(v));
  entity vv = entity_to_new_value(v);
  if(!value_belongs_to_transformer_space(vv, tf))
    add_value_to_transformer_space(vv, tf);
  transformer_add_type_information(tf);
  return;
}

References add_value_to_transformer_space(), entity_has_values_p(), entity_to_new_value(), pips_assert, transformer_add_type_information(), and value_belongs_to_transformer_space().

Referenced by declaration_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function: