eval.c File Reference

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "linear.h"
#include "genC.h"
#include "ri.h"
#include "misc.h"
#include "ri-util.h"
#include "properties.h"
#include "operator.h"

Include dependency graph for eval.c:

Go to the source code of this file.

Functions
value	EvalExpression (expression e)
	Evaluate statically an expression. More...
value	EvalSyntax (syntax s)
value	EvalCall (call c)
	only calls to constant, symbolic or intrinsic functions might be evaluated. More...
value	EvalSizeofexpression (sizeofexpression soe)
value	EvalConstant (constant c)
	Constant c is returned as field of value v. More...
value	EvalIntrinsic (entity e, list la)
	This function tries to evaluate a call to an intrinsic function. More...
value	EvalConditionalOp (list la)
value	EvalUnaryOp (int t, list la)
value	EvalBinaryOp (int t, list la)
	t defines the operator and la is a list to two sub-expressions. More...
value	EvalNaryOp (int t, list la)
int	IsUnaryOperator (entity e)
int	IsBinaryOperator (entity e)
	FI: These string constants are defined in ri-util.h and the tokens in ri-util/operator.h. More...
int	IsNaryOperator (entity e)
int	ipow (int vg, int vd)
	FI: such a function should exist in Linear/arithmetique. More...
bool	expression_integer_value (expression e, intptr_t *pval)
bool	expression_negative_integer_value_p (expression e)
	Return true iff the expression has an integer value known statically and this value is negative. More...
bool	positive_expression_p (expression e)
	Use constants and type information to decide if the value of sigma(e) is always positive, e.g. More...
bool	negative_expression_p (expression e)
	Use constants and type information to decide if the value of sigma(e) is always negative, e.g. More...
bool	expression_linear_p (expression e)
	returns if e is already normalized and linear. More...
expression	range_to_expression (range r, enum range_to_expression_mode mode)
	computes the distance between the lower bound and the upper bound of the range More...
bool	range_count (range r, intptr_t *pcount)
	The range count only can be evaluated if the three range expressions are constant and if the increment is non zero. More...
static bool	vect_const_p (Pvecteur v)
	returns true if v is not NULL and is constant More...
Pvecteur	vect_product (Pvecteur *pv1, Pvecteur *pv2)
	returns a Pvecteur equal to (*pv1) * (*pv2) if this product is linear or NULL otherwise. More...
reference	constant_reference_to_normalized_constant_reference (reference cr)
	Allocate a new reference with evaluated subscripts. More...
expression	normalize_integer_constant_expression (expression e)
	Allocate a new expression equivalent to e, but constant expressions are evaluated. More...

Function Documentation

constant_reference_to_normalized_constant_reference()

reference constant_reference_to_normalized_constant_reference

(

reference

cr

)

Allocate a new reference with evaluated subscripts.

For instance, return a[2] for a[10/2-3]

This function deals with all kinds of references, including the points-to references which use fields as subscripts.

There is an ambiguity for a[*] where * may be considered a constant in some passes of PIPS. However, it denotes a constant set of references and not a constant reference. The returned reference is undefined.

Parameters

cr

r

Definition at line 1068 of file eval.c.

{
  reference ncr = reference_undefined;
  list sl = reference_indices(cr);
  list nsl = NIL;
  bool constant_p = true;
  FOREACH(EXPRESSION, s, sl) {
    expression ns = expression_undefined;
    if(unbounded_expression_p(s)) {
      constant_p = false;
      break;
    }
    else if(expression_reference_p(s)) {
      // it must be a field
      ns = copy_expression(s);
    }
    else {
      intptr_t i;
      if(expression_integer_value(s, &i)) {
        ns = int_to_expression((int) i);
      }
      else
        pips_internal_error("Unexpected case\n.");
    }
    nsl = CONS(EXPRESSION, ns, nsl);
  }
  if(constant_p) {
    entity v = reference_variable(cr);
    ncr = make_reference(v, NIL);
    nsl = gen_nreverse(nsl);
    reference_indices(ncr) = nsl;
  }
  else {
    gen_full_free_list(nsl);
  }
  return ncr;
}

References CONS, constant_p(), copy_expression(), EXPRESSION, expression_integer_value(), expression_reference_p(), expression_undefined, FOREACH, gen_full_free_list(), gen_nreverse(), int_to_expression(), intptr_t, make_reference(), NIL, pips_internal_error, reference_indices, reference_undefined, reference_variable, and unbounded_expression_p().

Referenced by constant_memory_access_path_to_location_entity(), and make_location_entity().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalBinaryOp()

value EvalBinaryOp	(	int	t,
		list	la
	)

t defines the operator and la is a list to two sub-expressions.

Integer and floatint point constants are evaluated.

FI: lazy...

OK for Fortran Logical? Int value or logical value?

Parameters

la

a

Definition at line 385 of file eval.c.

{
  value v;
  long long int i_arg_l = 0, i_arg_r = 0;
  double f_arg_l, f_arg_r;
  bool int_p = true;
 
  pips_assert("non empty list", la != NIL);
 
  v = EvalExpression(EXPRESSION(CAR(la)));
  if (value_constant_p(v) && constant_int_p(value_constant(v))) {
    i_arg_l = constant_int(value_constant(v));
    f_arg_l = i_arg_l;
    free_value(v);
  }
  else if (value_constant_p(v) && constant_float_p(value_constant(v))) {
    int_p = false;
    f_arg_l = constant_float(value_constant(v));
  }
  else
    return v;
 
  la = CDR(la);
 
  pips_assert("non empty list", la != NIL);
  v = EvalExpression(EXPRESSION(CAR(la)));
 
  if (value_constant_p(v) && constant_int_p(value_constant(v))) {
    i_arg_r = constant_int(value_constant(v));
    f_arg_r = i_arg_r;
  }
  else if (value_constant_p(v) && constant_float_p(value_constant(v))) {
    f_arg_r = constant_float(value_constant(v));
    int_p = false;
  }
  else
    return v;
 
  switch (t) {
  case MINUS:
    if(int_p)
      constant_int(value_constant(v)) = i_arg_l-i_arg_r;
    else
      constant_float(value_constant(v)) = i_arg_l-i_arg_r;
    break;
  case PLUS:
    if(int_p)
      constant_int(value_constant(v)) = i_arg_l+i_arg_r;
    else
      constant_float(value_constant(v)) = f_arg_l+f_arg_r;
    break;
  case STAR:
    if(int_p)
      constant_int(value_constant(v)) = i_arg_l*i_arg_r;
    else
      constant_float(value_constant(v)) = f_arg_l*f_arg_r;
    break;
  case SLASH:
    if(int_p) {
      if (i_arg_r != 0)
        constant_int(value_constant(v)) = i_arg_l/i_arg_r;
      else {
        pips_user_error("[EvalBinaryOp] zero divide\n");
      }
    }
    else {
      if (f_arg_r != 0)
        constant_float(value_constant(v)) = f_arg_l/f_arg_r;
      else {
        pips_user_error("[EvalBinaryOp] zero divide\n");
      }
    }
    break;
  case MOD:
    if(int_p) {
      if (i_arg_r != 0)
        constant_int(value_constant(v)) = i_arg_l%i_arg_r;
      else {
        pips_user_error("[EvalBinaryOp] zero divide\n");
      }
    }
    else {
      if (f_arg_r != 0) {
        free_value(v);
        v = make_value(is_value_unknown, NIL);
      }
      else {
        pips_user_error("[EvalBinaryOp] zero divide\n");
      }
    }
    break;
  case POWER:
    if(int_p) {
      if (i_arg_r >= 0)
        constant_int(value_constant(v)) = ipow(i_arg_l,i_arg_r);
      else {
        free_value(v);
        v = make_value(is_value_unknown, NIL);
      }
    }
    else {
      /* FI: lazy... */
      free_value(v);
      v = make_value(is_value_unknown, NIL);
    }
    break;
    /*
     * Logical operators should return logical values...
     */
  case EQ:
    if(int_p)
      constant_int(value_constant(v)) = i_arg_l==i_arg_r;
    else
      constant_int(value_constant(v)) = f_arg_l==f_arg_r;
    break;
  case NE:
    if(int_p)
      constant_int(value_constant(v)) = i_arg_l!=i_arg_r;
    else
      constant_int(value_constant(v)) = f_arg_l!=f_arg_r;
    break;
  case EQV:
    if(int_p)
      constant_int(value_constant(v)) = i_arg_l==i_arg_r;
    else
      constant_int(value_constant(v)) = f_arg_l==f_arg_r;
    break;
  case NEQV:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l!=i_arg_r;
    else
       constant_int(value_constant(v)) = f_arg_l!=f_arg_r;
   break;
  case GT:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l>i_arg_r;
    else
       constant_int(value_constant(v)) = f_arg_l>f_arg_r;
   break;
  case LT:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l<i_arg_r;
    else
       constant_int(value_constant(v)) = f_arg_l<f_arg_r;
   break;
  case GE:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l>=i_arg_r;
    else
       constant_int(value_constant(v)) = f_arg_l>=f_arg_r;
   break;
   /* OK for Fortran Logical? Int value or logical value? */
  case OR:
    if(int_p)
       constant_int(value_constant(v)) = (i_arg_l!=0)||(i_arg_r!=0);
    else
       constant_int(value_constant(v)) = (f_arg_l!=0)||(f_arg_r!=0);
   break;
  case AND:
    if(int_p)
       constant_int(value_constant(v)) = (i_arg_l!=0)&&(i_arg_r!=0);
    else
       constant_int(value_constant(v)) = (f_arg_l!=0)&&(f_arg_r!=0);
   break;
  case BITWISE_OR:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l|i_arg_r;
    else
      pips_user_error("Bitwise or cannot have floating point arguments\n");
   break;
  case BITWISE_AND:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l&i_arg_r;
    else
      pips_user_error("Bitwise and cannot have floating point arguments\n");
   break;
  case BITWISE_XOR:
    if(int_p)
      constant_int(value_constant(v)) = i_arg_l^i_arg_r;
    else
      pips_user_error("Bitwise xor cannot have floating point arguments\n");
   break;
  case LEFT_SHIFT:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l<<i_arg_r;
    else {
      free_value(v);
      v = make_value(is_value_unknown, NIL);
    }
   break;
   case RIGHT_SHIFT:
    if(int_p)
       constant_int(value_constant(v)) = i_arg_l>>i_arg_r;
    else {
      free_value(v);
      v = make_value(is_value_unknown, NIL);
    }
   break;
 default:
    free_value(v);
    v = make_value(is_value_unknown, NIL);
  }
 
  return(v);
}

References AND, BITWISE_AND, BITWISE_OR, BITWISE_XOR, CAR, CDR, constant_float, constant_float_p, constant_int, constant_int_p, EQ, EQV, EvalExpression(), EXPRESSION, free_value(), GE, GT, ipow(), is_value_unknown, LEFT_SHIFT, LT, make_value(), MINUS, MOD, NE, NEQV, NIL, OR, pips_assert, pips_user_error, PLUS, POWER, RIGHT_SHIFT, SLASH, STAR, value_constant, and value_constant_p.

Referenced by EvalIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalCall()

value EvalCall

(

call

c

)

only calls to constant, symbolic or intrinsic functions might be evaluated.

recall that intrinsic functions are not known.

SG: it may be better not to evaluate symbolic and keep their symbolic name

it might be an intrinsic function

Definition at line 170 of file eval.c.

{
  value vout, vin;
  entity f;
 
  f = call_function(c);
  vin = entity_initial(f);
 
  if (value_undefined_p(vin))
    pips_internal_error("undefined value for %s", entity_name(f));
 
  switch (value_tag(vin)) {
  case is_value_intrinsic:
    vout = EvalIntrinsic(f, call_arguments(c));
    break;
  case is_value_constant:
    vout = EvalConstant((value_constant(vin)));
    break;
  case is_value_symbolic:
    /* SG: it may be better not to evaluate symbolic and keep their symbolic name */
    if(get_bool_property("EVAL_SYMBOLIC_CONSTANT"))
      vout = EvalConstant((symbolic_constant(value_symbolic(vin))));
    else
      vout = make_value_unknown();
    break;
  case is_value_unknown:
    /* it might be an intrinsic function */
    vout = EvalIntrinsic(f, call_arguments(c));
    break;
  case is_value_code:
    vout = make_value_unknown();
    break;
  default:
    pips_internal_error("Unexpected default case.");
    vout = value_undefined;
  }
 
  return vout;
}

References call_arguments, call_function, entity_initial, entity_name, EvalConstant(), EvalIntrinsic(), f(), get_bool_property(), is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, make_value_unknown(), pips_internal_error, symbolic_constant, value_constant, value_symbolic, value_tag, value_undefined, and value_undefined_p.

Referenced by EvalSyntax().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalConditionalOp()

value EvalConditionalOp

(

list

la

)

Parameters

la

a

Definition at line 309 of file eval.c.

{
  value vout, v1, v2, v3;
  _int arg1 = 0, arg2 = 0, arg3 = 0;
  bool failed = false;
 
  pips_assert("Three arguments", gen_length(la)==3);
 
  v1 = EvalExpression(EXPRESSION(CAR(la)));
  if (value_constant_p(v1) && constant_int_p(value_constant(v1)))
    arg1 = constant_int(value_constant(v1));
  else
    failed = true;
 
  v2 = EvalExpression(EXPRESSION(CAR(CDR(la))));
  if (value_constant_p(v2) && constant_int_p(value_constant(v2)))
    arg2 = constant_int(value_constant(v2));
  else
    failed = true;
 
  v3 = EvalExpression(EXPRESSION(CAR(CDR(CDR(la)))));
  if (value_constant_p(v3) && constant_int_p(value_constant(v3)))
    arg3 = constant_int(value_constant(v3));
  else
    failed = true;
 
  if(failed)
    vout = make_value(is_value_unknown, NIL);
  else
    vout = make_value(is_value_constant,
                      make_constant(is_constant_int, (void *) (arg1? arg2: arg3)));
 
  free_value(v1);
  free_value(v2);
  free_value(v3);
 
  return vout;
}

References CAR, CDR, constant_int, constant_int_p, EvalExpression(), EXPRESSION, free_value(), gen_length(), is_constant_int, is_value_constant, is_value_unknown, make_constant(), make_value(), NIL, pips_assert, value_constant, and value_constant_p.

Referenced by EvalIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalConstant()

value EvalConstant

(

constant

c

)

Constant c is returned as field of value v.

Definition at line 235 of file eval.c.

{
  value v = value_undefined;
 
  if(constant_int_p(c)) {
    v = make_value(is_value_constant,
                   make_constant(is_constant_int,
                                 (void*) constant_int(c)));
  }
  else if(constant_float_p(c)) {
    constant nc = make_constant(is_constant_float,
                                NULL);
    constant_float(nc) = constant_float(c);
    v = make_value(is_value_constant, nc);
  }
  else if(constant_call_p(c)) {
    entity e = constant_call(c);
    type t = entity_type(e);
    if(type_functional_p(t)) {
      functional f = type_functional(t);
      t = functional_result(f);
    }
    if(scalar_integer_type_p(t)) {
      long long int val;
      sscanf(entity_local_name(e), "%lld", &val);
      v = make_value(is_value_constant,
                     make_constant(is_constant_int,
                                   (void*) val));
    }
    else if(float_type_p(t)) {
      double val;
      sscanf(entity_local_name(e), "%lg", &val);
      constant nc = make_constant(is_constant_float,
                                 NULL);
      constant_float(nc) = val;
      v = make_value(is_value_constant, nc);
    }
    else
      v = make_value(is_value_constant,
                     make_constant(is_constant_litteral, NIL));
  }
  else
    v = make_value(is_value_constant,
                   make_constant(is_constant_litteral, NIL));
  return v;
}

References constant_call, constant_call_p, constant_float, constant_float_p, constant_int, constant_int_p, entity_local_name(), entity_type, f(), float_type_p(), functional_result, is_constant_float, is_constant_int, is_constant_litteral, is_value_constant, make_constant(), make_value(), NIL, scalar_integer_type_p(), type_functional, type_functional_p, and value_undefined.

Referenced by EvalCall().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalExpression()

value EvalExpression

(

expression

e

)

Evaluate statically an expression.

cproto-generated files

If the expression can be evaluated regardless of the store and regardless of the target machine, and if the expression type is integer or float, return a constant value. Else, return a value unknown.

To accept dependencies on target architecture, set the property "EVAL_SIZEOF" to true.

A new value is always allocated.

If you are not interested in the object value, but simply to the integer value of a constant expression, see expression_integer_value().

This function is not fully implemented. It does not take care of logical (apparently) and string expressions. Some intrinsic operators are not evaluated. Floating point expressions are not as well covered as integer expression.

It is not clear if the evaluation of floating point expressions should be considered target dependent (e.g. for GPU code) or if the IEEE floating point standard is considered strongly enforced.

If information about the store used to evaluate the expression, i.e. preconditions, use precondition_minmax_of_expression()

The algorithm is built on a recursive analysis of the expression structure. Lower level functions are called until basic atoms are reached. The success of basic atom evaluation depend on the atom type:

reference: right now, the evaluation fails because we do not compute predicates on variables, unless the variable type is qualified by const.

call: a call to a user function is not evaluated. a call to an intrinsic function is successfully evaluated if arguments can be evaluated. a call to a constant function is evaluated if its basic type is integer.

range: a range is not evaluated.

Definition at line 108 of file eval.c.

{
    return EvalSyntax(expression_syntax(e));
}

References EvalSyntax(), and expression_syntax.

Referenced by cell_is_xxx_p(), EvalBinaryOp(), EvalConditionalOp(), EvalNaryOp(), EvalSyntax(), EvalUnaryOp(), expression_integer_value(), ExpressionToInt(), extended_integer_constant_expression_p(), extended_integer_constant_expression_p_to_int(), InitializeEnumMemberValues(), MakeDataValueSet(), MakeValueSymbolic(), offset_array_reference(), offset_points_to_cell(), reference_to_points_to_translations(), reference_to_type(), simplified_reference(), subscript_expressions_to_constant_subscript_expressions(), xml_Argument(), xml_AssignArgument(), xml_expression(), and xml_Transposition().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalIntrinsic()

value EvalIntrinsic	(	entity	e,
		list	la
	)

This function tries to evaluate a call to an intrinsic function.

right now, we only try to evaluate unary and binary intrinsic functions, ie. Fortran operators.

e is the intrinsic function.

la is the list of arguments.

Parameters

la

a

Definition at line 290 of file eval.c.

{
  value v;
  int token;
 
  if ((token = IsUnaryOperator(e)) > 0)
    v = EvalUnaryOp(token, la);
  else if ((token = IsBinaryOperator(e)) > 0)
    v = EvalBinaryOp(token, la);
  else if ((token = IsNaryOperator(e)) > 0)
    v = EvalNaryOp(token, la);
  else if (ENTITY_CONDITIONAL_P(e))
    v = EvalConditionalOp(la);
  else
    v = make_value(is_value_unknown, NIL);
 
  return(v);
}

References ENTITY_CONDITIONAL_P, EvalBinaryOp(), EvalConditionalOp(), EvalNaryOp(), EvalUnaryOp(), is_value_unknown, IsBinaryOperator(), IsNaryOperator(), IsUnaryOperator(), make_value(), and NIL.

Referenced by EvalCall().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalNaryOp()

value EvalNaryOp	(	int	t,
		list	la
	)

2 operands at least are needed

Parameters

la

a

Definition at line 591 of file eval.c.

{
    value v = value_undefined;
    value w = value_undefined;
    int new_arg = 0;
    bool first_arg_p = true;
 
    /* 2 operands at least are needed */
    assert(la != NIL && CDR(la) != NIL);
 
    MAP(EXPRESSION, e, {
        v = EvalExpression(e);
        if (value_constant_p(v) && constant_int_p(value_constant(v))) {
            new_arg = constant_int(value_constant(v));
            if (first_arg_p) {
                first_arg_p = false;
                w = v;
            }
            else {
                switch(t) {
                case MAXIMUM:
                    constant_int(value_constant(w))= MAX(constant_int(value_constant(w)),
                                                         new_arg);
                    break;
                case MINIMUM:
                    constant_int(value_constant(w))= MIN(constant_int(value_constant(w)),
                                                         new_arg);
                    break;
                default:
                    return v;
                }
                free_value(v);
            }
        }
        else
            return(v);
    }, la);
 
    return(w);
}

References assert, CDR, constant_int, constant_int_p, EvalExpression(), EXPRESSION, free_value(), MAP, MAX, MAXIMUM, MIN, MINIMUM, NIL, value_constant, value_constant_p, and value_undefined.

Referenced by EvalIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalSizeofexpression()

value EvalSizeofexpression

(

sizeofexpression

soe

)

Parameters

soe

oe

Definition at line 210 of file eval.c.

{
  type t = type_undefined;
  value v = value_undefined;
  _int i;
 
  if(sizeofexpression_expression_p(soe)) {
    expression e = sizeofexpression_expression(soe);
 
    t = expression_to_type(e);
  }
  else {
    t = sizeofexpression_type(soe);
  }
 
  i = type_memory_size(t);
  v = make_value_constant(make_constant_int(i));
 
  if(sizeofexpression_expression_p(soe))
    free_type(t);
 
  return v;
}

References expression_to_type(), free_type(), make_constant_int(), make_value_constant(), sizeofexpression_expression, sizeofexpression_expression_p, sizeofexpression_type, type_memory_size(), type_undefined, and value_undefined.

Referenced by EvalSyntax(), expression_constant(), expression_to_int(), and integer_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalSyntax()

value EvalSyntax

(

syntax

s

)

Is it a reference to a const variable?

SG: sizeof is architecture dependant, it is better not to evaluate it by default

Definition at line 113 of file eval.c.

{
  value v = value_undefined;
 
  switch (syntax_tag(s)) {
  case is_syntax_reference: {
    /* Is it a reference to a const variable? */
    reference r = syntax_reference(s);
    entity var = reference_variable(r);
    if(const_variable_p(var)) {
      value i = entity_initial(var);
      if(value_constant_p(i))
        v = copy_value(entity_initial(var));
      else if(value_expression_p(i)) {
        expression ie = value_expression(i);
        v = EvalExpression(ie);
      }
      else
        v = make_value_unknown();
    }
    else
      v = make_value_unknown();
    break;
  }
  case is_syntax_range:
    v = make_value_unknown();
    break;
  case is_syntax_call:
    v = EvalCall((syntax_call(s)));
    break;
  case is_syntax_cast:
    v = make_value_unknown();
    break;
  case is_syntax_sizeofexpression:
    /* SG: sizeof is architecture dependant, it is better not to
       evaluate it by default */
    if(get_bool_property("EVAL_SIZEOF"))
        v = EvalSizeofexpression((syntax_sizeofexpression(s)));
    else
        v = make_value_unknown();
    break;
  case is_syntax_subscript:
  case is_syntax_application:
  case is_syntax_va_arg:
    v = make_value_unknown();
    break;
  default:
    pips_internal_error("Unexpected syntax tag %d\n", syntax_tag(s));
    abort();
  }
 
  return v;
}

References abort, const_variable_p(), copy_value(), entity_initial, EvalCall(), EvalExpression(), EvalSizeofexpression(), get_bool_property(), 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_value_unknown(), pips_internal_error, reference_variable, syntax_call, syntax_reference, syntax_sizeofexpression, syntax_tag, value_constant_p, value_expression, value_expression_p, and value_undefined.

Referenced by EvalExpression().

Here is the call graph for this function:

Here is the caller graph for this function:

EvalUnaryOp()

value EvalUnaryOp	(	int	t,
		list	la
	)

Parameters

la

a

Definition at line 349 of file eval.c.

{
  value vout, v;
  int arg;
 
  assert(la != NIL);
  v = EvalExpression(EXPRESSION(CAR(la)));
  if (value_constant_p(v) && constant_int_p(value_constant(v)))
    arg = constant_int(value_constant(v));
  else
    return(v);
 
  if (t == MINUS) {
    constant_int(value_constant(v)) = -arg;
    vout = v;
  }
  else if (t == PLUS) {
    constant_int(value_constant(v)) = arg;
    vout = v;
  }
  else if (t == NOT) {
    constant_int(value_constant(v)) = arg!=0;
    vout = v;
  }
  else {
    free_value(v);
    vout = make_value(is_value_unknown, NIL);
  }
 
  return(vout);
}

References assert, CAR, constant_int, constant_int_p, EvalExpression(), EXPRESSION, free_value(), is_value_unknown, make_value(), MINUS, NIL, NOT, PLUS, value_constant, and value_constant_p.

Referenced by EvalIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_integer_value()

bool expression_integer_value	(	expression	e,
		intptr_t *	pval
	)

Parameters

pval

val

Definition at line 792 of file eval.c.

{
    bool is_int = false;
    value v = EvalExpression(e);
 
    if (value_constant_p(v) && constant_int_p(value_constant(v))) {
        *pval = constant_int(value_constant(v));
        is_int = true;
    }
 
    free_value(v);
    return is_int;
}

References constant_int, constant_int_p, EvalExpression(), free_value(), is_int, value_constant, and value_constant_p.

Referenced by array_references_may_conflict_p(), c_dim_string(), c_reference(), cell_reference_compare(), comparable_statements_on_distance_p(), compare_statements_on_distance_to_origin(), conflict_is_a_real_conflict_p(), consecutive_expression_p(), constant_image_p(), constant_reference_to_normalized_constant_reference(), convert_bound_expression(), copy_image_p(), dag_normalize(), declarations_to_dimensions(), dimension_size(), do_group_statement_constant(), do_isolate_statement_preconditions_satisified_p(), do_loop_unroll(), do_loop_unroll_with_prologue(), do_simdizer_init(), do_solve_hardware_constraints_on_volume(), expression_negative_integer_value_p(), fcs_call_flt(), freia_convolution_width_height(), freia_extract_kernel(), full_loop_unroll(), HpfcExpressionToInt(), loop_fully_unrollable_p(), loop_nest_to_offset(), make_condition_from_loop(), make_op_exp(), make_send_receive_conversion(), make_transStat(), MakeCaseStatement(), MakeDimension(), negative_expression_p(), normalize_integer_constant_expression(), NumberOfElements(), old_effects_conflict_p(), points_to_cell_update_last_subscript(), positive_expression_p(), range_count(), region_to_minimal_dimensions(), simd_loop_unroll(), size_of_dimension(), SizeOfIthDimension(), st_dimension_bound_as_string(), st_dimension_reference_as_string(), st_loop(), subscripted_field_list_to_type(), symbolic_tiling_valid_p(), terapix_loop_optimizer(), terapixify_loops(), update_range(), ValueSizeOfDimension(), variable_references_may_conflict_p(), variable_to_string(), words_dimension(), xml_Argument(), xml_AssignArgument(), xml_Bounds(), xml_Bounds_and_Stride(), xml_declarations(), and xml_dim_string().

Here is the call graph for this function:

expression_linear_p()

bool expression_linear_p

(

expression

e

)

returns if e is already normalized and linear.

FI: should be moved into expression.c. Treacherous because the normalization is assumed to have occured earlier.

Definition at line 951 of file eval.c.

{
    normalized n = expression_normalized(e);
    return !normalized_undefined_p(n) && normalized_linear_p(n);
}

References expression_normalized, normalized_linear_p, and normalized_undefined_p.

Referenced by convert_bound_expression(), expression_flt(), reference_filter(), and substitute_and_create().

Here is the caller graph for this function:

expression_negative_integer_value_p()

bool expression_negative_integer_value_p

(

expression

e

)

Return true iff the expression has an integer value known statically and this value is negative.

All leaves of the expression tree must be constant integer.

If preconditions are available, a more general expression can be evaluated using precondition_minmax_of_expression().

Definition at line 814 of file eval.c.

                                                       {
  intptr_t v;
  return expression_integer_value(e, &v) && (v < 0);
}

References expression_integer_value(), and intptr_t.

Here is the call graph for this function:

ipow()

int ipow	(	int	vg,
		int	vd
	)

FI: such a function should exist in Linear/arithmetique.

FI: should it return a long long int?

Parameters

vg	g
vd	d

Definition at line 769 of file eval.c.

{
        int i = 1;
 
        assert(vd >= 0);
 
        while (vd-- > 0)
                i *= vg;
 
        return(i);
}

References assert.

Referenced by binary_to_normalized(), EvalBinaryOp(), and partial_eval_power_operator().

Here is the caller graph for this function:

IsBinaryOperator()

int IsBinaryOperator

(

entity

e

)

FI: These string constants are defined in ri-util.h and the tokens in ri-util/operator.h.

Definition at line 660 of file eval.c.

{
  int token;
  const char* n = entity_local_name(e);
 
  if      (same_string_p(n, MINUS_OPERATOR_NAME)
           || same_string_p(n, MINUS_C_OPERATOR_NAME))
    token = MINUS;
  else if (same_string_p(n, PLUS_OPERATOR_NAME)
           || same_string_p(n, PLUS_C_OPERATOR_NAME))
    token = PLUS;
  else if (same_string_p(n, MULTIPLY_OPERATOR_NAME))
    token = STAR;
  else if (same_string_p(n, DIVIDE_OPERATOR_NAME))
    token = SLASH;
  else if (same_string_p(n, POWER_OPERATOR_NAME))
    token = POWER;
  else if (same_string_p(n, MODULO_OPERATOR_NAME)
           || same_string_p(n, C_MODULO_OPERATOR_NAME))
    token = MOD;
  else if (same_string_p(n, EQUAL_OPERATOR_NAME)
           || same_string_p(n, C_EQUAL_OPERATOR_NAME))
    token = EQ;
  else if (same_string_p(n, NON_EQUAL_OPERATOR_NAME)
           || same_string_p(n, C_NON_EQUAL_OPERATOR_NAME))
    token = NE;
  else if (same_string_p(n, MODULO_OPERATOR_NAME)
           || same_string_p(n, C_MODULO_OPERATOR_NAME))
    token = EQV;
  else if (same_string_p(n, EQUIV_OPERATOR_NAME))
    token = NEQV;
  else if (same_string_p(n, GREATER_THAN_OPERATOR_NAME)
           || same_string_p(n, C_MODULO_OPERATOR_NAME))
    token = GT;
  else if (same_string_p(n, LESS_THAN_OPERATOR_NAME)
           || same_string_p(n, C_LESS_THAN_OPERATOR_NAME))
    token = LT;
  else if (same_string_p(n, GREATER_OR_EQUAL_OPERATOR_NAME)
           || same_string_p(n, C_GREATER_OR_EQUAL_OPERATOR_NAME))
    token = GE;
  else if (same_string_p(n, LESS_OR_EQUAL_OPERATOR_NAME)
           || same_string_p(n, C_LESS_OR_EQUAL_OPERATOR_NAME))
    token = LE;
  else if (same_string_p(n, OR_OPERATOR_NAME)
           || same_string_p(n, C_OR_OPERATOR_NAME))
    token = OR;
  else if (same_string_p(n, AND_OPERATOR_NAME)
           || same_string_p(n, C_AND_OPERATOR_NAME))
    token = AND;
  else if (same_string_p(n, BITWISE_AND_OPERATOR_NAME))
    token = BITWISE_AND;
  else if (same_string_p(n, BITWISE_OR_OPERATOR_NAME))
    token = BITWISE_OR;
  else if (same_string_p(n, BITWISE_XOR_OPERATOR_NAME))
    token = BITWISE_XOR;
  else if (same_string_p(n, LEFT_SHIFT_OPERATOR_NAME))
    token = LEFT_SHIFT;
  else if (same_string_p(n, RIGHT_SHIFT_OPERATOR_NAME))
    token = RIGHT_SHIFT;
 
  else if (same_string_p(n, ASSIGN_OPERATOR_NAME)) // C operators
    token = ASSIGN;
  else if (same_string_p(n, MULTIPLY_UPDATE_OPERATOR_NAME))
    token = MULTIPLY_UPDATE;
  else if (same_string_p(n, DIVIDE_UPDATE_OPERATOR_NAME))
    token = DIVIDE_UPDATE;
  else if (same_string_p(n, PLUS_UPDATE_OPERATOR_NAME))
    token = PLUS_UPDATE;
  else if (same_string_p(n, MINUS_UPDATE_OPERATOR_NAME))
    token = MINUS_UPDATE;
  else if (same_string_p(n, LEFT_SHIFT_UPDATE_OPERATOR_NAME))
    token = LEFT_SHIFT_UPDATE;
  else if (same_string_p(n, RIGHT_SHIFT_UPDATE_OPERATOR_NAME))
    token = RIGHT_SHIFT_UPDATE;
  else if (same_string_p(n, BITWISE_OR_UPDATE_OPERATOR_NAME))
    token = BITWISE_OR_UPDATE;
 
  else if (same_string_p(entity_local_name(e), IMPLIED_COMPLEX_NAME) ||
           same_string_p(entity_local_name(e), IMPLIED_DCOMPLEX_NAME))
    token = CAST_OP;
  else
    token = -1;
 
  return(token);
}

References AND, AND_OPERATOR_NAME, ASSIGN, ASSIGN_OPERATOR_NAME, BITWISE_AND, BITWISE_AND_OPERATOR_NAME, BITWISE_OR, BITWISE_OR_OPERATOR_NAME, BITWISE_OR_UPDATE, BITWISE_OR_UPDATE_OPERATOR_NAME, BITWISE_XOR, BITWISE_XOR_OPERATOR_NAME, C_AND_OPERATOR_NAME, C_EQUAL_OPERATOR_NAME, C_GREATER_OR_EQUAL_OPERATOR_NAME, C_LESS_OR_EQUAL_OPERATOR_NAME, C_LESS_THAN_OPERATOR_NAME, C_MODULO_OPERATOR_NAME, C_NON_EQUAL_OPERATOR_NAME, C_OR_OPERATOR_NAME, CAST_OP, DIVIDE_OPERATOR_NAME, DIVIDE_UPDATE, DIVIDE_UPDATE_OPERATOR_NAME, entity_local_name(), EQ, EQUAL_OPERATOR_NAME, EQUIV_OPERATOR_NAME, EQV, GE, GREATER_OR_EQUAL_OPERATOR_NAME, GREATER_THAN_OPERATOR_NAME, GT, IMPLIED_COMPLEX_NAME, IMPLIED_DCOMPLEX_NAME, LE, LEFT_SHIFT, LEFT_SHIFT_OPERATOR_NAME, LEFT_SHIFT_UPDATE, LEFT_SHIFT_UPDATE_OPERATOR_NAME, LESS_OR_EQUAL_OPERATOR_NAME, LESS_THAN_OPERATOR_NAME, LT, MINUS, MINUS_C_OPERATOR_NAME, MINUS_OPERATOR_NAME, MINUS_UPDATE, MINUS_UPDATE_OPERATOR_NAME, MOD, MODULO_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, MULTIPLY_UPDATE, MULTIPLY_UPDATE_OPERATOR_NAME, NE, NEQV, NON_EQUAL_OPERATOR_NAME, OR, OR_OPERATOR_NAME, PLUS, PLUS_C_OPERATOR_NAME, PLUS_OPERATOR_NAME, PLUS_UPDATE, PLUS_UPDATE_OPERATOR_NAME, POWER, POWER_OPERATOR_NAME, RIGHT_SHIFT, RIGHT_SHIFT_OPERATOR_NAME, RIGHT_SHIFT_UPDATE, RIGHT_SHIFT_UPDATE_OPERATOR_NAME, same_string_p, SLASH, and STAR.

Referenced by EvalIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

IsNaryOperator()

int IsNaryOperator

(

entity

e

)

Definition at line 746 of file eval.c.

{
        int token;
 
        if (strcmp(entity_local_name(e), MIN0_OPERATOR_NAME) == 0)
                token = MINIMUM;
        else if (strcmp(entity_local_name(e), MAX0_OPERATOR_NAME) == 0)
                token = MAXIMUM;
        else if (strcmp(entity_local_name(e), MIN_OPERATOR_NAME) == 0)
                token = MINIMUM;
        else if (strcmp(entity_local_name(e), MAX_OPERATOR_NAME) == 0)
                token = MAXIMUM;
        else
                token = -1;
 
        return token;
}

References entity_local_name(), MAX0_OPERATOR_NAME, MAX_OPERATOR_NAME, MAXIMUM, MIN0_OPERATOR_NAME, MIN_OPERATOR_NAME, and MINIMUM.

Referenced by EvalIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

IsUnaryOperator()

int IsUnaryOperator

(

entity

e

)

Definition at line 632 of file eval.c.

{
  int token;
  const char* n = entity_local_name(e);
 
  if (same_string_p(n, UNARY_MINUS_OPERATOR_NAME))
    token = MINUS;
  else if (same_string_p(n, UNARY_PLUS_OPERATOR_NAME))
    token = PLUS;
  else if (same_string_p(n, NOT_OPERATOR_NAME)
           || same_string_p(n, C_NOT_OPERATOR_NAME))
    token = NOT;
  else if (same_string_p(n, POST_INCREMENT_OPERATOR_NAME))
    token = POST_INCREMENT;
  else if (same_string_p(n, POST_DECREMENT_OPERATOR_NAME))
    token = POST_DECREMENT;
  else if (same_string_p(n, PRE_INCREMENT_OPERATOR_NAME))
    token = PRE_INCREMENT;
  else if (same_string_p(n, PRE_DECREMENT_OPERATOR_NAME))
    token = PRE_DECREMENT;
  else
    token = -1;
 
  return(token);
}

References C_NOT_OPERATOR_NAME, entity_local_name(), MINUS, NOT, NOT_OPERATOR_NAME, PLUS, POST_DECREMENT, POST_DECREMENT_OPERATOR_NAME, POST_INCREMENT, POST_INCREMENT_OPERATOR_NAME, PRE_DECREMENT, PRE_DECREMENT_OPERATOR_NAME, PRE_INCREMENT, PRE_INCREMENT_OPERATOR_NAME, same_string_p, UNARY_MINUS_OPERATOR_NAME, and UNARY_PLUS_OPERATOR_NAME.

Referenced by EvalIntrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

negative_expression_p()

bool negative_expression_p

(

expression

e

)

Use constants and type information to decide if the value of sigma(e) is always negative, e.g.

<=0. If this can be proven, true is returned.

false is returned when no decision can be made, i.e. negative_expression_p(e)==false does not imply positive_expression_p(e)

Similar and linked to previous function

We assume an operator is used

We can check a few cases recursively...

Definition at line 896 of file eval.c.

{
  bool negative_p = false; // In general, false because no conclusion can be reached
  intptr_t v;
  if(expression_integer_value(e, &v)) {
    negative_p = v<=0;
  }
  else {
    syntax s = expression_syntax(e);
 
    if(syntax_call_p(s)) {
      call c = syntax_call(s);
      entity f = call_function(c);
      type t = entity_type(f);
      pips_assert("t is a functional type", type_functional_p(t));
      type rt = functional_result(type_functional(t));
      if(overloaded_type_p(rt)) { /* We assume an operator is used */
        /* We can check a few cases recursively... */
        list args = call_arguments(c);
        intptr_t l = gen_length(args);
        if(l==1) {
          expression arg = EXPRESSION(CAR(args));
          if(ENTITY_UNARY_MINUS_P(f)) {
            negative_p = positive_expression_p(arg); // Maybe zero, but no chance for sigma(x)>0
          }
        }
        else if(l==2) {
          expression arg1 = EXPRESSION(CAR(args));
          expression arg2 = EXPRESSION(CAR(CDR(args)));
          if(ENTITY_MINUS_P(f)) {
            negative_p = negative_expression_p(arg1) && positive_expression_p(arg2);
          }
          else if(ENTITY_PLUS_P(f)) {
            negative_p = negative_expression_p(arg1) && negative_expression_p(arg2);
          }
          else if(ENTITY_MULTIPLY_P(f)) {
            negative_p = (negative_expression_p(arg1) && positive_expression_p(arg2))
              || (positive_expression_p(arg1) && negative_expression_p(arg2));
          }
          else if(ENTITY_DIVIDE_P(f)) {
            negative_p = (negative_expression_p(arg1) && positive_expression_p(arg2))
              || (positive_expression_p(arg1) && negative_expression_p(arg2));
          }
        }
      }
    }
  }
  return negative_p;
}

References call_arguments, call_function, CAR, CDR, ENTITY_DIVIDE_P, ENTITY_MINUS_P, ENTITY_MULTIPLY_P, ENTITY_PLUS_P, entity_type, ENTITY_UNARY_MINUS_P, EXPRESSION, expression_integer_value(), expression_syntax, f(), functional_result, gen_length(), intptr_t, overloaded_type_p(), pips_assert, positive_expression_p(), syntax_call, syntax_call_p, type_functional, and type_functional_p.

Referenced by add_index_range_conditions(), C_loop_range(), incrementation_expression_to_increment(), and positive_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_integer_constant_expression()

expression normalize_integer_constant_expression

(

expression

e

)

Allocate a new expression equivalent to e, but constant expressions are evaluated.

This function is used to normalize array dimensions to obtain type equality for a[2] and a[4/2].

Definition at line 1112 of file eval.c.

{
  expression ne = expression_undefined;
  intptr_t i;
  if(expression_integer_value(e, &i)) {
    ne = int_to_expression((int) i);
  }
  else
    ne = copy_expression(e);
  return ne;
}

References copy_expression(), expression_integer_value(), expression_undefined, int_to_expression(), and intptr_t.

Referenced by dimensions_to_normalized_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

positive_expression_p()

bool positive_expression_p

(

expression

e

)

Use constants and type information to decide if the value of sigma(e) is always positive, e.g.

>=0

See negative_expression_p()

Should we define positive_integer_expression_p() and check the expression type?

We assume an operator is used

We can check a few cases recursively...

Definition at line 826 of file eval.c.

{
  bool positive_p = false; // In general, false because no conclusion can be reached
  intptr_t v;
  if(expression_integer_value(e, &v)) {
    positive_p = v>=0;
  }
  else {
    syntax s = expression_syntax(e);
 
    if(syntax_reference_p(s)) {
      entity v = reference_variable(syntax_reference(s));
      type t = ultimate_type(entity_type(v));
      positive_p = unsigned_type_p(t);
    }
    else if(syntax_call_p(s)) {
      call c = syntax_call(s);
      entity f = call_function(c);
      type t = entity_type(f);
      pips_assert("t is a functional type", type_functional_p(t));
      type rt = functional_result(type_functional(t));
      if(unsigned_type_p(rt))
        positive_p = true;
      else if(overloaded_type_p(rt)) { /* We assume an operator is used */
        /* We can check a few cases recursively... */
        list args = call_arguments(c);
        intptr_t l = gen_length(args);
        if(l==1) {
          expression arg = EXPRESSION(CAR(args));
          if(ENTITY_UNARY_MINUS_P(f)) {
            positive_p = negative_expression_p(arg); // Maybe zero, but no chance for sigma(x)>0
          }
          else if(ENTITY_IABS_P(f) || ENTITY_ABS_P(f) || ENTITY_DABS_P(f)
                  || ENTITY_CABS_P(f)) {
            positive_p = true;
          }
        }
        else if(l==2) {
          expression arg1 = EXPRESSION(CAR(args));
          expression arg2 = EXPRESSION(CAR(CDR(args)));
          if(ENTITY_MINUS_P(f)) {
            positive_p = positive_expression_p(arg1) && negative_expression_p(arg2);
          }
          else if(ENTITY_PLUS_P(f)) {
            positive_p = positive_expression_p(arg1) && positive_expression_p(arg2);
          }
          else if(ENTITY_MULTIPLY_P(f)) {
            positive_p = (positive_expression_p(arg1) && positive_expression_p(arg2))
              || (negative_expression_p(arg1) && negative_expression_p(arg2));
          }
          else if(ENTITY_DIVIDE_P(f)) {
            positive_p = (positive_expression_p(arg1) && positive_expression_p(arg2))
              || (negative_expression_p(arg1) && negative_expression_p(arg2));
          }
        }
      }
    }
  }
  return positive_p;
}

References call_arguments, call_function, CAR, CDR, ENTITY_ABS_P, ENTITY_CABS_P, ENTITY_DABS_P, ENTITY_DIVIDE_P, ENTITY_IABS_P, ENTITY_MINUS_P, ENTITY_MULTIPLY_P, ENTITY_PLUS_P, entity_type, ENTITY_UNARY_MINUS_P, EXPRESSION, expression_integer_value(), expression_syntax, f(), functional_result, gen_length(), intptr_t, negative_expression_p(), overloaded_type_p(), pips_assert, reference_variable, syntax_call, syntax_call_p, syntax_reference, syntax_reference_p, type_functional, type_functional_p, ultimate_type(), and unsigned_type_p().

Referenced by add_index_range_conditions(), C_loop_range(), incrementation_expression_to_increment(), and negative_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

range_count()

bool range_count	(	range	r,
		intptr_t *	pcount
	)

The range count only can be evaluated if the three range expressions are constant and if the increment is non zero.

On failure, a zero count is returned. See also SizeOfRange().

inc>0

Parameters

pcount

count

Definition at line 979 of file eval.c.

{
    bool success = false;
    intptr_t l, u, inc;
 
    if(expression_integer_value(range_lower(r), &l)
       && expression_integer_value(range_upper(r), &u)
       && expression_integer_value(range_increment(r), &inc)
       && inc != 0 ) {
 
        if(inc<0) {
            * pcount = ((l-u)/(-inc))+1;
        }
        else /* inc>0 */ {
            * pcount = ((u-l)/inc)+1;
        }
 
        if(* pcount < 0)
            *pcount = 0;
 
        success = true;
    }
    else {
        * pcount = 0;
        success = false;
    }
 
    return success;
}

References expression_integer_value(), intptr_t, range_increment, range_lower, and range_upper.

Referenced by implied_do_reference_number().

Here is the call graph for this function:

Here is the caller graph for this function:

range_to_expression()

expression range_to_expression	(	range	r,
		enum range_to_expression_mode	mode
	)

computes the distance between the lower bound and the upper bound of the range

Parameters

r	range to analyse
mode	wether we compute the distance or count the number of iterations

Returns

appropriate distance or count

Definition at line 963 of file eval.c.

{
    expression distance =  make_op_exp(PLUS_OPERATOR_NAME,
            copy_expression(range_upper(r)),
            make_op_exp(MINUS_OPERATOR_NAME,
                int_to_expression(1),
                copy_expression(range_lower(r))));
    if( range_to_nbiter_p(mode) ) distance = make_op_exp(DIVIDE_OPERATOR_NAME,distance,copy_expression(range_increment(r)));
    return distance;
}

References copy_expression(), DIVIDE_OPERATOR_NAME, int_to_expression(), make_op_exp(), MINUS_OPERATOR_NAME, PLUS_OPERATOR_NAME, range_increment, range_lower, range_to_nbiter_p, and range_upper.

Referenced by add_loop_parallel_threshold(), build_iteration_list(), do_loop_expansion(), do_loop_expansion_init(), sesamify(), simd_loop_unroll(), simdizer_auto_tile(), and terapix_loop_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_const_p()

static bool vect_const_p ( Pvecteur  v )

static

returns true if v is not NULL and is constant

I make it "static" because it conflicts with a Linear library function. Both functions have the same name but a slightly different behavior. The Linear version returns 0 when a null vector is passed as argument. Francois Irigoin, 16 April 1990

See vect_constant_p() placed in linear/src/contrainte/predicats.c. Seems now OK.

Definition at line 1020 of file eval.c.

{
    pips_assert("vect_const_p", v != NULL);
    return vect_size(v) == 1 && value_notzero_p(vect_coeff(TCST, v));
}

References pips_assert, TCST, value_notzero_p, vect_coeff(), and vect_size().

Referenced by vect_product().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_product()

Pvecteur vect_product	(	Pvecteur *	pv1,
		Pvecteur *	pv2
	)

returns a Pvecteur equal to (*pv1) * (*pv2) if this product is linear or NULL otherwise.

the result is built from pv1 or pv2 and the other vector is removed.

Parameters

pv1	v1
pv2	v2

Definition at line 1032 of file eval.c.

{
    Pvecteur vr;
 
    if (vect_const_p(*pv1)) {
        vr = vect_multiply(*pv2, vect_coeff(TCST, *pv1));
        vect_rm(*pv1);
    }
    else if (vect_const_p(*pv2)) {
        vr = vect_multiply(*pv1, vect_coeff(TCST, *pv2));
        vect_rm(*pv2);
    }
    else {
        vr = NULL;
        vect_rm(*pv1);
        vect_rm(*pv2);
    }
 
    *pv1 = NULL;
    *pv2 = NULL;
 
    return(vr);
}

References TCST, vect_coeff(), vect_const_p(), vect_multiply(), and vect_rm().

Here is the call graph for this function: