eval.c File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "parser_private.h"
#include "syntax.h"
#include "toklex.h"

Include dependency graph for eval.c:

Go to the source code of this file.

Functions
value	EvalExpression (expression e)
	lint More...
value	EvalSyntax (syntax s)
value	EvalCall (call c)
	only calls to constant, symbolic or intrinsic functions might be evaluated. More...
value	EvalConstant (ant c) const
value	EvalIntrinsic (entity e, cons *la)
	this function tries to evaluate a call to an intrinsic function. More...
value	EvalUnaryOp (int t, cons *la)
value	EvalBinaryOp (int t, cons *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	ipow (int vg, int vd)
	FI: such a function should exist in Linear/arithmetique. More...

Variables
char	vcid_syntax_eval [] = "%A% ($Date: 1998/04/14 21:28:15 $, ) version $Revision: 16236 $, got on %D%, %T% [%P%].\n Copyright (c) École des Mines de Paris Proprietary."

Function Documentation

EvalBinaryOp()

value EvalBinaryOp	(	int	t,
		cons *	la
	)

Definition at line 195 of file eval.c.

{
    value v;
    int argl, argr;
 
    pips_assert("EvalBinaryOpt", la != NIL);
    v = EvalExpression(EXPRESSION(CAR(la)));
    if (value_constant_p(v) && constant_int_p(value_constant(v))) {
        argl = constant_int(value_constant(v));
        gen_free(v);
    }
    else
            return(v);
 
    la = CDR(la);
    pips_assert("EvalBinaryOpt", la != NIL);
    v = EvalExpression(EXPRESSION(CAR(la)));
    if (value_constant_p(v) && constant_int_p(value_constant(v))) {
        argr = constant_int(value_constant(v));
    }
    else
            return(v);
 
    switch (t) {
      case TK_MINUS:
        constant_int(value_constant(v)) = argl-argr;
        break;
      case TK_PLUS:
        constant_int(value_constant(v)) = argl+argr;
        break;
      case TK_STAR:
        constant_int(value_constant(v)) = argl*argr;
        break;
      case TK_SLASH:
        if (argr != 0)
                constant_int(value_constant(v)) = argl/argr;
        else
                FatalError("EvalBinaryOp", "zero divide\n");
        break;
      case TK_POWER:
        if (argr >= 0)
                constant_int(value_constant(v)) = ipow(argl,argr);
        else {
            gen_free(v);
            v = make_value_unknown();
        }
        break;
      default:
        debug(9, "EvalBinaryOp", "pas encore d'evaluation\n");
        gen_free(v);
        v = make_value_unknown();
    }
 
    return(v);
}

References CAR, CDR, constant_int, constant_int_p, debug(), EvalExpression(), EXPRESSION, FatalError, gen_free(), ipow(), make_value_unknown(), NIL, pips_assert, TK_MINUS, TK_PLUS, TK_POWER, TK_SLASH, TK_STAR, value_constant, and value_constant_p.

Here is the call 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.

it might be an intrinsic function

Definition at line 95 of file eval.c.

{
        value vout, vin;
        entity f;
 
        f = call_function(c);
        vin = entity_initial(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:
                vout = EvalConstant((symbolic_constant(value_symbolic(vin))));
                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:
                ParserError("EvalCall", "case default\n");
        }
 
        return(vout);
}

References call_arguments, call_function, entity_initial, EvalConstant(), EvalIntrinsic(), f(), is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, make_value_unknown(), ParserError(), symbolic_constant, value_constant, value_symbolic, and value_tag.

Here is the call graph for this function:

EvalConstant()

value EvalConstant

(

ant

c

)

const

Definition at line 130 of file eval.c.

{
    return((constant_int_p(c)) ?
           make_value(is_value_constant, make_constant(is_constant_int,
                                                       constant_int(c))) :
           MakeValueLitteral());
}

References constant_int, constant_int_p, is_constant_int, is_value_constant, make_constant(), make_value(), and MakeValueLitteral().

Here is the call graph for this function:

EvalExpression()

value EvalExpression

(

expression

e

)

lint

cproto-generated files

This file contains a set of functions to evaluate integer constant expressions. The algorithm is built on a recursive analysis of the expression structure. Lower level functions are called until basic atoms are reached. The succes of basic atom evaluation depend on the atom type:

reference: right now, the evaluation fails because we do not compute predicates on variables.

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 55 of file eval.c.

{
    return(EvalSyntax(expression_syntax(e)));
}

References EvalSyntax(), and expression_syntax.

Here is the call graph for this function:

EvalIntrinsic()

value EvalIntrinsic	(	entity	e,
		cons *	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.

Definition at line 150 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
            v = make_value_unknown();
 
    return(v);
}

References EvalBinaryOp(), EvalUnaryOp(), IsBinaryOperator(), IsUnaryOperator(), and make_value_unknown().

Here is the call 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 63 of file eval.c.

{
  value v;
 
  switch (syntax_tag(s)) {
  case is_syntax_reference:
  case is_syntax_range:
    v = make_value_unknown();
    break;
  case is_syntax_call:
    v = EvalCall((syntax_call(s)));
    break;
  case is_syntax_cast:
  case is_syntax_sizeofexpression:
  case is_syntax_subscript:
  case is_syntax_application:
  case is_syntax_va_arg:
    v = make_value_unknown();
    break;
  default:
    ParserError("EvalExpression", "cas default\n");
  }
 
  return(v);
}

References EvalCall(), 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(), ParserError(), syntax_call, and syntax_tag.

Here is the call graph for this function:

EvalUnaryOp()

value EvalUnaryOp	(	int	t,
		cons *	la
	)

Definition at line 169 of file eval.c.

{
        value vout, v;
        int arg;
 
        pips_assert("EvalUnaryOpt", 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 == TK_MINUS) {
                constant_int(value_constant(v)) = -arg;
                vout = v;
        }
        else {
                gen_free(v);
                vout = make_value_unknown();
        }
 
        return(vout);
}

References CAR, constant_int, constant_int_p, EvalExpression(), EXPRESSION, gen_free(), make_value_unknown(), NIL, pips_assert, TK_MINUS, value_constant, and value_constant_p.

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?

FI: see arithmetique library

Parameters

vg	g
vd	d

Definition at line 315 of file eval.c.

{
    /* FI: see arithmetique library */
        int i = 1;
 
        pips_assert("ipow", vd >= 0);
 
        while (vd-- > 0)
                i *= vg;
 
        return(i);
}

References pips_assert.

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 272 of file eval.c.

{
        int token;
 
        if      (strcmp(entity_local_name(e), "-") == 0)
                token = TK_MINUS;
        else if (strcmp(entity_local_name(e), "+") == 0)
                token = TK_PLUS;
        else if (strcmp(entity_local_name(e), "*") == 0)
                token = TK_STAR;
        else if (strcmp(entity_local_name(e), "/") == 0)
                token = TK_SLASH;
        else if (strcmp(entity_local_name(e), "**") == 0)
                token = TK_POWER;
        else if (strcmp(entity_local_name(e), ".EQ.") == 0)
                token = TK_EQ;
        else if (strcmp(entity_local_name(e), ".NE.") == 0)
                token = TK_NE;
        else if (strcmp(entity_local_name(e), ".EQV") == 0)
                token = TK_EQV;
        else if (strcmp(entity_local_name(e), ".NEQV") == 0)
                token = TK_NEQV;
        else if (strcmp(entity_local_name(e), ".GT.") == 0)
                token = TK_GT;
        else if (strcmp(entity_local_name(e), ".LT.") == 0)
                token = TK_LT;
        else if (strcmp(entity_local_name(e), ".GE.") == 0)
                token = TK_GE;
        else if (strcmp(entity_local_name(e), ".LE.") == 0)
                token = TK_LE;
        else if (strcmp(entity_local_name(e), ".OR.") == 0)
                token = TK_OR;
        else if (strcmp(entity_local_name(e), ".AND.") == 0)
                token = TK_AND;         
        else
                token = -1;
 
        return(token);
}

References entity_local_name(), TK_AND, TK_EQ, TK_EQV, TK_GE, TK_GT, TK_LE, TK_LT, TK_MINUS, TK_NE, TK_NEQV, TK_OR, TK_PLUS, TK_POWER, TK_SLASH, and TK_STAR.

Here is the call graph for this function:

IsUnaryOperator()

int IsUnaryOperator

(

entity

e

)

Definition at line 255 of file eval.c.

{
        int token;
 
        if (strcmp(entity_local_name(e), "--") == 0)
                token = TK_MINUS;
        else if (strcmp(entity_local_name(e), ".NOT.") == 0)
                token = TK_NOT;
        else
                token = -1;
 
        return(token);
}

References entity_local_name(), TK_MINUS, and TK_NOT.

Here is the call graph for this function:

Variable Documentation

vcid_syntax_eval

char vcid_syntax_eval[] = "%A% ($Date: 1998/04/14 21:28:15 $, ) version $Revision: 16236 $, got on %D%, %T% [%P%].\n Copyright (c) École des Mines de Paris Proprietary."

Definition at line 29 of file eval.c.