expression.c File Reference

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

Include dependency graph for expression.c:

Go to the source code of this file.

Data Structures
struct	ctx_substitute

Macros
#define	ALREADY_SEEN(node)   (hash_defined_p(seen, (char*)node))
#define	SEEN(node)   (hash_put(seen, (char*) node, (char*) 1))
#define	DV_CIRCLE   ",a(\"_GO\",\"circle\")"
#define	DV_YELLOW   ",a(\"COLOR\",\"yellow\")"

Typedefs
typedef struct ctx_substitute	ctx_substitute_t

Functions
static string	actual_fortran_string_to_compare (string fs, int *plength)
	quite lazy... More...
int	fortran_string_compare (string fs1, string fs2)
	compare pips fortran string constants from the fortran point of view. More...
tag	suggest_basic_for_expression (expression e)
	a BASIC tag is returned for the expression this is a preliminary version. More...
expression	expression_mult (expression ex)
expression	entity_to_expression (entity e)
	if v is a constant, returns a constant call. More...
expression	make_entity_expression (entity e, cons *inds)
expression	reference_to_expression (reference r)
reference	expression_to_reference (expression e)
reference	add_subscript_to_reference (reference r, expression s)
	Add a last subscript expression s to a reference r. More...
void	generic_reference_add_fixed_subscripts (reference r, type t, bool zero_p)
	Add a set of zero subscripts to a reference "r" by side effect. More...
void	reference_add_zero_subscripts (reference r, type t)
void	reference_add_zero_subscript (reference r)
	No check on reference r. More...
void	reference_complete_with_zero_subscripts (reference r)
	Reference r to an array maybe partial, as is possible in C: with declaration "int a[10][10]", references "a", "a[i]" and "a[i][j]" are all legal. More...
void	reference_add_unbounded_subscripts (reference r, type t)
expression	call_to_expression (call c)
	Build an expression that call a function or procedure. More...
expression	make_call_expression (entity e, list l)
	Build an expression that call an function entity with an argument list. More...
expression	MakeNullaryCall (entity f)
	Creates a call expression to a function with zero arguments. More...
expression	MakeUnaryCall (entity f, expression a)
	Creates a call expression to a function with one argument. More...
expression	MakeBinaryCall (entity f, expression eg, expression ed)
	Creates a call expression to a function with 2 arguments. More...
expression	MakeTernaryCall (entity f, expression e1, expression e2, expression e3)
	Creates a call expression to a function with 3 arguments. More...
expression	make_assign_expression (expression lhs, expression rhs)
	Make an assign expression, since in C the assignment is a side effect operator. More...
expression	make_subscript_expression (expression a, list sl)
bool	expression_brace_p (expression e)
	predicates and short cut accessors on expressions More...
bool	expression_call_p (expression e)
bool	expression_address_of_p (expression e)
call	expression_call (expression e)
bool	expression_cast_p (expression e)
cast	expression_cast (expression e)
bool	expression_sizeofexpression_p (expression e)
sizeofexpression	expression_sizeofexpression (expression e)
bool	expression_application_p (expression e)
	Duplicate bool expression_subscript_p(expression e) { return(syntax_subscript_p(expression_syntax(e))); }. More...
application	expression_application (expression e)
bool	expression_field_p (expression e)
	The expression is of kind "s.a", where "s" is a struct and a "a" field. More...
bool	field_expression_p (expression e)
	The expression is of kind "a", where "a" is a field of some struct "s". More...
bool	expression_pointer_p (expression e)
	we get the type of the expression by calling expression_to_type() which allocates a new one. More...
bool	array_argument_p (expression e)
bool	expression_reference_p (expression e)
	Test if an expression is a reference. More...
entity	expression_variable (expression e)
bool	is_expression_reference_to_entity_p (expression e, entity v)
	Test if an expression is a reference to a given variable entity. More...
bool	same_expression_in_list_p (expression e, list le)
	This function returns true, if there exists a same expression in the list false, otherwise. More...
bool	expression_equal_in_list_p (expression e, list le)
	This function returns true, if there exists an expression equal in the list false, otherwise. More...
bool	logical_operator_expression_p (expression e)
	C xor is missing. More...
bool	relational_expression_p (expression e)
bool	integer_expression_p (expression e)
bool	logical_expression_p (expression e)
int	trivial_expression_p (expression e)
	This function returns: More...
expression	expression_verbose_reduction_p_and_return_increment (expression incr, bool filter(expression))
	Test if an expression is a verbose reduction of the form : "i = i op v" or "i = v op i". More...
bool	expression_implied_do_p (e)
bool	comma_expression_p (expression e)
bool	expression_list_directed_p (e)
bool	extended_integer_constant_expression_p (expression e)
	More extensive than next function. More...
bool	extended_integer_constant_expression_p_to_int (expression e, int *result)
bool	integer_constant_expression_p (expression e)
	positive integer constant expression: call to a positive constant or to a sum of positive integer constant expressions (much too restrictive, but enough for the source codes submitted to PIPS up to now). More...
bool	signed_integer_constant_expression_p (expression e)
bool	expression_with_constant_signed_integer_value_p (expression e)
	The expression may be complicated but all its leaves are constants or parameters. More...
bool	assignment_expression_p (expression e)
	Test if an expression is an assignment operation. More...
bool	add_expression_p (expression e)
	Test if an expression is an addition. More...
bool	sub_expression_p (expression e)
bool	substraction_expression_p (expression e)
	Test if an expression is an substraction. More...
bool	modulo_expression_p (expression e)
bool	divide_expression_p (expression e)
bool	power_expression_p (expression e)
bool	abs_expression_p (expression e)
bool	unary_minus_expression_p (expression e)
bool	iabs_expression_p (expression e)
bool	dabs_expression_p (expression e)
bool	cabs_expression_p (expression e)
bool	min0_expression_p (expression e)
bool	max0_expression_p (expression e)
bool	user_function_call_p (expression e)
bool	operator_expression_p (expression e, string op_name)
expression	make_true_expression ()
expression	make_false_expression ()
bool	true_expression_p (expression e)
bool	false_expression_p (expression e)
bool	unbounded_dimension_p (dimension dim)
	bool unbounded_dimension_p(dim) input : a dimension of an array entity. More...
expression	find_ith_argument (list args, int n)
expression	find_ith_expression (list le, int r)
	find_ith_expression() is obsolet; use find_ith_argument() instead More...
expression	int_to_expression (_int i)
	transform an int into an expression and generate the corresponding entity if necessary; it is not clear if strdup() is always/sometimes necessary and if a memory leak occurs; wait till syntax/expression.c is merged with ri-util/expression.c More...
expression	make_zero_expression (void)
	Make a zero expression. More...
bool	zero_expression_p (expression e)
expression	float_to_expression (float c)
expression	complex_to_expression (float re, float im)
expression	bool_to_expression (bool b)
expression	Value_to_expression (Value v)
	added interface for linear stuff. More...
list	expression_to_reference_list (expression e, list lr)
	conversion of an expression into a list of references; references are appended to list lr as they are encountered; array references are added before their index expressions are scanned; More...
list	syntax_to_reference_list (syntax s, list lr)
bool	expression_equal_p (expression e1, expression e2)
	Syntactic equality e1==e2. More...
bool	expression_equal_or_opposite_p (expression e1, expression e2)
	e1==e2 or -e1==e2 or e1==-e2 syntactically More...
bool	expression_opposite_p (expression e1, expression e2)
	e1+e2==0, i.e. More...
bool	expression_lists_equal_p (list l1, list l2)
bool	same_expression_p (expression e1, expression e2)
	this is slightly different from expression_equal_p, as it will return true for a+b vs b+a More...
bool	sizeofexpression_equal_p (sizeofexpression s0, sizeofexpression s1)
bool	cast_equal_p (cast c1, cast c2)
bool	syntax_equal_p (syntax s1, syntax s2)
bool	subscript_equal_p (subscript s1, subscript s2)
bool	reference_equal_p (reference r1, reference r2)
bool	range_equal_p (range r1, range r2)
bool	call_equal_p (call c1, call c2)
int	integer_constant_expression_value (expression e)
int	signed_integer_constant_expression_value (expression e)
expression	make_max_expression (expression e1, expression e2, enum language_utype lang)
expression	make_min_expression (expression e1, expression e2, enum language_utype lang)
expression	make_factor_expression (int coeff, entity vari)
	Some functions to generate expressions from vectors and constraint systems. More...
expression	make_vecteur_expression (Pvecteur pv)
	make expression for vector (Pvecteur) More...
statement	Pvecteur_to_assign_statement (entity var, Pvecteur v)
	generates var = linear expression from the Pvecteur. More...
expression	make_constraint_expression (Pvecteur v, Variable index)
	Make an expression from a constraint v for a given index. More...
expression	make_contrainte_expression (Pcontrainte pc, Variable index)
	A wrapper around make_constraint_expression() for compatibility. More...
expression	Pvecteur_to_expression (Pvecteur vect)
	AP, sep 25th 95 : some usefull functions moved from static_controlize/utils.c. More...
reference	expression_reference (expression e)
	Short cut, meaningful only if expression_reference_p(e) holds. More...
bool	expression_subscript_p (expression e)
subscript	expression_subscript (expression e)
bool	expression_range_p (expression e)
range	expression_range (expression e)
bool	array_reference_p (reference r)
	predicates on references More...
bool	references_do_not_conflict_p (reference r1, reference r2)
	If true is returned, the two references cannot conflict unless array bound declarations are violated. More...
expression	expression_list_to_binary_operator_call (list l, entity op)
expression	expression_list_to_conjonction (list l)
bool	expression_intrinsic_operation_p (expression exp)
	bool expression_intrinsic_operation_p(expression exp): Returns true if "exp" is an expression with a call to an intrinsic operation. More...
bool	call_constant_p (call c)
	bool call_constant_p(call c): Returns true if "c" is a call to a constant, that is, a constant number or a symbolic constant. More...
bool	expression_equal_integer_p (expression exp, int i)
	================================================================ More...
expression	make_op_exp (char *op_name, expression exp1, expression exp2)
	================================================================ More...
expression	add_integer_to_expression (expression exp, int val)
expression	make_lin_op_exp (entity op_ent, expression exp1, expression exp2)
	================================================================ More...
int	expression_to_int (expression exp)
	================================================================ More...
float	expression_to_float (expression exp)
	Same as above for floating point constants. More...
constant	expression_constant (expression exp)
	This function returns a "constant" object if the expression is a constant such as 10, -11 or 2.345 or "foo". More...
bool	expression_string_constant_p (expression exp)
char *	expression_string_constant (expression exp)
	returns a newly allocated string! More...
bool	expression_integer_constant_p (expression e)
bool	expression_constant_p (expression exp)
	================================================================ More...
bool	extended_expression_constant_p (expression exp)
	Returns true if the value of the expression does not depend syntactically on the current store. More...
bool	expression_is_C_rhs_p (expression exp)
	Not all expressions can be used as right-hand side (rhs) in C assignments. More...
bool	expression_one_p (expression exp)
bool	expression_null_p (expression exp)
	returns true if the expression is equal to zero or NULL (even if there is a cast before such as in (void *) 0). More...
static bool	davinci_dump_expression_rc (FILE *out, expression e, hash_table seen)
void	davinci_dump_expression (FILE *out, expression e)
	dump expression e in file out as a davinci graph. More...
static bool	expr_flt (expression e)
void	davinci_dump_all_expressions (FILE *out, statement s)
	dump all expressions in s to out. More...
static void	substitute_variable_in_reference (reference r, ctx_substitute_t *ctx)
static void	substitute_entity_in_call (call c, ctx_substitute_t *ctx)
expression	substitute_entity_variable_in_expression (entity old, entity new, expression e)
	(This function isn't use for the moment) This function replaces all the occurrences of an old entity in the expression exp by the new entity. More...
expression	substitute_entity_in_expression (entity old, entity new, expression e)
	This function replaces all the occurences of an old entity in the expression exp by the new entity. More...
bool	simplify_C_expression (expression e)
	Replace C operators "+C" and "-C" which can handle pointers by arithmetic operators "+" and "-" when it is safe to do so, i.e. More...
expression	convert_bound_expression (expression e, bool upper_p, bool non_strict_p)
	Replace a C expression used as FOR bound by a Fortran DO bound expression, taking into account the C comparison operator used. More...
bool	reference_with_constant_indices_p (reference r)
reference	reference_with_store_independent_indices (reference r)
	Return by side effect a reference whose memory locations includes the memory locations of r in case the subcript expressions are changed by a store change. More...
bool	reference_with_unbounded_indices_p (reference r)
	indices can be constant or unbounded: they are store independent. More...
bool	reference_with_unbounded_subscript_p (reference r)
	See if the reference uses the unbounded function '*'. More...
bool	store_independent_reference_p (reference r)
	Does this reference define the same set of memory locations regardless of the current (environment and) memory state? More...
entity	expression_to_entity (expression e)
	just returns the entity of an expression, or entity_undefined More...
list	expressions_to_entities (list expressions)
	map expression_to_entity on expressions More...
static bool	_expression_similar_p (expression target, expression pattern, hash_table symbols)
	perform the real similarity comparaison between two expressions target is matched against pattern, and expression <> argument is stored in symbols More...
bool	expression_similar_get_context_p (expression target, expression pattern, hash_table *symbol_table)
	similar to expression_similar_p but the hash_map containing the crossref value is retured for further use More...
bool	expression_similar_p (expression target, expression pattern)
	compare if two expressions are similar that is can we exchange target and pattern by substituing variables examples: 1+2 ~ a+b a+b !~ a+2 1+b ~ 1+c More...
list	make_list_of_constant (int val, int number)
	of expression More...
bool	brace_expression_p (expression e)
	Return bool indicating if expression e is a brace expression. More...
static list	do_brace_expression_to_statements (entity arr, expression e, list curr_indices)
	helper for brace_expression_to_statements More...
list	brace_expression_to_statements (entity arr, expression e)
	converts a brace expression used to initialize an array (not a struct yet) into a statement sequence More...
static void	do_brace_expression_to_updated_type (entity arr, expression e, list dl)
	helper for brace_expression_to_updated_type More...
void	brace_expression_to_updated_type (entity arr, expression e)
	use a brace expression to update the type of array "arr" if the dimensions are implicit More...
bool	reference_scalar_p (reference r)
	This function returns true if Reference r is scalar. More...
expression	expressions_to_operation (const list l_exprs, entity op)
	take a list of expression and apply a binary operator between all of them and return it as an expression More...
void	update_expression_syntax (expression e, syntax s)
	frees expression syntax of e and replace it by the new syntax s More...
void	local_assign_expression (expression caller, expression field)
	replace expression caller by expression field , where field is contained by caller More...
expression	syntax_to_expression (syntax s)
	generates an expression from a syntax More...
expression	monome_to_expression (Pmonome pm)
	converts a monome to an expression More...
expression	polynome_to_expression (Ppolynome pp)
	converts a polynomial to expression More...
Ppolynome	expression_to_polynome (expression exp)
	=========================================================================== More...
bool	simplify_expression (expression *pexp)
	use polynomials to simplify an expression in some cases this operation can change the basic of the expression. More...
static void	do_simplify_expressions (call c)
void	simplify_expressions (void *obj)
expression	reference_offset (reference ref)
	computes the offset of a C reference with its origin More...
expression	replace_expression_content (expression e1, expression e2)
	Use side effects to move the content of e2, s2 and n2, into e1; s1 and n1 are freed, as well as e2. More...
bool	expression_minmax_p (expression e)
expression	MakeSizeofExpression (expression e)
expression	MakeSizeofType (type t)
expression	MakeCastExpression (type t, expression e)
expression	MakeCommaExpression (list l)
expression	MakeBraceExpression (list l)
expression	dereference_expression (expression e)
	generate a newly allocated expression for *(e) More...
expression	make_address_of_expression (expression e)
	generate a newly allocated expression for &(e) More...
list	subscript_expressions_to_constant_subscript_expressions (list sl)
	make a full copy of the subscript expression list, preserve constant subscripts, replace non-constant subscript by the star subscript expression. More...
expression	pointer_reference_to_expression (reference r)
	Assume p is a pointer. More...
expression	expression_to_dereferencing_expression (expression e)
	Reuse expression e to build expression *(e) without cheking the legality of the construct. More...
bool	C_initialization_expression_p (expression e)
list	struct_initialization_expression_to_expressions (expression e)
	Returns a list of expressions hidden by the brace function. More...
void	free_expressions (list el)
	Free a list of expressions. More...
static void	expr_rwt (expression e)
	hack: clean all normalize fields... More...
void	clean_all_normalized (expression e)
expression	subscript_value_stride (entity arr, list l_inds)
expression	size_of_actual_array (entity actual_array, list l_actual_ref, int i)
expression	make_ref_expr (entity ent, list args)
bool	unbounded_entity_p (entity f)
bool	unbounded_expression_p (expression e)
expression	make_unbounded_expression ()
list	make_unbounded_subscripts (int d)
	FI: this piece of code must have been duplicated somewhere else in an effect library. More...
bool	user_call_p (call c)
	Test if a call is a user call. More...
void	normalize_subscript_expression (expression e)
	Normalization of subscript in expressions. More...
void	expression_normalize_subscripts (expression e)
	To be used for initialization expressions. More...
void	statement_normalize_subscripts (statement s)
	To be used for module statements. More...

Variables
static FILE *	out_flt = NULL

Macro Definition Documentation

ALREADY_SEEN

#define ALREADY_SEEN

(

node

)

(hash_defined_p(seen, (char*)node))

Definition at line 2631 of file expression.c.

DV_CIRCLE

#define DV_CIRCLE   ",a(\"_GO\",\"circle\")"

Definition at line 2634 of file expression.c.

DV_YELLOW

#define DV_YELLOW   ",a(\"COLOR\",\"yellow\")"

Definition at line 2635 of file expression.c.

SEEN

#define SEEN

(

node

)

(hash_put(seen, (char*) node, (char*) 1))

Definition at line 2632 of file expression.c.

Typedef Documentation

ctx_substitute_t

typedef struct ctx_substitute ctx_substitute_t

Function Documentation

_expression_similar_p()

static bool _expression_similar_p ( expression  target, expression  pattern, hash_table  symbols  )

static

perform the real similarity comparaison between two expressions target is matched against pattern, and expression <> argument is stored in symbols

Parameters

target	cheked expression
pattern	pattern expression
symbols	map storing entity <> expression tuple

Returns

true if similar

cast handler

we memorize reference from target and pattern in the symbol table similar to \1 in sed

scalar reference always matches. SG: in fact, you have to check for type compatibility too ... Allows to match malloc(a) with more complex expressions like malloc(1 + strlen("...")). Interferes incorrectly with commutativity.

recursively compare each arguments if call do not differ

could occur with va args

SG: will this be usefull ?

SG:not supported yet

could occur with va args

Definition at line 3180 of file expression.c.

{
    bool similar=true;
    syntax starget = expression_syntax(target),
           spattern = expression_syntax(pattern);
 
    /* cast handler */
    if( syntax_cast_p( spattern ) )
    {
        pips_user_warning("cast ignored\n");
        return _expression_similar_p(target, cast_expression(syntax_cast(spattern)),symbols);
    }
    if( syntax_cast_p( starget ) )
    {
        pips_user_warning("cast ignored\n");
        return _expression_similar_p(cast_expression(syntax_cast(starget)), pattern,symbols);
    }
 
    switch(syntax_tag(spattern) )
    {
        /* we memorize reference from target and pattern in the symbol table
         * similar to \1 in sed
         */
        case is_syntax_reference:
            {
                    reference r = syntax_reference(spattern);
                    /* scalar reference always matches.
             * SG: in fact, you have to check for type compatibility too ...
             * Allows to match malloc(a) with more complex expressions like malloc(1 +
                     * strlen("...")).
             * Interferes incorrectly with commutativity. */
                    if (! expression_scalar_p(pattern))
                            similar = false;
                    else {
                basic bpattern = basic_of_expression(pattern),
                      btarget = basic_of_expression(target);
                basic bmax = basic_maximum(bpattern,btarget);
                if(basic_overloaded_p(bmax) || basic_equal_p(bmax,bpattern)) {
                    hash_put(symbols,entity_name(reference_variable(r)), target);
                }
                else
                    similar = false;
                free_basic(bmax);
                free_basic(bpattern);
                free_basic(btarget);
            }
            } break;
            /* recursively compare each arguments if call do not differ */
        case is_syntax_call:
            if( syntax_call_p(starget) &&
                    same_entity_p( call_function(syntax_call(starget)), call_function(syntax_call(spattern)) ) )
            {
                call cpattern = syntax_call(spattern);
                call ctarget = syntax_call(starget);
                if(commutative_call_p(cpattern))
                {
                    pips_assert("pips commutative call have only two arguments\n",gen_length(call_arguments(cpattern))==2);
                    expression lhs_pattern = binary_call_lhs(cpattern),
                               rhs_pattern = binary_call_rhs(cpattern),
                               lhs_target = binary_call_lhs(ctarget),
                               rhs_target = binary_call_rhs(ctarget);
                    similar = (_expression_similar_p(lhs_target,lhs_pattern,symbols) && _expression_similar_p(rhs_target,rhs_pattern,symbols))
                        ||
                        (_expression_similar_p(lhs_target,rhs_pattern,symbols) && _expression_similar_p(rhs_target,lhs_pattern,symbols))
                        ;
 
                }
                else
                {
                    list iter = call_arguments(cpattern);
                    FOREACH(EXPRESSION, etarget, call_arguments(ctarget) )
                    {
                        if( ENDP(iter) ) { similar = false; break; }/* could occur with va args */
                        expression epattern = EXPRESSION(CAR(iter));
                        similar&= _expression_similar_p(etarget,epattern,symbols);
                        POP(iter);
                        if(!similar)
                            break;
                    }
                }
            }
            else
            {
                similar =false;
            }
            break;
            /* SG: will this be usefull ?*/
        case is_syntax_range:
            similar = syntax_range_p(starget) &&
                _expression_similar_p(range_lower(syntax_range(starget)),range_lower(syntax_range(spattern)),symbols) &&
                _expression_similar_p(range_upper(syntax_range(starget)),range_upper(syntax_range(spattern)),symbols) &&
                _expression_similar_p(range_increment(syntax_range(starget)),range_increment(syntax_range(spattern)),symbols);
            break;
 
            /* SG:not supported yet */
        case is_syntax_cast:
            pips_user_warning("cast ignored\n");
            similar = _expression_similar_p(cast_expression(syntax_cast(starget)),pattern,symbols);
            break;
 
        case is_syntax_sizeofexpression:
            if( syntax_sizeofexpression_p(starget) )
            {
                sizeofexpression seo_target = syntax_sizeofexpression(starget);
                sizeofexpression seo_pattern = syntax_sizeofexpression(spattern);
                if( sizeofexpression_type(seo_pattern) )
                    similar = sizeofexpression_type_p(seo_target) &&
                        type_equal_p( sizeofexpression_type(seo_target), sizeofexpression_type(seo_pattern) );
                else
                    similar = _expression_similar_p(sizeofexpression_expression(seo_target),
                            sizeofexpression_expression(seo_pattern),
                            symbols );
            }
            else
            {
                similar =false;
            }
            break;
 
        case is_syntax_subscript:
            if( syntax_subscript_p(starget) )
            {
                subscript sub_target = syntax_subscript(starget),
                          sub_pattern = syntax_subscript(spattern);
                similar&= _expression_similar_p( subscript_array(sub_target), subscript_array(sub_pattern),symbols );
 
                list iter = subscript_indices(sub_pattern);
                FOREACH(EXPRESSION, etarget, subscript_indices(sub_target) )
                {
                    if( ENDP(iter) ) { similar = false; break; }/* could occur with va args */
                    expression epattern = EXPRESSION(CAR(iter));
                    similar&= _expression_similar_p(etarget,epattern,symbols);
                    POP(iter);
                }
            }
            else
                similar =false;
            break;
        case is_syntax_application:
            pips_user_warning("application similarity not implemented yet\n");
            similar=false;
            break;
        case is_syntax_va_arg:
            pips_user_warning("va_arg similarity not implemented yet\n");
            similar=false;
            break;
    };
    return similar;
}

References basic_equal_p(), basic_maximum(), basic_of_expression(), basic_overloaded_p, binary_call_lhs, binary_call_rhs, call_arguments, call_function, CAR, cast_expression, commutative_call_p(), ENDP, entity_name, EXPRESSION, expression_scalar_p, expression_syntax, FOREACH, free_basic(), gen_length(), hash_put(), 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, pips_assert, pips_user_warning, POP, range_increment, range_lower, range_upper, reference_variable, same_entity_p(), sizeofexpression_expression, sizeofexpression_type, sizeofexpression_type_p, subscript_array, subscript_indices, syntax_call, syntax_call_p, syntax_cast, syntax_cast_p, syntax_range, syntax_range_p, syntax_reference, syntax_sizeofexpression, syntax_sizeofexpression_p, syntax_subscript, syntax_subscript_p, syntax_tag, and type_equal_p().

Referenced by expression_similar_get_context_p(), and expression_similar_p().

Here is the call graph for this function:

Here is the caller graph for this function:

abs_expression_p()

bool abs_expression_p

(

expression

e

)

Definition at line 1024 of file expression.c.

{
    return operator_expression_p(e, ABS_OPERATOR_NAME);
}

References ABS_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

actual_fortran_string_to_compare()

static string actual_fortran_string_to_compare ( string  fs, int *  plength  )

static

quite lazy...

skip TOP-LEVEL header

skip : header

skip surrounding quotes

skip trailing spaces (are these blanks?) if any.

Definition at line 54 of file expression.c.

{
  string s = fs;
  int len;
 
  /* skip TOP-LEVEL header */
  if (strncmp(s, TOP_LEVEL_MODULE_NAME, strlen(TOP_LEVEL_MODULE_NAME))==0)
    s += strlen(TOP_LEVEL_MODULE_NAME);
 
  /* skip : header */
  if (strncmp(s, MODULE_SEP_STRING, strlen(MODULE_SEP_STRING))==0)
    s += strlen(MODULE_SEP_STRING);
 
  len = strlen(s);
 
  /* skip surrounding quotes */
  if (len>=2 &&
      ((s[0]=='\'' && s[len-1]=='\'') || (s[0]=='"' && s[len-1]=='"')))
  {
    s++;
    len -= 2;
  }
 
  /* skip trailing *spaces* (are these blanks?) if any. */
  while (len>0 && s[len-1]==' ')
    len--;
 
  *plength = len;
  return s;
}

References MODULE_SEP_STRING, and TOP_LEVEL_MODULE_NAME.

Referenced by fortran_string_compare().

Here is the caller graph for this function:

add_expression_p()

bool add_expression_p

(

expression

e

)

Test if an expression is an addition.

Definition at line 986 of file expression.c.

                                    {
  return operator_expression_p(e, PLUS_OPERATOR_NAME)
    || operator_expression_p(e, PLUS_C_OPERATOR_NAME)
    ;
}

References operator_expression_p(), PLUS_C_OPERATOR_NAME, and PLUS_OPERATOR_NAME.

Referenced by incrementation_expression_to_increment().

Here is the call graph for this function:

Here is the caller graph for this function:

add_integer_to_expression()

expression add_integer_to_expression	(	expression	exp,
		int	val
	)

Returns

a new expression that adds the an expression with an integer

Parameters

e,the	expression to add
n,the	integer to add

Parameters

exp	xp
val	al

Definition at line 2132 of file expression.c.

                                                               {
  return make_op_exp (PLUS_OPERATOR_NAME, exp, int_to_expression(val));
}

References exp, int_to_expression(), make_op_exp(), and PLUS_OPERATOR_NAME.

Referenced by do_linearize_array_reference(), and region_to_minimal_dimensions().

Here is the call graph for this function:

Here is the caller graph for this function:

add_subscript_to_reference()

reference add_subscript_to_reference	(	reference	r,
		expression	s
	)

Add a last subscript expression s to a reference r.

The validity of the input reference is not checked. The validity of the output reference is not checked either.

Definition at line 224 of file expression.c.

{
  reference_indices(r) = gen_nconc(reference_indices(r),
                                   CONS(EXPRESSION, s, NIL));
  return r;
}

References CONS, EXPRESSION, gen_nconc(), NIL, and reference_indices.

Referenced by substitute_struct_stub_in_transformer(), transformer_apply_field_assignments_or_equalities(), and transformer_apply_unknown_field_assignments_or_equalities().

Here is the call graph for this function:

Here is the caller graph for this function:

array_argument_p()

bool array_argument_p

(

expression

e

)

Definition at line 513 of file expression.c.

{
  if (expression_reference_p(e))
    {
      reference ref = expression_reference(e);
      entity ent = reference_variable(ref);
      if (array_entity_p(ent)) return true;
    }
  return false;
}

References array_entity_p(), expression_reference(), expression_reference_p(), ref, and reference_variable.

Referenced by interprocedural_abc_call(), xml_Argument(), xml_AssignArgument(), xml_Call(), and xml_Transposition().

Here is the call graph for this function:

Here is the caller graph for this function:

array_reference_p()

bool array_reference_p

(

reference

r

)

predicates on references

two possible meanings:

• the referenced variable is declared as an array
• the reference is to an array element

This makes a difference in procedure calls and IO statements

The second interpretation is chosen.

Definition at line 1861 of file expression.c.

{
  /* two possible meanings:
   * - the referenced variable is declared as an array
   * - the reference is to an array element
   *
   * This makes a difference in procedure calls and IO statements
   *
   * The second interpretation is chosen.
   */
 
  return reference_indices(r) != NIL;
}

References NIL, and reference_indices.

Referenced by array_to_constant_paths(), bottom_up_abc_reference(), bottom_up_abc_reference_implied_do(), dmas_invert_p(), expression_in_array_subscript(), initial_code_abc_reference(), and top_down_abc_flt().

Here is the caller graph for this function:

assignment_expression_p()

bool assignment_expression_p

(

expression

e

)

Test if an expression is an assignment operation.

Definition at line 979 of file expression.c.

                                           {
  return operator_expression_p(e, ASSIGN_OPERATOR_NAME);
}

References ASSIGN_OPERATOR_NAME, and operator_expression_p().

Referenced by expression_verbose_reduction_p_and_return_increment(), and step_directive_basic_workchunk_index().

Here is the call graph for this function:

Here is the caller graph for this function:

bool_to_expression()

expression bool_to_expression

(

bool

b

)

Definition at line 1238 of file expression.c.

{
    return MakeNullaryCall
        (MakeConstant(b ? TRUE_OPERATOR_NAME : FALSE_OPERATOR_NAME,
                      is_basic_logical));
}

References FALSE_OPERATOR_NAME, is_basic_logical, MakeConstant(), MakeNullaryCall(), and TRUE_OPERATOR_NAME.

Referenced by generate_all_liveness_but(), generate_dynamic_liveness_for_primary(), generate_prelude(), generate_remapping_guard(), and set_live_status().

Here is the call graph for this function:

Here is the caller graph for this function:

brace_expression_p()

bool brace_expression_p

(

expression

e

)

Return bool indicating if expression e is a brace expression.

Definition at line 3384 of file expression.c.

{
    if (expression_call_p(e))
    {
        entity f = call_function(syntax_call(expression_syntax(e)));
        if (ENTITY_BRACE_INTRINSIC_P(f))
            return true;
    }
    return false;
}

References call_function, ENTITY_BRACE_INTRINSIC_P, expression_call_p(), expression_syntax, f(), and syntax_call.

Referenced by brace_expression_to_statements(), brace_expression_to_updated_type(), c_brace_expression_string(), do_brace_expression_to_statements(), expression_is_C_rhs_p(), freia_extract_kernel(), st_brace_expression_as_string(), st_declaration_init(), this_entity_cdeclaration(), words_assign_op(), and words_variable_or_function().

Here is the call graph for this function:

Here is the caller graph for this function:

brace_expression_to_statements()

list brace_expression_to_statements	(	entity	arr,
		expression	e
	)

converts a brace expression used to initialize an array (not a struct yet) into a statement sequence

Parameters

arr

rr

Definition at line 3480 of file expression.c.

                                                              {
  pips_assert("is a brace expression\n",brace_expression_p(e));
  //SG: needs work to support structures
  // pips_assert("is an array\n",array_entity_p(arr));
  list curr_index = NIL;
  list out = do_brace_expression_to_statements(arr,e,curr_index);
  return out;
}

References brace_expression_p(), do_brace_expression_to_statements(), NIL, out, and pips_assert.

Referenced by split_initializations_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

brace_expression_to_updated_type()

void brace_expression_to_updated_type	(	entity	arr,
		expression	e
	)

use a brace expression to update the type of array "arr" if the dimensions are implicit

Parameters

arr

rr

Definition at line 3517 of file expression.c.

                                                                {
  pips_assert("is a brace expression\n",brace_expression_p(e));
  //SG: needs work to support structures
  //pips_assert("is an array\n",array_entity_p(arr));
  // type t = entity_basic_concrete_type(arr);
  type t = entity_type(arr);
  variable v = type_variable(t);
  list dl = variable_dimensions(v);
  do_brace_expression_to_updated_type(arr, e, dl);
}

References brace_expression_p(), do_brace_expression_to_updated_type(), entity_type, pips_assert, type_variable, and variable_dimensions.

Referenced by split_initializations_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

C_initialization_expression_p()

bool C_initialization_expression_p

(

expression

e

)

Definition at line 4056 of file expression.c.

{
  bool initialization_p = false;
  syntax s = expression_syntax(e);
  if(syntax_call_p(s)) {
    call c = syntax_call(s);
    entity f = call_function(c);
    if(ENTITY_BRACE_INTRINSIC_P(f))
      initialization_p = true;
  }
  return initialization_p;
}

References call_function, ENTITY_BRACE_INTRINSIC_P, expression_syntax, f(), syntax_call, and syntax_call_p.

Referenced by struct_assignment_to_points_to(), and struct_initialization_expression_to_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

cabs_expression_p()

bool cabs_expression_p

(

expression

e

)

Definition at line 1048 of file expression.c.

{
    return operator_expression_p(e, CABS_OPERATOR_NAME);
}

References CABS_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

call_constant_p()

bool call_constant_p

(

call

c

)

bool call_constant_p(call c): Returns true if "c" is a call to a constant, that is, a constant number or a symbolic constant.

Definition at line 1965 of file expression.c.

{
  value cv = entity_initial(call_function(c));
  return( (value_tag(cv) == is_value_constant) ||
          (value_tag(cv) == is_value_symbolic)   );
}

References call_function, entity_initial, is_value_constant, is_value_symbolic, and value_tag.

Referenced by logical_expression_to_transformer().

Here is the caller graph for this function:

call_equal_p()

bool call_equal_p	(	call	c1,
		call	c2
	)

Parameters

c1	1
c2	2

Definition at line 1529 of file expression.c.

{
  entity f1 = call_function(c1);
  entity f2 = call_function(c2);
  list args1 = call_arguments(c1);
  list args2 = call_arguments(c2);
 
  if(f1 != f2)
    return false;
 
  return gen_equals(args1,args2,(gen_eq_func_t)expression_equal_p);
 
  return true;
}

References call_arguments, call_function, expression_equal_p(), f2(), and gen_equals().

Referenced by syntax_equal_p().

Here is the call graph for this function:

Here is the caller graph for this function:

call_to_expression()

expression call_to_expression

(

call

c

)

Build an expression that call a function or procedure.

Parameters

c	is the call

Definition at line 309 of file expression.c.

{
  return make_expression(make_syntax(is_syntax_call, c),
                         normalized_undefined);
}

References is_syntax_call, make_expression(), make_syntax(), and normalized_undefined.

Referenced by add_exec_mmcd(), atom_cse_expression(), bound_to_statement(), call_nary_rwt(), call_to_transformer(), compute_constant(), do_point_to(), entity_to_expression(), expressions_to_operation(), float_to_expression(), freia_cleanup_status(), generate_compact(), generate_fifo_stat(), generate_mmcd_stat_from_ref(), get_fifoExp_from_ref(), gfc2pips_code2instruction_(), hwac_replace_statement(), if_different_pe_and_not_twin(), inline_statement_crawler(), int_to_expression(), inv_call_flt(), make_call_expression(), make_lInitStats(), make_loadsave_statement(), make_loop_step_stat(), make_lSwitchStats(), make_mmcd_load_store_stat(), make_read_write_fifo_stat(), make_send_receive_conversion(), make_step_inc_statement(), make_toggle_inc_statement(), make_transStat(), make_vecteur_expression(), MakeCaseStatement(), MakeForloopWithIndexDeclaration(), mpic_make_mpi_comm_rank(), mpic_make_mpi_comm_size(), mpic_make_mpi_finalize(), mpic_make_mpi_init(), mpic_make_mpi_irecv(), mpic_make_mpi_isend(), mpic_make_mpi_recv(), mpic_make_mpi_send(), new_local_image_variable(), pragma_build_if_condition(), pragma_if_as_expr(), process_innerStat1_proc(), replace_instruction_similar_to_pattern(), sesamify(), split_update_call(), and words_brace_op().

Here is the call graph for this function:

cast_equal_p()

bool cast_equal_p	(	cast	c1,
		cast	c2
	)

Parameters

c1	1
c2	2

Definition at line 1455 of file expression.c.

{
  return
    type_equal_p(cast_type(c1), cast_type(c2)) &&
    expression_equal_p(cast_expression(c1), cast_expression(c2));
}

References cast_expression, cast_type, expression_equal_p(), and type_equal_p().

Referenced by syntax_equal_p().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_all_normalized()

void clean_all_normalized

(

expression

e

)

Definition at line 4102 of file expression.c.

{
  gen_recurse(e, expression_domain, gen_true, expr_rwt);
}

References expr_rwt(), expression_domain, gen_recurse, and gen_true().

Referenced by abc_with_allocation_size(), alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_two_array_variables_in_caller(), alias_check_two_array_variables_in_module(), alias_check_two_scalar_variables_in_caller(), alias_check_two_scalar_variables_in_module(), bottom_up_abc_base_reference_implied_do(), bottom_up_abc_reference(), expression_equal_in_context_p(), impact_check_two_scalar_variables_in_path(), top_down_abc_dimension(), and translate_to_module_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

comma_expression_p()

bool comma_expression_p

(

expression

e

)

Definition at line 830 of file expression.c.

{
  bool result = false;
 
  if (expression_call_p(e)) {
    call c = syntax_call(expression_syntax(e));
    entity f = call_function(c);
 
    result = ENTITY_COMMA_P(f);
  }
 
  return result;
}

References call_function, ENTITY_COMMA_P, expression_call_p(), expression_syntax, f(), and syntax_call.

Referenced by any_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

complex_to_expression()

expression complex_to_expression	(	float	re,
		float	im
	)

Parameters

re	e
im	m

Definition at line 1234 of file expression.c.

{
    return MakeComplexConstantExpression(float_to_expression(re),float_to_expression(im));
}

References float_to_expression(), and MakeComplexConstantExpression().

Referenced by make_0val_expression(), and make_1val_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_bound_expression()

expression convert_bound_expression	(	expression	e,
		bool	upper_p,
		bool	non_strict_p
	)

Replace a C expression used as FOR bound by a Fortran DO bound expression, taking into account the C comparison operator used.

Fi this test is too strong to preserve source code

The offset might not be plus or minus one, unless we know the index is an integer? Does it depend on the step value? More thought needed than available tonight (FI)

The offset might not be plus or minus one, unless we know the index is an integer? Does it depend on the step value? More thought needed than available tonight (FI)

May modify the source code a bit more than necessary, but avoids stupid expressions such as 64-1-1

This could be generalized to any affine expression. See for instance loop_bound02.c. But the source code is likely to be disturbed if the bound expression is regenerated from v after adding or subtracting 1 from its constant term.

Parameters

upper_p	pper_p
non_strict_p	on_strict_p

Definition at line 2968 of file expression.c.

{
  expression b = expression_undefined;
 
  if(non_strict_p) {
    b = copy_expression(e);
  }
  else {
    /* */
    intptr_t ib = 0;
    intptr_t nb = 0;
 
    /* Fi this test is too strong to preserve source code */
    if(false && expression_integer_value(e, &ib)) {
      /* The offset might not be plus or minus one, unless we know the
         index is an integer? Does it depend on the step value? More
         thought needed than available tonight (FI) */
      nb = upper_p? ib-1 : ib+1;
      b = int_to_expression(nb);
    }
    else if(expression_constant_p(e)) {
      /* The offset might not be plus or minus one, unless we know the
         index is an integer? Does it depend on the step value? More
         thought needed than available tonight (FI) */
      ib = expression_to_int(e);
      nb = upper_p? ib-1 : ib+1;
      b = int_to_expression(nb);
    }
    else if(NORMALIZE_EXPRESSION(e), expression_linear_p(e)) {
      /* May modify the source code a bit more than necessary, but
         avoids stupid expressions such as 64-1-1 */
      normalized n = expression_normalized(e);
      Pvecteur v = normalized_linear(n);
      /* This could be generalized to any affine expression. See for
         instance loop_bound02.c. But the source code is likely to be
         disturbed if the bound expression is regenerated from v after
         adding or subtracting 1 from its constant term. */
      if(vect_constant_p(v) || VECTEUR_NUL_P(v)) {
        Value c = vect_coeff(TCST, v);
        ib = (int) c;
        nb = upper_p? ib-1 : ib+1;
        b = int_to_expression(nb);
      }
    }
    if(expression_undefined_p(b)) {
      expression offset = int_to_expression(1);
      entity op = entity_intrinsic(upper_p? MINUS_OPERATOR_NAME : PLUS_OPERATOR_NAME);
 
      b = MakeBinaryCall(op, copy_expression(e), offset);
    }
  }
  return b;
}

References copy_expression(), entity_intrinsic(), expression_constant_p(), expression_integer_value(), expression_linear_p(), expression_normalized, expression_to_int(), expression_undefined, expression_undefined_p, int, int_to_expression(), intptr_t, MakeBinaryCall(), MINUS_OPERATOR_NAME, NORMALIZE_EXPRESSION, normalized_linear, offset, PLUS_OPERATOR_NAME, TCST, vect_coeff(), vect_constant_p(), and VECTEUR_NUL_P.

Referenced by condition_expression_to_final_bound().

Here is the call graph for this function:

Here is the caller graph for this function:

dabs_expression_p()

bool dabs_expression_p

(

expression

e

)

Definition at line 1042 of file expression.c.

{
    return operator_expression_p(e, DABS_OPERATOR_NAME);
}

References DABS_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

davinci_dump_all_expressions()

void davinci_dump_all_expressions	(	FILE *	out,
		statement	s
	)

dump all expressions in s to out.

Parameters

out

ut

Definition at line 2728 of file expression.c.

{
  out_flt = out;
  gen_recurse(s, expression_domain, expr_flt, gen_null);
  out_flt = NULL;
}

References expr_flt(), expression_domain, gen_null(), gen_recurse, out, and out_flt.

Referenced by davinci_dump_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

davinci_dump_expression()

void davinci_dump_expression	(	FILE *	out,
		expression	e
	)

dump expression e in file out as a davinci graph.

Parameters

out

ut

Definition at line 2710 of file expression.c.

{
  hash_table seen = hash_table_make(hash_pointer, 0);
  fprintf(out, "[\n");
  davinci_dump_expression_rc(out, e, seen);
  fprintf(out, "]\n\n");
  hash_table_free(seen);
}

References davinci_dump_expression_rc(), fprintf(), hash_pointer, hash_table_free(), hash_table_make(), out, and seen.

Referenced by expr_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

davinci_dump_expression_rc()

static bool davinci_dump_expression_rc ( FILE *  out, expression  e, hash_table  seen  )

static

daVinci node prolog.

node epilog

Definition at line 2637 of file expression.c.

{
  syntax s;
  const char* name, *shape, *color;
  list sons = NIL;
  bool first = true, something = true;
 
  if (ALREADY_SEEN(e)) return false;
  SEEN(e);
 
  s = expression_syntax(e);
  switch (syntax_tag(s))
  {
  case is_syntax_call:
    {
      call c = syntax_call(s);
      name = entity_local_name(call_function(c));
      sons = call_arguments(c);
      shape = "";
      color = "";
      break;
    }
  case is_syntax_range:
    name = "::";
    shape = "";
    color = "";
    break;
  case is_syntax_cast: // ???
    name = "";
    shape = "";
    color = "";
    pips_user_warning("skipping cast\n");
    break;
  case is_syntax_reference:
    name = entity_local_name(reference_variable(syntax_reference(s)));
    shape = DV_CIRCLE;
    color = DV_YELLOW;
    break;
  default:
    name = "";
    shape = "";
    color = "";
    pips_internal_error("unexpected syntax tag (%d)", syntax_tag(s));
  }
 
    /* daVinci node prolog. */
  fprintf(out, "l(\"%zx\",n(\"\",[a(\"OBJECT\",\"%s\")%s%s],[",
          (_uint) e, name, color, shape);
 
  MAP(EXPRESSION, son,
  {
    if (!first) fprintf(out, ",\n");
    else { fprintf(out, "\n"); first=false; }
    fprintf(out, " l(\"%zx->%zx\",e(\"\",[],r(\"%zx\")))",
            (_uint) e, (_uint) son, (_uint) son);
  },
    sons);
 
    /* node epilog */
  fprintf(out, "]))\n");
 
  MAP(EXPRESSION, son,
  {
    if (something) fprintf(out, ",");
    something = davinci_dump_expression_rc(out, son, seen);
  }, sons);
 
  return true;
}

References ALREADY_SEEN, call_arguments, call_function, DV_CIRCLE, DV_YELLOW, entity_local_name(), EXPRESSION, expression_syntax, fprintf(), is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, MAP, NIL, out, pips_internal_error, pips_user_warning, reference_variable, seen, SEEN, syntax_call, syntax_reference, and syntax_tag.

Referenced by davinci_dump_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

dereference_expression()

expression dereference_expression

(

expression

e

)

generate a newly allocated expression for *(e)

Definition at line 3934 of file expression.c.

{
  if (expression_call_p(e))
  {
    call c = expression_call(e);
    if (ENTITY_ADDRESS_OF_P(call_function(c))) // e is "&x"
    {
      pips_assert("one arg to address operator (&)",
                  gen_length(call_arguments(c))==1);
 
      // result is simply "x"
      return copy_expression(EXPRESSION(CAR(call_arguments(c))));
    }
  }
 
  // result is "*e"
  return MakeUnaryCall(CreateIntrinsic(DEREFERENCING_OPERATOR_NAME),
                       copy_expression(e));
}

References call_arguments, call_function, CAR, copy_expression(), CreateIntrinsic(), DEREFERENCING_OPERATOR_NAME, ENTITY_ADDRESS_OF_P, EXPRESSION, expression_call(), expression_call_p(), gen_length(), MakeUnaryCall(), and pips_assert.

Referenced by switch_vertex_to_assign().

Here is the call graph for this function:

Here is the caller graph for this function:

divide_expression_p()

bool divide_expression_p

(

expression

e

)

Definition at line 1012 of file expression.c.

{
    return operator_expression_p(e, DIVIDE_OPERATOR_NAME);
}

References DIVIDE_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

do_brace_expression_to_statements()

static list do_brace_expression_to_statements ( entity  arr, expression  e, list  curr_indices  )

static

helper for brace_expression_to_statements

Definition at line 3396 of file expression.c.

                                                                                          {
  int new_index = 0;
  list out = NIL;
  FOREACH(EXPRESSION,arg,call_arguments(expression_call(e))) {
    // FI: we need to know the type of arr[curr_indices] to determine
    // if it is a struct or an array
 
    // A reference r is built temporarily to call reference_to_type()
    reference r = make_reference(arr, curr_indices);
    // FI: I have no idea if t should be freed; no documentation for
    // reference_to_type()
    type t = reference_to_type(r);
    reference_indices(r) = NIL;
    free_reference(r);
 
    expression ee = expression_undefined;
    if(array_type_p(t)) {
      ee = int_to_expression(new_index);
    }
    else if(type_struct_variable_p(t)) {
      list fl = struct_type_to_fields(t);
      entity f = ENTITY(gen_nth(new_index, fl));
      ee = entity_to_expression(f);
      // The field will appear as an index, not as a field selector
    }
    else
      pips_internal_error("Unexpected type.\n");
 
    list ind = gen_append(gen_full_copy_list(curr_indices),
                          make_expression_list(ee));
    if(brace_expression_p(arg)) {
      list out_bis = do_brace_expression_to_statements(arr, arg,ind);
      gen_full_free_list(ind);
      out = gen_append(out, out_bis);
    }
    else {
      reference r = make_reference(arr,NIL);
      expression e = reference_to_expression(r);
      // FI: the expression should be normalized and field subscripts
      // replaced by field accesses, with the field operator...
      FOREACH(expression, ie, ind) {
        if(expression_reference_p(ie)) {
          entity i = reference_variable(expression_reference(ie));
          if(entity_field_p(i)) {
            // FI: this is not going to work for structs of arrays...
            // expression ne = make_op_exp(FIELD_OPERATOR_NAME, e, ie);
            // expression ne = make_op_exp(FIELD_OPERATOR_NAME, e, ie);
            entity op = CreateIntrinsic(FIELD_OPERATOR_NAME);
            expression ne = MakeBinaryCall(op, e, ie);
            e = ne;
          }
          else
            pips_internal_error("Unexpected entity.\n");
        }
        else {
          // list ind is memory leaked...
          if(expression_reference_p(e)) {
            reference_indices(r) = gen_nconc(reference_indices(r),
                                             CONS(expression, ie, NIL));
          }
          else {
            subscript s = make_subscript(e, CONS(expression, ie, NIL));
            syntax ss = make_syntax_subscript(s);
            e = make_expression(ss, normalized_undefined);
            //entity op = CreateIntrinsic(SUBSCRIPT_OPERATOR_NAME);
            //expression ne = MakeBinaryCall(op, e, ie);
            //e = ne;
          }
        }
      }
      gen_free_list(ind);
      out = gen_append(out,make_statement_list(
            make_assign_statement(e, copy_expression(arg))
            )
          );
    }
    ++new_index;
  }
  return out;
}

References array_type_p(), brace_expression_p(), call_arguments, CONS, copy_expression(), CreateIntrinsic(), ENTITY, entity_field_p(), entity_to_expression(), EXPRESSION, expression_call(), expression_reference(), expression_reference_p(), expression_undefined, f(), FIELD_OPERATOR_NAME, FOREACH, free_reference(), gen_append(), gen_free_list(), gen_full_copy_list(), gen_full_free_list(), gen_nconc(), gen_nth(), int_to_expression(), make_assign_statement(), make_expression(), make_expression_list, make_reference(), make_statement_list, make_subscript(), make_syntax_subscript(), MakeBinaryCall(), NIL, normalized_undefined, out, pips_internal_error, reference_indices, reference_to_expression(), reference_to_type(), reference_variable, struct_type_to_fields(), and type_struct_variable_p().

Referenced by brace_expression_to_statements().

Here is the call graph for this function:

Here is the caller graph for this function:

do_brace_expression_to_updated_type()

static void do_brace_expression_to_updated_type ( entity  arr, expression  e, list  dl  )

static

helper for brace_expression_to_updated_type

Side-effect on dl, the dimension list of e's type

Definition at line 3493 of file expression.c.

{
  dimension d = DIMENSION(CAR(dl));
  expression u = dimension_upper(d);
  if(unbounded_expression_p(u)) {
    list al = call_arguments(expression_call(e));
    int nu = (int) gen_length(al) -1 ;
    expression nue = int_to_expression(nu);
    dimension_upper(d) = nue;
    free_expression(u);
    if(!ENDP(CDR(dl))) {
      // This is probably useless because only the first dimension can
      // be undefined
      expression se = EXPRESSION(CAR(al));
      do_brace_expression_to_updated_type(arr, se, CDR(dl));
    }
  }
}

References call_arguments, CAR, CDR, DIMENSION, dimension_upper, ENDP, EXPRESSION, expression_call(), free_expression(), gen_length(), int, int_to_expression(), and unbounded_expression_p().

Referenced by brace_expression_to_updated_type().

Here is the call graph for this function:

Here is the caller graph for this function:

do_simplify_expressions()

static void do_simplify_expressions ( call  c )

static

Definition at line 3794 of file expression.c.

                                            {
    for(list iter = call_arguments(c);!ENDP(iter);POP(iter)) {
        expression *pexp = (expression*)REFCAR(iter);
        simplify_expression(pexp);
    }
}

References call_arguments, ENDP, POP, REFCAR, and simplify_expression().

Referenced by simplify_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

entity_to_expression()

expression entity_to_expression

(

entity

e

)

if v is a constant, returns a constant call.

if v is a variable, returns a reference to v.

should be a scalar variable!

Definition at line 165 of file expression.c.

{
  if(entity_symbolic_p(e))
    return call_to_expression(make_call(e, NIL));
  else if (entity_constant_p(e))
    return call_to_expression(make_call(e, NIL));
  else /* should be a scalar variable! */
    return reference_to_expression(make_reference(e, NIL));
}

References call_to_expression(), entity_constant_p, entity_symbolic_p, make_call(), make_reference(), NIL, and reference_to_expression().

Referenced by add_actual_return_code(), add_exec_mmcd(), add_index_out_effect_proc(), add_pragma_to_sequence(), adg_dataflowgraph_with_extremities(), adg_enrichir(), adg_rename_entities(), any_basic_update_operation_to_transformer(), any_update_to_transformer_list(), atom_cse_expression(), buffer_full_condition(), build_call_STEP_AllToAll(), build_call_STEP_init_regionArray(), build_call_STEP_set_recvregions(), build_call_STEP_set_sendregions(), c_convex_effects_on_actual_parameter_forward_translation(), C_MakeReturnStatement(), call_STEP_subroutine(), call_STEP_subroutine3(), comEngine_generate_procCode(), compile_master(), compile_one_reduction(), compile_reduction(), compute_HRE_memory_mapping(), compute_points_to_binded_set(), compute_region(), controlize_distribution(), ctx_generate_new_statement_cluster_dependant(), declaration_statement_to_points_to(), declaration_to_post_pv(), define_node_processor_id(), derived_formal_parameter_to_stub_points_to(), dimensions_to_dma(), distribute_code(), do_array_to_pointer_walk_expression(), do_atomize_call(), do_brace_expression_to_statements(), do_clone_statement(), do_gather_all_expressions(), do_group_constants_terapix(), do_loop_expansion(), do_loop_nest_unswitching(), do_loop_to_for_loop(), do_loop_to_while_loop(), do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), do_outliner_smart_replacment(), do_point_to(), do_scalar_renaming_in_successors(), do_solve_hardware_constraints_on_volume(), do_split_structure(), do_symbolic_tiling(), do_terapix_argument_handler(), entities_to_expressions(), entities_to_expressions2(), expression_multiply_sizeof_to_transformer(), find_or_create_allocatable_struct(), fix_loop_index_sign(), for_to_do_loop_conversion(), freia_add_image_arguments(), freia_copy_image(), full_loop_unroll(), fusion(), fusion_buffer(), gen_if_rank(), Generate_C_ReturnStatement(), generate_call_compute_loopslices(), generate_call_get_commsize(), generate_call_get_rank(), generate_call_get_rank_loopbounds(), generate_call_get_workchunk_loopbounds(), generate_call_set_regionarray(), generate_code_loop(), generate_exec_statement(), generate_fifo_stat(), generate_fifo_stat2(), generate_ind_fifo_stat2(), generate_load_statement(), generate_loop_workchunk(), generate_mmcd_stat_from_ref(), generate_optimized_code_for_loop_nest(), generate_parallel_body(), generate_return_code_checks(), generate_save_statement(), generate_subarray_shift(), get_allocatable_data_expr(), get_fifoExp_from_ref(), get_indExp_from_ref(), gfc2pips_int2expression(), gfc2pips_logical2expression(), gfc2pips_real2expression(), gfc2pips_symbol2data_instruction(), hpfc_add_n(), hpfc_broadcast_buffers(), hpfc_broadcast_if_necessary(), hpfc_buffer_reference(), hpfc_compute_lid(), hpfc_gen_n_vars_expr(), hpfc_generate_message(), hpfc_hmessage(), hpfc_initsend(), hpfc_lazy_buffer_packing(), hpfc_lazy_guard(), hpfc_message(), hpfc_translate_call_with_distributed_args(), if_different_pe_and_not_twin(), image_free(), initialize_scalar_variable(), inline_expression_call(), inline_return_crawler(), inline_split_declarations(), insert_check_alias_before_statement(), intrinsic_call_to_points_to(), isolate_patch_reference(), loop_bound_evaluation_to_transformer(), loop_flt(), loop_rewrite(), loop_strip_mine(), loopbounds_substitution(), make_array_communication_statement(), make_assignement_statement(), make_body_from_loop(), make_C_print_statement(), make_communication_statement(), make_condition_from_loop(), make_dma_transfert(), make_exec_mmcd(), make_expression_with_state_variable(), make_factor_expression(), make_fields_assignment_instruction(), make_guard_expression(), make_increment_statement(), make_init_newInd_stat(), make_initialization_from_loop(), make_lInitStats(), make_loop_nest_for_overlap(), make_loop_step_stat(), make_loopStat1(), make_lSwitchStats(), make_mmcd_load_store_stat(), make_mmcd_stats_from_ref(), make_read_loopbody(), make_scalar_communication_module(), make_scanning_over_tiles(), make_send_receive_conversion(), make_set_rc_statement(), make_shuffle_statement(), make_start_ru_module(), make_state_variable_assignement_statement(), make_step_inc_statement(), make_temporary_scalar_entity(), make_toggle_inc_statement(), make_toggle_init_statement(), make_toggle_mmcd(), make_transStat(), MakeAssignedGotoInst(), MakeAssignedOrComputedGotoInst(), MakeDoInst(), modulo_to_transformer(), monome_to_expression(), move_declaration_control_node_declarations_to_statement(), mpi_initialize(), mpic_make_mpi_comm_rank(), mpic_make_mpi_comm_size(), mpic_make_mpi_finalize(), mpic_make_mpi_init(), mpic_make_mpi_irecv(), mpic_make_mpi_isend(), mpic_make_mpi_recv(), mpic_make_mpi_send(), mppa_compile_dag(), mppa_helper_args_params(), mylid_ne_lid(), new_local_image_variable(), normalize_microcode(), outliner_extract_loop_bound(), outliner_parameters(), outliner_patch_parameters(), perform_array_element_substitutions_in_transformer(), pointer_values_remove_var(), process_innerStat1_proc(), process_opt_replace(), Pvecteur_to_assign_statement(), reference_add_field_dimension(), reference_to_points_to(), regenerate_toggles(), region_to_address(), regions_to_loops(), rename_statement_declarations(), replace_field_by_reference_walker(), replace_indices_region(), replace_indices_region_com(), sc_delimiter(), scalar_to_array(), scalopify(), sequence_to_post_pv(), sesamify(), set_aipo_call(), simd_atomize_this_expression(), simd_loop_unroll(), simple_reference_add_field_dimension(), simplify_subscript(), split_complex_expression(), split_initializations_in_statement(), st_generate_packing(), statement_compute_bounds(), step_symbolic_expression(), string_to_expression(), struct_initialization_to_points_to(), struct_variable_to_pointer_locations(), struct_variable_to_pointer_subscripts(), substitute_struct_stub_in_transformer(), systeme_to_loop_nest(), terapix_loop_handler(), transformer_apply_field_assignments_or_equalities(), transformer_apply_unknown_field_assignments_or_equalities(), translate_to_module_frame(), typedef_formal_parameter_to_stub_points_to(), unsugared_loop_header(), unsugared_loop_inc(), unsugared_loop_test(), update_indices_for_local_computation(), update_reflhs_with_rhs_to_transformer(), usual_loop_tiling(), and verify_scalar_variable().

Here is the call graph for this function:

expr_flt()

static bool expr_flt ( expression  e )

static

Definition at line 2720 of file expression.c.

{
  davinci_dump_expression(out_flt, e);
  return false;
}

References davinci_dump_expression(), and out_flt.

Referenced by davinci_dump_all_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

expr_rwt()

static void expr_rwt ( expression  e )

static

hack: clean all normalize fields...

Definition at line 4093 of file expression.c.

{
  if (!normalized_undefined_p(expression_normalized(e)))
  {
    free_normalized(expression_normalized(e));
    expression_normalized(e) = normalized_undefined;
  }
}

References expression_normalized, free_normalized(), normalized_undefined, and normalized_undefined_p.

Referenced by clean_all_normalized().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_address_of_p()

bool expression_address_of_p

(

expression

e

)

Definition at line 420 of file expression.c.

{
  bool address_p = false;
  syntax s = expression_syntax(e);
  if(syntax_call_p(s)) {
    call c = syntax_call(s);
    entity f = call_function(c);
    if(ENTITY_ADDRESS_OF_P(f))
      address_p = true;
  }
  return address_p;
}

References call_function, ENTITY_ADDRESS_OF_P, expression_syntax, f(), syntax_call, and syntax_call_p.

Referenced by freia_reduction_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_application()

application expression_application

(

expression

e

)

Definition at line 485 of file expression.c.

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

References expression_syntax, and syntax_application.

Referenced by expression_to_transformer().

Here is the caller graph for this function:

expression_application_p()

bool expression_application_p

(

expression

e

)

Duplicate bool expression_subscript_p(expression e) { return(syntax_subscript_p(expression_syntax(e))); }.

subscript expression_subscript(expression e) { return(syntax_subscript(expression_syntax(e))); }

Definition at line 480 of file expression.c.

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

References expression_syntax, and syntax_application_p.

Referenced by expression_to_transformer().

Here is the caller graph for this function:

expression_brace_p()

bool expression_brace_p

(

expression

e

)

predicates and short cut accessors on expressions

Definition at line 407 of file expression.c.

                                      {
    if(expression_call_p(e)) {
        call c = expression_call(e);
        return ENTITY_BRACE_INTRINSIC_P(call_function(c));
    }
    return false;
}

References call_function, ENTITY_BRACE_INTRINSIC_P, expression_call(), and expression_call_p().

Referenced by do_convert_this_array_to_pointer_p().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_call()

call expression_call

(

expression

e

)

Definition at line 445 of file expression.c.

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

References expression_syntax, and syntax_call.

Referenced by address_of_scalar(), any_expression_to_transformer(), atomize_call(), atomize_call_filter(), atomize_call_statement(), atomize_this_expression(), cleanup_subscript_pre(), compact_phi_functions(), compute_points_to_binded_set(), copy_from_statement(), copy_to_statement(), dereference_expression(), distance_between_expression(), do_array_to_pointer_patch_call_expression(), do_brace_expression_to_statements(), do_brace_expression_to_updated_type(), do_expression_reduction(), do_group_constant_entity(), do_linearize_array_init(), do_linearize_array_manage_callers(), do_linearize_prepatch_subscript(), do_linearize_remove_dereferencment_walker(), do_loop_nest_unswitching(), do_reduction_detection(), do_reduction_propagation(), do_simplify_constant_address_expression(), do_split_structure(), do_split_structure_return_hook_walker(), expr_cse_flt(), expression_allocatable_data_access_p(), expression_brace_p(), expression_equal_or_opposite_p(), expression_field_p(), expression_minmax_p(), expression_opposite_p(), expression_string_constant(), expression_string_constant_p(), expression_to_transformer(), filter_variables_in_pragma_expr(), find_entities_to_wrap(), for_to_do_loop_conversion(), freia_alloc_stat_p(), freia_reduction_variable(), get_complement_expression(), guess_late_read_effect_on_entity(), guess_loop_increment(), guess_loop_increment_walker(), guess_loop_lower_bound(), initialization_list_to_statements(), make_address_of_expression(), make_loadsave_statement(), make_send_receive_conversion(), pragma_omp_merge_expr(), pragma_omp_p(), pragma_PRAGMA_DISTRIBUTED_p(), reference_filter(), remove_expression_from_comma_list(), remove_simple_scalar_pointers(), remove_unread_variable(), reorder_pointer_expression(), replace_entity_by_expression_expression_walker(), replace_instruction_similar_to_pattern(), rssp_ref(), simplify_complex_expression(), simplify_minmax_expression(), skip_field_and_cast_expression(), statement_has_omp_parallel_directive_p(), statement_phi_function_p(), statement_remove_omp_clauses(), terapix_loop_optimizer(), terapix_normalize_tests(), terapixify_loops(), two_addresses_code_generator(), two_addresses_code_generator_split_p(), user_function_call_to_transformer(), and zero_expression_p().

expression_call_p()

bool expression_call_p

(

expression

e

)

Definition at line 415 of file expression.c.

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

References expression_syntax, and syntax_call_p.

Referenced by actual_label_replacement_p(), address_of_scalar(), alloc_instrumentation(), any_expression_to_transformer(), atomize_call(), atomize_call_filter(), atomize_call_statement(), atomize_this_expression(), brace_expression_p(), c_brace_expression_p(), change_basic_if_needed(), cleanup_subscript_pre(), comma_expression_p(), complex_constant_expression_p(), compute_points_to_binded_set(), condition_to_transformer(), controlize_statement(), copy_from_statement(), copy_to_statement(), dereference_expression(), do_array_to_pointer_patch_call_expression(), do_expression_reduction(), do_group_constant_entity(), do_linearize_array_init(), do_linearize_array_manage_callers(), do_linearize_prepatch_subscript(), do_linearize_remove_dereferencment_walker(), do_reduction_detection(), do_reduction_propagation(), do_simplify_constant_address_expression(), expr_flt(), expression_allocatable_data_access_p(), expression_brace_p(), expression_field_p(), expression_implied_do_p(), expression_list_directed_p(), expression_minmax_p(), expression_reference_number(), expression_string_constant_p(), expression_to_int(), expression_to_transformer(), expression_try_find_size(), find_entities_to_wrap(), find_implicit_goto(), find_target_position(), freia_alloc_stat_p(), get_complement_expression(), guess_late_read_effect_on_entity(), guess_loop_increment(), guess_loop_increment_walker(), guess_loop_lower_bound(), initialization_list_to_statements(), inline_expression(), interprocedural_abc_expression(), is_this_op(), logical_operator_expression_p(), make_address_of_expression(), MakeReturn(), number_of_initial_values(), number_of_operators_flt(), parser_macro_expansion(), pragma_omp_p(), pragma_PRAGMA_DISTRIBUTED_p(), process_static_initialization(), reference_filter(), regenerate_call(), relational_expression_p(), remove_expression_from_comma_list(), remove_unread_variable(), reorder_pointer_expression(), replace_entity_by_expression_expression_walker(), replace_subscript(), rssp_ref(), sentence_data_statement(), simplify_complex_expression(), SizeOfArray(), statement_has_omp_parallel_directive_p(), statement_phi_function_p(), statement_remove_omp_clauses(), store_initial_value(), switch_specific_cmplx(), switch_specific_dcmplx(), terapix_loop_optimizer(), terapix_normalize_tests(), terapixify_loops(), two_addresses_code_generator(), two_addresses_code_generator_split_p(), words_assign_op(), words_dimension(), words_infix_binary_op(), words_infix_nary_op(), words_regular_call(), words_subexpression(), and zero_expression_p().

expression_cast()

cast expression_cast

(

expression

e

)

Definition at line 455 of file expression.c.

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

References expression_syntax, and syntax_cast.

Referenced by condition_to_transformer(), expression_null_p(), expression_to_transformer(), MakeCaseStatement(), and words_subexpression().

Here is the caller graph for this function:

expression_cast_p()

bool expression_cast_p

(

expression

e

)

Definition at line 450 of file expression.c.

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

References expression_syntax, and syntax_cast_p.

Referenced by condition_to_transformer(), expression_null_p(), expression_to_transformer(), MakeCaseStatement(), and words_subexpression().

Here is the caller graph for this function:

expression_constant()

constant expression_constant

(

expression

exp

)

This function returns a "constant" object if the expression is a constant such as 10, -11 or 2.345 or "foo".

Expressions such as "5+0" or "sizeof(int)" or "m", with m defined as "const int m = 2;" or "M" with M defined as PARAMETER do not qualify. However their value is constant, i.e. store independent, and can be evaluated using EvalExpression().

FI: difficult to make a decision here. We may have a constant expression that cannot be evaluated as a constant statically by PIPS. What is the semantics of expression_constant_p()?

&& get_bool_property("EVAL_SIZEOF")

Too bad we need a function located in eval.c ...

Might be a reference to a scalar constant.

Parameters

exp

xp

Definition at line 2347 of file expression.c.

{
  syntax s = expression_syntax(exp);
  if(syntax_call_p(s))
    {
      call c = syntax_call(expression_syntax(exp));
      value v = entity_initial(call_function(c));
      switch(value_tag(v))
        {
        case is_value_constant:
          return value_constant(v);
        case is_value_intrinsic: {
          entity op = call_function(c);
          if(ENTITY_UNARY_MINUS_P(op)||ENTITY_UNARY_PLUS_P(op))
            return expression_constant(binary_call_lhs(c));
        }
        default:
          ;
        }
    }
  else if(false && syntax_sizeofexpression_p(s)) {
    sizeofexpression soe = syntax_sizeofexpression(s);
    /* FI: difficult to make a decision here. We may have a constant
       expression that cannot be evaluated as a constant statically by
       PIPS. What is the semantics of expression_constant_p()?  */
    if(sizeofexpression_type_p(soe) /* && get_bool_property("EVAL_SIZEOF")*/ ) {
      /* Too bad we need a function located in eval.c ... */
      value v = EvalSizeofexpression(soe);
      if(value_constant_p(v)) { // Should always be true...
        constant c = value_constant(v);
        value_constant(v) = constant_undefined;
        free_value(v);
        return c;
      }
    }
  }
  else if(false && syntax_reference_p(s)) {
    /* Might be a reference to a scalar constant. */
    reference r = syntax_reference(s);
    entity v = reference_variable(r);
    if(const_variable_p(v)) {
      value val = entity_initial(v);
      if(value_constant_p(val)) {
        constant c = copy_constant(value_constant(val));
        return c;
      }
    }
  }
  return constant_undefined;
}

References binary_call_lhs, call_function, const_variable_p(), constant_undefined, copy_constant(), entity_initial, ENTITY_UNARY_MINUS_P, ENTITY_UNARY_PLUS_P, EvalSizeofexpression(), exp, expression_syntax, free_value(), is_value_constant, is_value_intrinsic, reference_variable, sizeofexpression_type_p, syntax_call, syntax_call_p, syntax_reference, syntax_reference_p, syntax_sizeofexpression, syntax_sizeofexpression_p, value_constant, value_constant_p, and value_tag.

Referenced by expression_constant_p(), and words_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_constant_p()

bool expression_constant_p

(

expression

exp

)

================================================================

Overlap Management Module for HPFC Fabien Coelho, August 1993.

HPFC module by Fabien COELHO.

bool expression_constant_p(expression exp) Returns true if "exp" is an (integer) constant value.

Note : A negativePositive constant can be represented with a call to the unary minus/plus intrinsic function upon a positive value.

See below extended_expression_constant_p() for a more general function.

Parameters

exp

xp

Definition at line 2453 of file expression.c.

{
  return !constant_undefined_p(expression_constant(exp));
}

References constant_undefined_p, exp, and expression_constant().

Referenced by add_const_expr_p(), analyze_expression(), array_indices_check(), array_size_stride(), atom_cse_expression(), atomize_this_expression(), compute_final_index_value(), constant_step_loop_p(), constraints_to_loop_bound(), convert_bound_expression(), do_loop_expansion(), do_loop_expansion_init(), do_solve_hardware_constraints_on_volume(), effect_field_dimension_entity(), equal_must_vreference(), expression_equal_integer_p(), expression_null_p(), expression_plusplus(), expression_string_constant_p(), expression_to_float(), expression_to_int(), expression_to_polynome(), expression_try_find_size(), formal_variable_add_aliases(), freia_insert_added_stats(), have_null_value_in_pointer_expression_p(), incrementation_expression_to_increment(), inline_expression_call(), loop_annotate(), loop_normalize_of_loop(), make_loadsave_statement(), make_max_exp(), make_send_receive_conversion(), MakeCaseStatement(), MakeEquivAtom(), malloc_arg_to_type(), normalizable_loop_p(), opkill_may_vreference(), opkill_must_vreference(), overlap_redefine_expression(), plc_make_dim(), points_to_compare_cell(), points_to_compare_cells(), points_to_compare_location(), points_to_compare_ptr_cell(), process_true_call_stat(), rational_op_exp(), references_do_not_conflict_p(), replace_subscript(), simplify_C_expression(), size_of_actual_array(), size_of_dummy_array(), sp_feautrier_expression_p(), splc_feautrier_expression_p(), stmt_bdt_directions(), subscript_value(), subscript_value_stride(), terapixify_loops(), valuer(), and words_dimension().

Here is the call graph for this function:

expression_equal_in_list_p()

bool expression_equal_in_list_p	(	expression	e,
		list	le
	)

This function returns true, if there exists an expression equal in the list false, otherwise.

Parameters

le

e

Definition at line 566 of file expression.c.

{
  MAP(EXPRESSION, f, if (expression_equal_p(e,f)) return true, le);
  return false;
}

References EXPRESSION, expression_equal_p(), f(), and MAP.

Referenced by pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_equal_integer_p()

bool expression_equal_integer_p	(	expression	exp,
		int	i
	)

================================================================

bool expression_equal_integer_p(expression exp, int i): returns true if "exp" is a constant value equal to "i".

Parameters

exp

xp

Definition at line 1977 of file expression.c.

{
  pips_debug(7, "doing\n");
  if(expression_constant_p(exp))
    return(expression_to_int(exp) == i);
  return(false);
}

References exp, expression_constant_p(), expression_to_int(), and pips_debug.

Referenced by alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_two_array_variables_in_caller(), alias_check_two_array_variables_in_module(), c_reference(), formal_variable_add_aliases(), make_op_exp(), pointer_type_array_p(), ram_variable_add_aliases(), rational_op_exp(), same_dimension_p(), same_or_equivalence_argument_add_aliases(), set_array_declaration(), splc_positive_relation_p(), storage_formal_offset(), storage_ram_offset(), subscript_value_stride(), and translate_to_module_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_equal_or_opposite_p()

bool expression_equal_or_opposite_p	(	expression	e1,
		expression	e2
	)

e1==e2 or -e1==e2 or e1==-e2 syntactically

Parameters

e1	1
e2	2

Definition at line 1366 of file expression.c.

{
  bool equal_or_opposite_p = false;
  if(expression_equal_p(e1,e2)) {
    equal_or_opposite_p = true;
  }
  else if(unary_intrinsic_expression(UNARY_MINUS_OPERATOR_NAME, e1)) {
    call c1 = expression_call(e1);
    expression e11 = EXPRESSION(CAR(call_arguments(c1)));
    equal_or_opposite_p = expression_equal_p(e11, e2);
  }
  else if(unary_intrinsic_expression(UNARY_MINUS_OPERATOR_NAME, e2)) {
    call c2 = expression_call(e2);
    expression e22 = EXPRESSION(CAR(call_arguments(c2)));
    equal_or_opposite_p = expression_equal_p(e1, e22);
  }
  return  equal_or_opposite_p;
}

References call_arguments, CAR, EXPRESSION, expression_call(), expression_equal_p(), unary_intrinsic_expression, and UNARY_MINUS_OPERATOR_NAME.

Here is the call graph for this function:

expression_equal_p()

bool expression_equal_p	(	expression	e1,
		expression	e2
	)

Syntactic equality e1==e2.

Add expression_undefined tests to avoid segmentation fault

let's assume that every expression has a correct syntax component

Parameters

e1	1
e2	2

Definition at line 1347 of file expression.c.

{
  syntax s1, s2;
 
  /* Add expression_undefined tests to avoid segmentation fault */
 
  if (expression_undefined_p(e1) && expression_undefined_p(e2))
    return true;
  if (expression_undefined_p(e1) || expression_undefined_p(e2))
    return false;
 
  /* let's assume that every expression has a correct syntax component */
  s1 = expression_syntax(e1);
  s2 = expression_syntax(e2);
 
  return syntax_equal_p(s1, s2);
}

References expression_syntax, expression_undefined_p, s1, and syntax_equal_p().

Referenced by bitwise_xor_to_transformer(), bottom_up_abc_base_reference_implied_do(), call_equal_p(), cast_equal_p(), compact_phi_functions(), compatible_points_to_subscripts_p(), convex_cell_reference_preceding_p(), dimension_equal_p(), do_expressions_to_vector(), effect_comparable_p(), effect_may_union(), effect_must_union(), expr_rwt(), expression_eq_in_list_p(), expression_equal_in_list_p(), expression_equal_or_opposite_p(), expression_flt(), expression_lists_equal_p(), expression_opposite_p(), find_equal_expression_not_in_list(), forward_substitute_array_location_in_transformer(), generic_basic_equal_p(), integer_multiply_to_transformer(), lexpression_equal_p(), loop_rewrite(), lrange_larger_p(), make_permutations_indexes(), make_simd_statement(), opkill_may_vreference(), opkill_must_vreference(), partial_eval_plus_or_minus_operator(), points_to_reference_included_p(), range_equal_p(), reference_equal_p(), reference_to_points_to_translations(), references_must_conflict_p(), same_alignment_in_list_p(), same_alignment_p(), same_distribute_p(), same_distribution_p(), same_expression_p(), similarity(), simple_cell_reference_preceding_p(), simple_cells_inclusion_p(), simple_cells_intersection_p(), simple_pv_may_union(), simple_pv_must_union(), sizeofexpression_equal_p(), subscript_equal_p(), switch_vertex_to_assign(), terapix_loop_optimizer(), terapixify_loops(), two_addresses_code_generator(), and update_vector_to_expressions().

Here is the call graph for this function:

expression_field_p()

bool expression_field_p

(

expression

e

)

The expression is of kind "s.a", where "s" is a struct and a "a" field.

Definition at line 491 of file expression.c.

{
  return expression_call_p(e)
    && ENTITY_FIELD_P(call_function(expression_call(e)));
}

References call_function, ENTITY_FIELD_P, expression_call(), and expression_call_p().

Referenced by adapt_reference_to_type(), distance_between_expression(), expression_reference_or_field_p(), make_loadsave_statement(), replace_subscript(), and skip_field_and_cast_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_implied_do_p()

bool expression_implied_do_p

(

e

)

Definition at line 817 of file expression.c.

{
    if (expression_call_p(e)) {
        call c = syntax_call(expression_syntax(e));
        entity e = call_function(c);
 
        return(strcmp(entity_local_name(e), IMPLIED_DO_NAME) == 0);
    }
 
    return(false);
}

References call_function, entity_local_name(), expression_call_p(), expression_syntax, IMPLIED_DO_NAME, and syntax_call.

Referenced by bottom_up_abc_expression(), bottom_up_abc_expression_implied_do(), comp_regions_of_implied_do(), comp_regions_of_iolist(), expression_in_array_subscript(), FortranExpressionList(), initial_code_abc_expression(), MakeFortranBinaryCall(), and MakeFortranUnaryCall().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_integer_constant_p()

bool expression_integer_constant_p

(

expression

e

)

I hope a short evaluation is made by the compiler

Definition at line 2417 of file expression.c.

{
    syntax s = expression_syntax(e);
    normalized n = expression_normalized(e);
 
    if ((n!=normalized_undefined) && (normalized_linear_p(n)))
    {
        Pvecteur v = normalized_linear(n);
        int s = vect_size(v);
 
        if (s==0) return(true);
        if (s>1) return(false);
        return((s==1) && value_notzero_p(vect_coeff(TCST,v)));
    }
    else
    if (syntax_call_p(s))
    {
        call c = syntax_call(s);
        value v = entity_initial(call_function(c));
 
        /* I hope a short evaluation is made by the compiler */
        return((value_constant_p(v)) && (constant_int_p(value_constant(v))));
    }
    
    return(false);
}

References call_function, constant_int_p, entity_initial, expression_normalized, expression_syntax, normalized_linear, normalized_linear_p, normalized_undefined, syntax_call, syntax_call_p, TCST, value_constant, value_constant_p, value_notzero_p, vect_coeff(), and vect_size().

Referenced by array_access_to_array_ranges(), do_solve_hardware_constraints_on_volume(), generate_optimized_code_for_loop_nest(), hpfc_decision(), loop_flt(), and points_to_reference_to_type().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_intrinsic_operation_p()

bool expression_intrinsic_operation_p

(

expression

exp

)

bool expression_intrinsic_operation_p(expression exp): Returns true if "exp" is an expression with a call to an intrinsic operation.

Parameters

exp

xp

Definition at line 1949 of file expression.c.

{
  entity e;
  syntax syn = expression_syntax(exp);
 
  if (syntax_tag(syn) != is_syntax_call)
    return (false);
 
  e = call_function(syntax_call(syn));
 
  return(value_tag(entity_initial(e)) == is_value_intrinsic);
}

References call_function, entity_initial, exp, expression_syntax, is_syntax_call, is_value_intrinsic, syntax_call, syntax_tag, and value_tag.

Referenced by atomizer_of_test().

Here is the caller graph for this function:

expression_is_C_rhs_p()

bool expression_is_C_rhs_p

(

expression

exp

)

Not all expressions can be used as right-hand side (rhs) in C assignments.

PIPS expressions used to encode initializations such as

"{ 1, 2, 3}"

in

"int k[] = { 1, 2, 3 };" cannot be used as rhs.

There are probably many more cases, especially with Fortran-specific expressions, e.g. IO expressions. But we do not have a way to know if an intrinsic is a Fortran or a C or a shared intrinsic. The information is not carried by PIPS internal representation and hence not initialized in bootstrap.

Note: this test is too restrictive as the condition depends on the type of the lhs. A struct can be assigned a brace expression. So a type argument should be passed to make such decisions.

"s = { 1, 2, 3};" is ok if s is a struct with three integer compatible fields.

Parameters

exp

xp

Definition at line 2582 of file expression.c.

{
  bool is_rhs_p = false;
 
  is_rhs_p = !brace_expression_p(exp);
 
  return is_rhs_p;
}

References brace_expression_p(), and exp.

Referenced by redeclaration_enter_statement(), and split_initializations_in_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_list_directed_p()

bool expression_list_directed_p

(

e

)

Definition at line 844 of file expression.c.

{
    if (expression_call_p(e)) {
        call c = syntax_call(expression_syntax(e));
        entity e = call_function(c);
 
        return(strcmp(entity_local_name(e), LIST_DIRECTED_FORMAT_NAME) == 0);
    }
 
    return(false);
}

References call_function, entity_local_name(), expression_call_p(), expression_syntax, LIST_DIRECTED_FORMAT_NAME, and syntax_call.

Here is the call graph for this function:

expression_list_to_binary_operator_call()

expression expression_list_to_binary_operator_call	(	list	l,
		entity	op
	)

Parameters

op

p

Definition at line 1917 of file expression.c.

{
  int
    len = gen_length(l);
  expression
    result = expression_undefined;
 
  pips_assert("list_to_binary_operator_call", len!=0);
 
  result = EXPRESSION(CAR(l));
 
  MAPL(ce,
       {
         result = MakeBinaryCall(op, EXPRESSION(CAR(ce)), result);
       },
       CDR(l));
 
  return(result);
}

References CAR, CDR, EXPRESSION, expression_undefined, gen_length(), MakeBinaryCall(), MAPL, and pips_assert.

Referenced by compute_region(), expression_list_to_conjonction(), and top_down_abc_not_exact_case().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_list_to_conjonction()

expression expression_list_to_conjonction

(

list

l

)

Definition at line 1937 of file expression.c.

{
  int   len = gen_length(l);
  entity and = entity_intrinsic(AND_OPERATOR_NAME);
  return(len==0?
         MakeNullaryCall(entity_intrinsic(".TRUE.")):
         expression_list_to_binary_operator_call(l, and));
}

References AND_OPERATOR_NAME, entity_intrinsic(), expression_list_to_binary_operator_call(), gen_length(), and MakeNullaryCall().

Referenced by alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_two_array_variables_in_caller(), alias_check_two_array_variables_in_module(), alias_check_two_scalar_variables_in_caller(), alias_check_two_scalar_variables_in_module(), make_guard_expression(), and Psysteme_to_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_lists_equal_p()

bool expression_lists_equal_p	(	list	l1,
		list	l2
	)

Parameters

l1	1
l2	2

Definition at line 1405 of file expression.c.

{
  bool equal_p = true;
  list cl1 = l1, cl2 = l2;
  while(!ENDP(cl1) && !ENDP(cl2)) {
    expression e1 = EXPRESSION(CAR(cl1));
    expression e2 = EXPRESSION(CAR(cl2));
    if(!expression_equal_p(e1, e2)) {
      equal_p = false;
      break;
    }
    POP(cl1), POP(cl2);
  }
  if(equal_p)
    equal_p = ENDP(cl1) && ENDP(cl2);
  return equal_p;
}

References CAR, ENDP, EXPRESSION, expression_equal_p(), and POP.

Referenced by reference_to_points_to_translations().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_minmax_p()

bool expression_minmax_p

(

expression

e

)

Returns

true if expression e is a min or a max

Definition at line 3882 of file expression.c.

{
    if(expression_call_p(e))
    {
        entity op = call_function(expression_call(e));
        return ENTITY_MIN_P(op) || ENTITY_MAX_P(op);
    }
    return false;
}

References call_function, ENTITY_MAX_P, ENTITY_MIN_P, expression_call(), and expression_call_p().

Referenced by do_loop_nest_unswitching(), region_to_minimal_dimensions(), and simplify_minmax_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_mult()

expression expression_mult

(

expression

ex

)

Parameters

ex

x

Definition at line 156 of file expression.c.

{
  pips_internal_error("not implemented");
  return ex;
}

References pips_internal_error.

expression_normalize_subscripts()

void expression_normalize_subscripts

(

expression

e

)

To be used for initialization expressions.

Definition at line 4465 of file expression.c.

{
  gen_recurse(e, expression_domain, gen_true, normalize_subscript_expression);
}

References expression_domain, gen_recurse, gen_true(), and normalize_subscript_expression().

Here is the call graph for this function:

expression_null_p()

bool expression_null_p

(

expression

exp

)

returns true if the expression is equal to zero or NULL (even if there is a cast before such as in (void *) 0).

Parameters

exp

xp

Definition at line 2611 of file expression.c.

{
  bool null_p = false;
  if (expression_cast_p(exp))
    null_p = expression_null_p(cast_expression(expression_cast(exp)));
  else if (expression_reference_p(exp))
    {
      null_p = same_string_p(entity_local_name(expression_variable(exp)), "NULL");
    }
  else
    {
      if (expression_constant_p(exp))
        null_p = (expression_to_int(exp) == 0);
    }
  return null_p;
}

References cast_expression, entity_local_name(), exp, expression_cast(), expression_cast_p(), expression_constant_p(), expression_reference_p(), expression_to_int(), expression_variable(), and same_string_p.

Referenced by equal_condition_to_points_to(), freeable_points_to_cells(), have_null_value_in_pointer_expression_p(), non_equal_condition_to_points_to(), and pointer_expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_one_p()

bool expression_one_p

(

expression

exp

)

Parameters

exp

xp

Definition at line 2591 of file expression.c.

{
  bool one_p = false;
 
  if(syntax_call_p(expression_syntax(exp))) {
    call c = syntax_call(expression_syntax(exp));
    value v = entity_initial(call_function(c));
 
    if(value_constant_p(v)) {
      constant c = value_constant(v);
      one_p = constant_int_p(c) && (constant_int(c)==1);
    }
  }
  return one_p;
}

References call_function, constant_int, constant_int_p, entity_initial, exp, expression_syntax, syntax_call, syntax_call_p, value_constant, and value_constant_p.

Referenced by ensure_comment_consistency().

Here is the caller graph for this function:

expression_opposite_p()

bool expression_opposite_p	(	expression	e1,
		expression	e2
	)

e1+e2==0, i.e.

-e1==e2 or e1==-e2 syntactically

Parameters

e1	1
e2	2

Definition at line 1386 of file expression.c.

{
  bool opposite_p = false;
 
  if(unary_minus_expression_p(e1)) {
    call c1 = expression_call(e1);
    expression e11 = EXPRESSION(CAR(call_arguments(c1)));
    opposite_p = expression_equal_p(e11, e2);
  }
  else if(unary_minus_expression_p(e2)) {
    call c2 = expression_call(e2);
    expression e22 = EXPRESSION(CAR(call_arguments(c2)));
    opposite_p = expression_equal_p(e1, e22);
  }
  return  opposite_p;
}

References call_arguments, CAR, EXPRESSION, expression_call(), expression_equal_p(), and unary_minus_expression_p().

Referenced by integer_multiply_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_pointer_p()

bool expression_pointer_p

(

expression

e

)

we get the type of the expression by calling expression_to_type() which allocates a new one.

Then we call ultimate_type() to have the final type. Finally we test if it's a pointer by using pointer_type_p().

Definition at line 506 of file expression.c.

                                        {
  type et = expression_to_type(e);
  type t = ultimate_type(et);
  return pointer_type_p(t);
 
}

References expression_to_type(), pointer_type_p(), and ultimate_type().

Referenced by atom_cse_expression(), cse_call_flt(), derived_formal_parameter_to_stub_points_to(), do_terapix_pointer_initialized_from_a_mask_p(), glc_call(), points_to_cells_pointer_arguments(), and typedef_formal_parameter_to_stub_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_range()

range expression_range

(

expression

e

)

Definition at line 1853 of file expression.c.

{
    pips_assert("is a range", expression_range_p(e));
    return syntax_range(expression_syntax(e));
}

References expression_range_p(), expression_syntax, pips_assert, and syntax_range.

Here is the call graph for this function:

expression_range_p()

bool expression_range_p

(

expression

e

)

Definition at line 1848 of file expression.c.

{
    return syntax_range_p(expression_syntax(e));
}

References expression_syntax, and syntax_range_p.

Referenced by expression_range(), and generic_atomic_points_to_reference_p().

Here is the caller graph for this function:

expression_reference()

reference expression_reference

(

expression

e

)

Short cut, meaningful only if expression_reference_p(e) holds.

Definition at line 1832 of file expression.c.

{
    pips_assert("e is a reference\n",expression_reference_p(e));
    return syntax_reference(expression_syntax(e));
}

References expression_reference_p(), expression_syntax, pips_assert, and syntax_reference.

Referenced by add_aliases_for_current_call_site(), address_of_scalar(), array_argument_p(), array_elements_substitution_in_transformer(), array_must_fully_written_by_regions_p(), array_to_constant_paths(), assignment_to_points_to(), atomize_call(), c_convex_effects_on_actual_parameter_forward_translation(), call_count_flt(), call_flt(), call_rwt(), comEngine_replace_reference_in_stat_rwt(), compact_phi_functions(), complete_points_to_reference_with_fixed_subscripts(), compute_points_to_binded_set(), convert_pointer_to_array_aux(), da_process_list(), dereferencing_to_points_to(), distance_between_expression(), do_array_to_pointer_walk_call_and_patch(), do_array_to_pointer_walk_expression(), do_atomize_call(), do_brace_expression_to_statements(), do_expression_reduction(), do_grouping_filter_out_self(), do_grouping_replace_reference_by_expression_walker(), do_linearize_prepatch_subscript(), do_linearize_remove_dereferencment_walker(), do_reduction_atomization(), do_reduction_detection(), do_reduction_propagation(), do_split_structure_return_hook_walker(), do_terapix_pointer_initialized_from_a_mask_p(), entity_used_in_calls_walker(), expression_allocatable_data_access_p(), expression_equal_in_context_p(), expression_reference_number(), expression_to_transformer(), expression_try_find_string_size(), expression_verbose_reduction_p_and_return_increment(), extended_regions_must_convex_hull(), field_expression_p(), FindDefinitionsOf_rewrite(), flint_cons_actual_argument(), freia_shuffle_move_forward(), full_copy_p(), generate_deducables(), get_complement_expression(), get_dma_dimension(), get_sizeofexpression_for_region(), glc_call(), guess_loop_increment_walker(), guess_loop_lower_bound(), guess_write_effect_on_entity_walker(), interprocedural_abc_call(), invalidate_expressions_in_statement(), isolate_patch_reference(), list_of_same_or_equivalence_arguments(), loadstore_type_conversion_string(), make_loadsave_statement(), make_send_receive_conversion(), new_array_elements_backward_substitution_in_transformer(), new_array_elements_forward_substitution_in_transformer(), offset_in_caller(), outliner_patch_parameters(), partial_eval_update_operators(), perform_substitution_in_assign(), points_to_array_reference_p(), points_to_array_reference_to_type(), points_to_cells_pointer_arguments(), points_to_indices_to_subscript_indices(), points_to_indices_to_unbounded_indices(), process_static_initialization(), process_true_call_stat(), put_variables_in_ordered_lists(), recursive_store_independent_points_to_reference_p(), reference_argument_number(), reference_filter(), reference_to_field_disambiguator(), references_must_conflict_p(), region_to_address(), remove_unread_variable(), replace_entities_expression_walker(), replace_entity_by_expression_expression_walker(), replace_field_by_reference_walker(), rssp_ref(), sac_aligned_expression_p(), sac_expression_reduction_p(), safe_expression_to_transformer(), same_or_equivalence_argument_add_aliases(), same_section_common_variable_in_list_p(), same_section_formal_variable_in_list_p(), seq_rwt(), simd_trace_call(), simple_reference_to_convex_reference_conversion(), simplify_complex_expression(), split_complex_expression(), statement_insertion_fix_access_in_callers(), subscripted_field_list_to_type(), substitute_image_in_statement(), sww_seq_rwt(), terapix_loop_handler(), update_functional_type_with_actual_arguments(), variable_to_dimensions(), and verify_array_element().

Here is the call graph for this function:

expression_reference_p()

bool expression_reference_p

(

expression

e

)

Test if an expression is a reference.

Definition at line 528 of file expression.c.

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

References expression_syntax, and syntax_reference_p.

Referenced by add_aliases_for_current_call_site(), address_of_scalar(), alloc_instrumentation(), array_argument_p(), array_elements_substitution_in_transformer(), array_indices_check(), array_must_fully_written_by_regions_p(), assign_operation_to_transformer(), assignment_to_points_to(), atomize_call(), atomize_call_statement(), atomize_condition(), c_convex_effects_on_actual_parameter_forward_translation(), call_count_flt(), call_flt(), cleanup_subscript(), comEngine_replace_reference_in_stat_rwt(), compact_phi_functions(), compute_points_to_binded_set(), constant_reference_to_normalized_constant_reference(), continue_propagation_p(), controlize_statement(), convert_pointer_to_array_aux(), cstr_args_check(), dereferencing_to_points_to(), distance_between_expression(), do_array_to_pointer_walk_call_and_patch(), do_array_to_pointer_walk_expression(), do_atomize_call(), do_brace_expression_to_statements(), do_expression_reduction(), do_grouping_filter_out_self(), do_grouping_replace_reference_by_expression_walker(), do_linearize_pointer_is_expression(), do_linearize_prepatch_subscript(), do_linearize_remove_dereferencment_walker(), do_reduction_atomization(), do_reduction_propagation(), do_split_structure_return_hook_walker(), do_terapix_loop_optimizer(), entity_used_in_calls_walker(), expr_flt(), expr_rwt(), expression_equal_in_context_p(), expression_null_p(), expression_number_for_index(), expression_reference(), expression_reference_number(), expression_reference_or_field_p(), expression_simple_nondist_p(), expression_to_transformer(), expression_try_find_size(), expression_verbose_reduction_p_and_return_increment(), extended_regions_must_convex_hull(), field_expression_p(), flint_cons_actual_argument(), freia_extract_kernel(), freia_shuffle_move_forward(), full_copy_p(), get_complement_expression(), get_dma_dimension(), get_sizeofexpression_for_region(), glc_call(), guess_loop_increment_walker(), guess_loop_lower_bound(), guess_write_effect_on_entity_walker(), hpfc_overlap_kill_unused_scalars_rewrite(), interprocedural_mapping(), intrinsic_call_to_points_to(), invalidate_expressions_in_statement(), is_expression_reference_to_entity_p(), isolate_patch_reference(), list_of_same_or_equivalence_arguments(), loadstore_type_conversion_string(), make_loadsave_statement(), new_array_elements_backward_substitution_in_transformer(), new_array_elements_forward_substitution_in_transformer(), outliner_patch_parameters(), parser_macro_expansion(), partial_eval_call(), partial_eval_update_operators(), points_to_cells_pointer_arguments(), points_to_indices_to_array_index_number(), points_to_indices_to_subscript_indices(), points_to_indices_to_unbounded_indices(), process_static_initialization(), process_true_call_stat(), proper_to_summary_simple_effect(), reference_argument_number(), reference_filter(), reference_to_field_disambiguator(), reference_to_type(), references_aligned_p(), references_must_conflict_p(), regenerate_call(), region_to_address(), remove_unread_variable(), replace_entities_expression_walker(), replace_entity_by_expression_expression_walker(), replace_field_by_reference_walker(), rssp_ref(), sac_aligned_expression_p(), sac_expression_reduction_p(), safe_expression_to_transformer(), same_section_common_variable_in_list_p(), same_section_formal_variable_in_list_p(), seq_rwt(), simple_reference_to_convex_reference_conversion(), simplify_complex_expression(), statement_insertion_fix_access_in_callers(), subarray_shift_assignment_p(), subscripted_field_list_to_type(), substitute_image_in_statement(), sww_seq_rwt(), terapix_loop_handler(), update_functional_type_with_actual_arguments(), update_operation_to_transformer(), variable_references_may_conflict_p(), and variable_to_dimensions().

expression_similar_get_context_p()

bool expression_similar_get_context_p	(	expression	target,
		expression	pattern,
		hash_table *	symbol_table
	)

similar to expression_similar_p but the hash_map containing the crossref value is retured for further use

Parameters

target	expression to compare
pattern	expression serving as pattern
symbol_table	pointer to unallocated hash_map, in the end it will contain a set of pair (original syntax reference name, substituted syntax element). Must be freed, but only if expressions are similar

Returns

true if expressions are similar

Parameters

target	arget
pattern	attern
symbol_table	ymbol_table

Definition at line 3339 of file expression.c.

{
    *symbol_table = hash_table_make(hash_string,HASH_DEFAULT_SIZE);
    bool similar = _expression_similar_p(target,pattern,*symbol_table);
    if( !similar) hash_table_free(*symbol_table);
    return similar;
}

References _expression_similar_p(), HASH_DEFAULT_SIZE, hash_string, hash_table_free(), hash_table_make(), and symbol_table().

Referenced by replace_expression_similar_to_pattern().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_similar_p()

bool expression_similar_p	(	expression	target,
		expression	pattern
	)

compare if two expressions are similar that is can we exchange target and pattern by substituing variables examples: 1+2 ~ a+b a+b !~ a+2 1+b ~ 1+c

Parameters

target	expression that sould match with pattern
pattern	the pattern to match

Returns

true if expressions are similar

Parameters

target	arget
pattern	attern

Definition at line 3360 of file expression.c.

{
  hash_table symbol_table = hash_table_make(hash_pointer,HASH_DEFAULT_SIZE);
  bool similar = _expression_similar_p(target,pattern,symbol_table);
  hash_table_free(symbol_table);
  return similar;
}

References _expression_similar_p(), HASH_DEFAULT_SIZE, hash_pointer, hash_table_free(), hash_table_make(), and symbol_table().

Here is the call graph for this function:

expression_sizeofexpression()

sizeofexpression expression_sizeofexpression

(

expression

e

)

Definition at line 465 of file expression.c.

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

References expression_syntax, and syntax_sizeofexpression.

Referenced by expression_to_transformer().

Here is the caller graph for this function:

expression_sizeofexpression_p()

bool expression_sizeofexpression_p

(

expression

e

)

Definition at line 460 of file expression.c.

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

References expression_syntax, and syntax_sizeofexpression_p.

Referenced by expression_to_transformer().

Here is the caller graph for this function:

expression_string_constant()

char* expression_string_constant

(

expression

exp

)

returns a newly allocated string!

Parameters

exp

xp

Definition at line 2409 of file expression.c.

                                                 {
  pips_assert("is a string constant", expression_string_constant_p(exp));
    call c = expression_call(exp);
    entity operator = call_function(c);
    const char * eun = entity_user_name(operator);
    return strndup(eun+1,strlen(eun)-2);
}

References call_function, entity_user_name(), exp, expression_call(), expression_string_constant_p(), pips_assert, and strndup().

Referenced by do_simplify_constant_address_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_string_constant_p()

bool expression_string_constant_p

(

expression

exp

)

Parameters

exp

xp

Definition at line 2398 of file expression.c.

                                                  {
  bool constant_p = false;
  if(expression_constant_p(exp) && expression_call_p(exp) ) {
    call c = expression_call(exp);
    entity operator = call_function(c);
    constant_p = constant_string_entity_p(operator);
  }
  return constant_p;
}

References call_function, constant_p(), constant_string_entity_p(), exp, expression_call(), expression_call_p(), and expression_constant_p().

Referenced by compute_points_to_binded_set(), do_simplify_constant_address_expression(), and expression_string_constant().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_subscript()

subscript expression_subscript

(

expression

e

)

Definition at line 1843 of file expression.c.

{
    pips_assert("is a subscript\n",expression_subscript_p(e));
    return syntax_subscript(expression_syntax(e));
}

References expression_subscript_p(), expression_syntax, pips_assert, and syntax_subscript.

Referenced by expression_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_subscript_p()

bool expression_subscript_p

(

expression

e

)

Definition at line 1838 of file expression.c.

                                          {
    return syntax_subscript_p(expression_syntax(e));
}

References expression_syntax, and syntax_subscript_p.

Referenced by expression_subscript(), and expression_to_transformer().

Here is the caller graph for this function:

expression_to_dereferencing_expression()

expression expression_to_dereferencing_expression

(

expression

e

)

Reuse expression e to build expression *(e) without cheking the legality of the construct.

Definition at line 4051 of file expression.c.

{
  return unary_intrinsic_expression(DEREFERENCING_OPERATOR_NAME, e);
}

References DEREFERENCING_OPERATOR_NAME, and unary_intrinsic_expression.

expression_to_entity()

entity expression_to_entity

(

expression

e

)

just returns the entity of an expression, or entity_undefined

The entity returned is either the function called or the variable referenced

SG: moved here from hpfc Warning: This function certainly needs to be reviewed, maybe just testing the size of arguments (call), or the size of index (reference) may be sufficient as a first step. If their sizes are != 0, it may not return what we expect (for instance "-3" will return UNARY_MINUS_OPERATOR_NAME "--"). But expression_to_entity is called by many functions and I worry about the side effects on them.

Definition at line 3140 of file expression.c.

{
  syntax s = expression_syntax(e);
 
  switch (syntax_tag(s))
  {
  case is_syntax_call:
    return call_function(syntax_call(s));
  case is_syntax_reference:
    return reference_variable(syntax_reference(s));
  case is_syntax_range:
  case is_syntax_cast:
  case is_syntax_sizeofexpression:
  case is_syntax_subscript:
  case is_syntax_application:
  case is_syntax_va_arg:
  default:
    return entity_undefined;
  }
}

References call_function, entity_undefined, expression_syntax, 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, reference_variable, syntax_call, syntax_reference, and syntax_tag.

Referenced by address_of_entity_p(), continue_propagation_p(), copy_write_statement_with_cumulated_regions(), dagvtx_copy_list_dot(), do_check_isolate_statement_preconditions_on_call(), do_group_statement_constant(), do_isolate_statement_preconditions_satisified_p(), do_simdizer_init(), do_solve_hardware_constraints_on_nb_proc(), do_terapix_loop_optimizer(), effect_field_dimension_entity(), expressions_to_entities(), filter_variables_in_pragma_expr(), find_receiver_cluster(), fis_call_flt(), freia_cleanup_sequence_rec(), freia_extract_params(), freia_is_transpose_call(), gen_mpi_send_recv(), get_assigned_variable(), get_reference_assignments(), handle_align_and_realign_directive(), handle_prescriptive_directive(), hpf_compile_call(), hpfc_translate_call_with_distributed_args(), is_expression_in_list(), is_expression_omp_for_p(), is_expression_omp_if_p(), is_expression_omp_omp_p(), is_expression_omp_parallel_p(), is_expression_omp_private_p(), is_expression_omp_reduction_p(), lUpdateExpr_but_distributed(), make_loadsave_statement(), make_send_receive_conversion(), make_simd_statement(), mpi_recv_ctx(), mpi_send_ctx(), new_dynamic(), new_fake_function(), new_io_function(), new_processor(), new_pure_function(), new_system_with_only_live_variable(), new_template(), oi_call_rwt(), outliner_smart_references_computation(), partial_eval_binary_operator(), region_to_minimal_dimensions(), remove_from_effective_parameters(), step_directive_basic_workchunk_index(), terapix_loop_optimizer(), terapixify_loops(), test_rewrite(), and update_overlaps_in_caller().

expression_to_float()

float expression_to_float

(

expression

exp

)

Same as above for floating point constants.

Its calls must be guarded by expression_constant_p()

Parameters

exp

xp

Definition at line 2305 of file expression.c.

{
  float rv = 0;
 
  pips_debug( 7, "doing\n");
  if(expression_constant_p(exp)) {
    call c = syntax_call(expression_syntax(exp));
    switch(value_tag(entity_initial(call_function(c)))) {
    case is_value_constant:     {
      rv = atof(entity_user_name(call_function(c)));
      break;
    }
    case is_value_intrinsic: {
      entity op = call_function(c);
      if(ENTITY_UNARY_MINUS_P(op))
        rv = 0 - expression_to_float(binary_call_lhs(c));
      else if(ENTITY_UNARY_PLUS_P(op))
        rv = expression_to_float(binary_call_lhs(c));
      else
        pips_internal_error("Unexpected intrinsic \"%s\"\n",
                            entity_local_name(op));
      break;
    }
    default:
      pips_internal_error("expression is not a constant"
                          " according to expression_constant_p()");
    }
  }
  else
    pips_internal_error("expression is not a constant"
                        " according to expression_constant_p()");
  return(rv);
}

References binary_call_lhs, call_function, entity_initial, entity_local_name(), ENTITY_UNARY_MINUS_P, ENTITY_UNARY_PLUS_P, entity_user_name(), exp, expression_constant_p(), expression_syntax, is_value_constant, is_value_intrinsic, pips_debug, pips_internal_error, syntax_call, and value_tag.

Referenced by do_solve_hardware_constraints_on_volume(), and expression_to_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_int()

int expression_to_int

(

expression

exp

)

================================================================

int expression_to_int(expression exp): returns the integer value of "exp" when "exp" is programming language constant or a Fortran symbolic constant.

Note: "exp" is supposed to contain an integer value which means that the function expression_constant_p() has returned true with "exp" as argument.

This implies that if "exp" is not a "value_constant", it must be a "value_intrinsic". In that case it is an unary minus operation upon an expression for which the function expression_constant_p() returns true (see its comment).

SG: improvement: the integer value of a extended_integer_constant_expression_p is computed too, for instance 0+5 or 6+3.

FI: I am not sure it is an improvement, at best it is an extension; it looks more like a change of semantics (see above comments and expression_constant_p()); other functions exist to evaluate a constant expression... The extension should be useless as this function should not be called unless guarded by a test with expression_constant_p()... The same is true for the extension related to symbolic constants.

For an extended static expression evaluation, see EvalExpression(). See also extended_expression_constant_p() for more comments about what is called a "constant" expression.

For a cleaner implementation of this function, as it was originally intended, see below expression_to_float().

use the normalize field first: this is Serge Guelton's improvement...

Not good for user source code preservation...

This is the initial code

pips_internal_error("expression %s is not an integer constant.\n",

expression_to_string(exp));

Could be improved checking dependent and not dependent types...

pips_internal_error("expression %s is not an integer constant\n",

expression_to_string(exp));

This is another useless extension

Is it an integer "parameter" in Fortran, that is symbolic constants?

Should this be generalized to C const qualified variables?

I have doubt about this piece of code since the call is supposedly guarded by expression_constant_p()

pips_internal_error("expression %s is not an integer constant\n",

expression_to_string(exp));

pips_internal_error("expression %s is not an integer constant"

" in the sense of expression_constant_p()\n",

expression_to_string(exp));

Parameters

exp

xp

Definition at line 2205 of file expression.c.

{
  int rv = 0;
  pips_debug(7, "doing\n");
 
  /* use the normalize field first: this is Serge Guelton's improvement... */
  /* Not good for user source code preservation... */
  NORMALIZE_EXPRESSION(exp);
  normalized n = expression_normalized(exp);
  if(normalized_linear_p(n)) {
      Pvecteur pv = normalized_linear(n);
      if(vect_constant_p(pv))
          return (int)vect_coeff(TCST, pv);
  }
 
  /* This is the initial code */
  if(expression_constant_p(exp)) {
    syntax s = expression_syntax(exp);
    if(syntax_call_p(s)) { // A nullary call is assumed
      call c = syntax_call(s);
      switch(value_tag(entity_initial(call_function(c)))) {
      case is_value_constant:   {
        rv = constant_int(value_constant(entity_initial(call_function(c))));
        break;
      }
      case is_value_intrinsic: {
        entity op = call_function(c);
        if(ENTITY_UNARY_MINUS_P(op))
          rv = 0 - expression_to_int(binary_call_lhs(c));
        else if(ENTITY_UNARY_PLUS_P(op))
          rv = expression_to_int(binary_call_lhs(c));
        else
          pips_internal_error("Unexpected intrinsic \"%s\"\n",
                              entity_local_name(op));
        break;
      }
      default:
        /* pips_internal_error("expression %s is not an integer constant.\n", */
        /*                  expression_to_string(exp)); */
        pips_internal_error("expression is not an integer constant.\n");
      }
    }
    else if(false && syntax_sizeofexpression(s)) {
      sizeofexpression soe = syntax_sizeofexpression(s);
      // FI: do we want to guard this evaluation with EVAL_SIZEOF?
      // This should be part of eval.c
      value v = EvalSizeofexpression(soe);
      if(value_constant_p(v)) { // Should always be true... but for dependent types
        rv = constant_int(value_constant(v));
      }
      else {
        /* Could be improved checking dependent and not dependent types...*/
        // FI: to avoid cycles between librairies ri-util and prettyprint
        /* pips_internal_error("expression %s is not an integer constant\n", */
        /*                  expression_to_string(exp)); */
        pips_internal_error("expression is not an integer constant.\n");
      }
      free_value(v);
    }
  }
  /* This is another useless extension */
  else if(expression_call_p(exp)) {
    /* Is it an integer "parameter" in Fortran, that is symbolic constants?
     *
     * Should this be generalized to C const qualified variables?
     *
     * I have doubt about this piece of code since the call is
     * supposedly guarded by expression_constant_p()
     */
    entity p = call_function(syntax_call(expression_syntax(exp)));
    value v = entity_initial(p);
 
    if(value_symbolic_p(v) && constant_int_p(symbolic_constant(value_symbolic(v)))) {
      rv = constant_int(symbolic_constant(value_symbolic(v)));
    }
    else {
      // FI: to avoid cycles between librairies ri-util and prettyprint
      /* pips_internal_error("expression %s is not an integer constant\n", */
      /*                          expression_to_string(exp)); */
      pips_internal_error("expression is not an integer constant\n");
    }
  }
  else {
      // FI: to avoid cycles between librairies ri-util and prettyprint
      /* pips_internal_error("expression %s is not an integer constant" */
      /*                          " in the sense of expression_constant_p()\n", */
      /*                          expression_to_string(exp)); */
      pips_internal_error("expression is not an integer constant"
                          " in the sense of expression_constant_p()\n");
  }
 
  return(rv);
}

References binary_call_lhs, call_function, constant_int, constant_int_p, entity_initial, entity_local_name(), ENTITY_UNARY_MINUS_P, ENTITY_UNARY_PLUS_P, EvalSizeofexpression(), exp, expression_call_p(), expression_constant_p(), expression_normalized, expression_syntax, free_value(), is_value_constant, is_value_intrinsic, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, pips_debug, pips_internal_error, symbolic_constant, syntax_call, syntax_call_p, syntax_sizeofexpression, TCST, value_constant, value_constant_p, value_symbolic, value_symbolic_p, value_tag, vect_coeff(), and vect_constant_p().

Referenced by adg_get_conjonctions(), analyze_expression(), array_indices_check(), array_size_stride(), compute_final_index_value(), convert_bound_expression(), effect_field_dimension_entity(), equal_must_vreference(), expression_equal_integer_p(), expression_null_p(), expression_plusplus(), expression_try_find_size(), find_target_position(), formal_variable_add_aliases(), incrementation_expression_to_increment(), loop_annotate(), loop_normalize_of_loop(), make_max_exp(), make_send_receive_conversion(), MakeEquivAtom(), opkill_may_vreference(), opkill_must_vreference(), points_to_compare_cell(), points_to_compare_cells(), points_to_compare_location(), points_to_compare_ptr_cell(), rational_op_exp(), references_do_not_conflict_p(), sentence_data_statement(), size_of_actual_array(), size_of_dummy_array(), subscript_value(), subscript_value_stride(), system_new_var_subst(), valuer(), and words_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_polynome()

Ppolynome expression_to_polynome

(

expression

exp

)

===========================================================================

Ppolynome expression_to_polynome(expression exp): translates "exp" into a polynome. This transformation is feasible if "exp" contains only scalars and the four classical operations (+, -, *, /).

The translation is done straightforwardly and recursively.

it returns a POLYNOME_UNDEFINED if the conversion failed

This the resulting polynome

Two cases : _ a constant _ a "real" call, ie an intrinsic or external function

We should have a real null polynome : 0*TCST^1 AL, AC 04 11 93 else { Pmonome pm = (Pmonome) malloc(sizeof(Smonome)); monome_coeff(pm) = 0; monome_term(pm) = vect_new(TCST, 1); pp_new = monome_to_new_polynome(pm); }

The call must be one of the four classical operations: +, - (unary or binary), *, /

This call has one (unary minus) or two (binary plus, minus, multiply or divide) arguments, no less and no more.

arg1 + arg2

-arg2 + arg1

arg1 * arg2

arg1 / arg2

(ENTITY_UNARY_MINUS_P(op_ent)) : -arg1

Parameters

exp

xp

Definition at line 3650 of file expression.c.

{
    Ppolynome pp_new=POLYNOME_UNDEFINED; /* This the resulting polynome */
    syntax sy = expression_syntax(exp);
 
    switch(syntax_tag(sy))
    {
        case is_syntax_reference:
            {
                reference r = syntax_reference(sy);
                entity en = reference_variable(r);
 
                if(entity_scalar_p(en)||(entity_pointer_p(en)&&ENDP(reference_indices(r))))
                    pp_new = make_polynome(1.0, (Variable) en, (Value) 1);
                break;
            }
        case is_syntax_call:
            {
                /* Two cases : _ a constant
                 *             _ a "real" call, ie an intrinsic or external function
                 */
                if (expression_constant_p(exp)) {
                    float etof = expression_to_float(exp);
                    pp_new = make_polynome( etof,
                            (Variable) entity_undefined, (Value) 0);
                    /* We should have a real null polynome : 0*TCST^1 AL, AC 04 11 93
                     *else  {
                     *  Pmonome pm = (Pmonome) malloc(sizeof(Smonome));
                     * monome_coeff(pm) = 0;
                     *  monome_term(pm) = vect_new(TCST, 1);
                     *  pp_new = monome_to_new_polynome(pm);
                     *}
                     */
                }
                else
                {
                    int cl;
                    expression arg1, arg2 = expression_undefined;
                    entity op_ent = call_function(syntax_call(sy));
 
                    /* The call must be one of the four classical operations:
                     *  +, - (unary or binary), *, /
                     */
                    if(ENTITY_FIVE_OPERATION_P(op_ent))
                    {
                        /* This call has one (unary minus) or two (binary plus, minus,
                         * multiply or divide) arguments, no less and no more.
                         */
                        cl = gen_length(call_arguments(syntax_call(sy)));
                        if( (cl != 2) && (cl != 1) )
                            pips_internal_error("%s call with %d argument(s)",
                                    entity_local_name(op_ent), cl);
 
                        arg1 = EXPRESSION(CAR(call_arguments(syntax_call(sy))));
                        if(cl == 2)
                            arg2 = EXPRESSION(CAR(CDR(call_arguments(syntax_call(sy)))));
 
                        if (ENTITY_PLUS_P(op_ent)||ENTITY_PLUS_C_P(op_ent)) /* arg1 + arg2 */
                        {
                            pp_new = expression_to_polynome(arg1);
                            if(!POLYNOME_UNDEFINED_P(pp_new))
                                polynome_add(&pp_new, expression_to_polynome(arg2));
                        }
                        else if(ENTITY_MINUS_P(op_ent)||ENTITY_MINUS_C_P(op_ent)) /* -arg2 + arg1 */
                        {
                            pp_new = expression_to_polynome(arg2);
                            if(!POLYNOME_UNDEFINED_P(pp_new)) {
                                polynome_negate(&pp_new);
                                Ppolynome parg1 = expression_to_polynome(arg1);
                                if(!POLYNOME_UNDEFINED_P(parg1))
                                    polynome_add(&pp_new, parg1);
                                else {
                                    polynome_rm(&pp_new);
                                    pp_new=POLYNOME_UNDEFINED;
                                }
                            }
                        }
                        else if(ENTITY_MULTIPLY_P(op_ent)) /* arg1 * arg2 */ {
                            Ppolynome p1 = expression_to_polynome(arg1);
                            if(!POLYNOME_UNDEFINED_P(p1)) {
                                Ppolynome p2 = expression_to_polynome(arg2);
                                if(!POLYNOME_UNDEFINED_P(p2)) {
                                    pp_new = polynome_mult(p1,p2);
                                }
                            }
                        }
                        else if(ENTITY_DIVIDE_P(op_ent)) /* arg1 / arg2 */ {
                            Ppolynome p1 = expression_to_polynome(arg1);
                            if(!POLYNOME_UNDEFINED_P(p1)) {
                                Ppolynome p2 = expression_to_polynome(arg2);
                                if(!POLYNOME_UNDEFINED_P(p2)) {
                                    pp_new = polynome_div(p1,p2);
                                }
                            }
                        }
                        else /* (ENTITY_UNARY_MINUS_P(op_ent)) : -arg1 */
                        {
                            pp_new = expression_to_polynome(arg1);
                            if(!POLYNOME_UNDEFINED_P(pp_new)) {
                                polynome_negate(&pp_new);
                            }
                        }
                    }
                }
 
                break;
            }
        default :
            {
                pp_new=POLYNOME_UNDEFINED;
            }
    }
    return(pp_new);
}

References call_arguments, call_function, CAR, CDR, ENDP, ENTITY_DIVIDE_P, ENTITY_FIVE_OPERATION_P, entity_local_name(), ENTITY_MINUS_C_P, ENTITY_MINUS_P, ENTITY_MULTIPLY_P, ENTITY_PLUS_C_P, ENTITY_PLUS_P, entity_pointer_p(), entity_scalar_p(), entity_undefined, exp, EXPRESSION, expression_constant_p(), expression_syntax, expression_to_float(), expression_undefined, gen_length(), is_syntax_call, is_syntax_reference, make_polynome(), pips_internal_error, polynome_add(), polynome_div(), polynome_mult(), polynome_negate(), polynome_rm(), POLYNOME_UNDEFINED, POLYNOME_UNDEFINED_P, reference_indices, reference_variable, syntax_call, syntax_reference, and syntax_tag.

Referenced by edge_cost_polynome(), include_trans_in_poly(), plc_make_distance(), search_scc_bdt(), simplify_expression(), and size_of_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_to_reference()

reference expression_to_reference

(

expression

e

)

Definition at line 212 of file expression.c.

{
    syntax s = expression_syntax(e);
    message_assert("reference", syntax_reference_p(s));
    return syntax_reference(s);
}

References expression_syntax, message_assert, syntax_reference, and syntax_reference_p.

Referenced by continue_propagation_p(), handle_align_and_realign_directive(), and handle_distribute_and_redistribute_directive().

Here is the caller graph for this function:

expression_to_reference_list()

list expression_to_reference_list	(	expression	e,
		list	lr
	)

conversion of an expression into a list of references; references are appended to list lr as they are encountered; array references are added before their index expressions are scanned;

references to functions and constants (which are encoded as null-ary functions) are not recorded

Parameters

lr

r

Definition at line 1263 of file expression.c.

{
    syntax s = expression_syntax(e);
    lr = syntax_to_reference_list(s, lr);
    return lr;
}

References expression_syntax, and syntax_to_reference_list().

Referenced by array_indice_in_list_p(), check_loop_distribution_feasability(), effect_interference(), effects_interfere_p(), guess_late_read_effect_on_entity(), loop_nest_to_local_variables(), self_initialization_p(), syntax_to_reference_list(), and verify_used_before_set_call().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_variable()

entity expression_variable

(

expression

e

)

Assume e is a reference expression: expression_reference_p(e)==true

Definition at line 532 of file expression.c.

{
  /* Assume e is a reference expression:
     expression_reference_p(e)==true  */
  return reference_variable(syntax_reference(expression_syntax(e)));
}

References expression_syntax, reference_variable, and syntax_reference.

Referenced by expression_null_p(), find_entities_to_wrap(), freia_extract_kernel(), freia_reduction_variable(), maybe_unroll_while_rwt(), proper_to_summary_simple_effect(), seq_rwt(), and variable_references_may_conflict_p().

Here is the caller graph for this function:

expression_verbose_reduction_p_and_return_increment()

expression expression_verbose_reduction_p_and_return_increment	(	expression	incr,
		bool	filterexpression
	)

Test if an expression is a verbose reduction of the form : "i = i op v" or "i = v op i".

Parameters

e	is the expression to analyse
filter	is a function that take an expression and return true iff expression is of the form "op(a,b,c...)". The filter may not be specific to binary operators, even if this function only deal with binary patterns. Use for example add_expression_p() to detect "i = i + v" or "i = v + i".

Returns

the v expression if e is of the requested form or expression_undefined if not

The expression is an assignment, it is a good start.

Only deal with simple references right now:

Operation found.

Only deal with binary operators

If arg1 is the same reference as lhs, we are in the "i = i op v" case:

If arg2 is the same reference as lhs, we are in the "i = v op i" case:

Definition at line 780 of file expression.c.

                                                                             {
  if (assignment_expression_p(incr)) {
    /* The expression is an assignment, it is a good start. */
    list assign_params = call_arguments(syntax_call(expression_syntax(incr)));
    expression lhs = EXPRESSION(CAR(assign_params));
 
    /* Only deal with simple references right now: */
    if (expression_reference_p(lhs)) {
      expression rhs = EXPRESSION(CAR(CDR(assign_params)));
      if (filter(rhs)) {
        /* Operation found. */
        list op_params = call_arguments(syntax_call(expression_syntax(rhs)));
        /* Only deal with binary operators */
        if (gen_length(op_params) == 2) {
          expression arg1 = EXPRESSION(CAR(op_params));
          expression arg2 = EXPRESSION(CAR(CDR(op_params)));
          if (expression_reference_p(arg1)
              && reference_equal_p(expression_reference(lhs),
                                   expression_reference(arg1)))
            /* If arg1 is the same reference as lhs,
               we are in the "i = i op v" case: */
            return arg2;
          else if (expression_reference_p(arg2)
                   && reference_equal_p(expression_reference(lhs),
                                        expression_reference(arg2)))
            /* If arg2 is the same reference as lhs,
               we are in the "i = v op i" case: */
            return arg1;
        }
      }
    }
  }
  return expression_undefined;
}

References assignment_expression_p(), call_arguments, CAR, CDR, EXPRESSION, expression_reference(), expression_reference_p(), expression_syntax, expression_undefined, gen_length(), reference_equal_p(), and syntax_call.

Referenced by incrementation_expression_to_increment().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_with_constant_signed_integer_value_p()

bool expression_with_constant_signed_integer_value_p

(

expression

e

)

The expression may be complicated but all its leaves are constants or parameters.

It evaluates to a signed integer constant. I am too lazy to fully implement it as I should and I only take care of affine expressions (Francois).

No vecteur_constant_p() in linear library?

Definition at line 960 of file expression.c.

{
  normalized ne = NORMALIZE_EXPRESSION(e);
  bool constant_p = false;
 
  if(normalized_linear_p(ne)) {
    Pvecteur ve = normalized_linear(ne);
    /* No vecteur_constant_p() in linear library? */
    constant_p = VECTEUR_NUL_P(ve)
      || (term_cst(ve) && VECTEUR_UNDEFINED_P(vecteur_succ(ve)));
  }
 
  return constant_p;
}

References constant_p(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, term_cst, VECTEUR_NUL_P, vecteur_succ, and VECTEUR_UNDEFINED_P.

Referenced by array_with_numerical_bounds_p().

Here is the call graph for this function:

Here is the caller graph for this function:

expressions_to_entities()

list expressions_to_entities

(

list

expressions

)

map expression_to_entity on expressions

Parameters

expressions

xpressions

Definition at line 3161 of file expression.c.

{
  list entities = NIL;
  FOREACH(EXPRESSION,exp,expressions)
    entities=CONS(ENTITY,expression_to_entity(exp),entities);
  return gen_nreverse(entities);
}

References CONS, ENTITY, exp, EXPRESSION, expression_to_entity(), FOREACH, gen_nreverse(), and NIL.

Referenced by do_array_expansion(), do_solve_hardware_constraints_on_nb_proc(), generate_full_copy(), handle_independent_directive(), handle_reduction_directive(), rectangularization_region(), and statement_insertion_fix_access().

Here is the call graph for this function:

Here is the caller graph for this function:

expressions_to_operation()

expression expressions_to_operation	(	const list	l_exprs,
		entity	op
	)

take a list of expression and apply a binary operator between all of them and return it as an expression

Returns

the operations as an expression

Parameters

l_exprs,the	list of expressions to compute with the operator
op,the	binary operator to apply

Parameters

l_exprs	_exprs
op	p

Definition at line 3544 of file expression.c.

                                                                    {
  expression result = expression_undefined;
  if ((l_exprs != NIL) && (op != entity_undefined)){
    list l_src = l_exprs;
    result = EXPRESSION (CAR (l_src));
    POP(l_src);
    FOREACH (EXPRESSION, ex, l_src) {
      list args =  gen_expression_cons (result, NIL);
      args = gen_expression_cons (ex, args);
      call c = make_call (op, args);
      result = call_to_expression (c);
    }
  }
  return result;
}

References call_to_expression(), CAR, entity_undefined, EXPRESSION, expression_undefined, FOREACH, gen_expression_cons(), make_call(), NIL, and POP.

Referenced by add_loop_parallel_threshold(), make_send_receive_conversion(), and merge_conditions().

Here is the call graph for this function:

Here is the caller graph for this function:

extended_expression_constant_p()

bool extended_expression_constant_p

(

expression

exp

)

Returns true if the value of the expression does not depend syntactically on the current store.

Returns false when this has not been proved.

The only constant references in PIPS internal representation are references to functions and to declared constants.

Check that all arguments are constant

Certainly true for Fortran. Quid for C?

does not make much sense... for a function!

Let's be conservative

There might be another case of constant expressions: all that are casted to void... Usage?

This should be a constant, except for dependent types.

Parameters

exp

xp

Definition at line 2461 of file expression.c.

{
  syntax s = expression_syntax(exp);
  bool constant_p = false;
 
  switch(syntax_tag(s)) {
  case is_syntax_reference: {
    /* The only constant references in PIPS internal representation
       are references to functions and to declared constants. */
    reference r = syntax_reference(s);
    entity v = reference_variable(r);
    type t = ultimate_type(entity_type(v));
 
    constant_p = type_functional_p(t) || const_variable_p(v);
    break;
  }
  case is_syntax_range: {
    range r = syntax_range(s);
    expression lb = range_lower(r);
    expression ub = range_upper(r);
    expression inc = range_increment(r);
 
    constant_p = extended_expression_constant_p(lb)
      && extended_expression_constant_p(ub)
      && extended_expression_constant_p(inc);
    break;
  }
  case is_syntax_call: {
    call c = syntax_call(s);
    entity f = call_function(c);
    value v = entity_initial(f);
    switch(value_tag(v)) {
    case is_value_constant:
      constant_p = true;
      break;
    case is_value_intrinsic: {
      /* Check that all arguments are constant */
      list args = call_arguments(c);
      constant_p = true;
      FOREACH(EXPRESSION, sub_exp, args) {
        constant_p = constant_p && extended_expression_constant_p(sub_exp);
      }
      break;
    }
    case is_value_symbolic:
      /* Certainly true for Fortran. Quid for C? */
      constant_p = true;
      break;
    case is_value_expression: {
      /* does not make much sense... for a function! */
      expression sub_exp = value_expression(v);
      constant_p = extended_expression_constant_p(sub_exp);
      break;
    }
    case is_value_unknown:
    case is_value_code:
    default:
      /* Let's be conservative */
      constant_p = false;
    }
    break;
  }
  case is_syntax_cast: {
    /* There might be another case of constant expressions: all that
       are casted to void... Usage? */
    cast c = syntax_cast(s);
    expression sub_exp = cast_expression(c);
    constant_p = extended_expression_constant_p(sub_exp);
    break;
  }
  case is_syntax_sizeofexpression: {
    /* This should be a constant, except for dependent types. */
    sizeofexpression soe = syntax_sizeofexpression(s);
    type t = type_undefined;
    if(sizeofexpression_type_p(soe))
      t = copy_type(sizeofexpression_type(soe));
    else {
      expression se = sizeofexpression_expression(soe);
      t = expression_to_type(se);
    }
    // constant_p = !dependent_type_p(t);
    constant_p = !variable_length_array_type_p(t);
    free_type(t);
    break;
  }
  case is_syntax_subscript:
    break;
  case is_syntax_application:
    break;
  case is_syntax_va_arg:
    break;
  default:
    pips_internal_error("Unexpected syntax tag %d", syntax_tag(s));
  }
  return constant_p;
}

References call_arguments, call_function, cast_expression, const_variable_p(), constant_p(), copy_type(), entity_initial, entity_type, exp, EXPRESSION, expression_syntax, expression_to_type(), f(), FOREACH, free_type(), 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, is_value_code, is_value_constant, is_value_expression, is_value_intrinsic, is_value_symbolic, is_value_unknown, pips_internal_error, range_increment, range_lower, range_upper, reference_variable, sizeofexpression_expression, sizeofexpression_type, sizeofexpression_type_p, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_tag, type_functional_p, type_undefined, ultimate_type(), value_expression, value_tag, and variable_length_array_type_p().

Referenced by dependent_type_p(), do_simdizer_init(), do_terapix_remove_divide(), redeclaration_enter_statement(), references_must_conflict_p(), and variable_length_array_type_p().

Here is the call graph for this function:

Here is the caller graph for this function:

extended_integer_constant_expression_p()

bool extended_integer_constant_expression_p

(

expression

e

)

More extensive than next function.

Definition at line 858 of file expression.c.

{
  value v = EvalExpression(e);
  bool ice_p = false;
 
  if(value_constant_p(v)) {
    constant c = value_constant(v);
 
    ice_p = constant_int_p(c);
  }
  free_value(v);
  return ice_p;
}

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

Referenced by constant_points_to_indices_p(), effect_to_store_independent(), incrementation_expression_to_increment(), opgen_may_vreference(), points_to_indices_to_subscript_indices(), proper_to_summary_simple_effect(), reference_to_points_to_translations(), reference_with_constant_indices_p(), reference_with_store_independent_indices(), reference_with_unbounded_indices_p(), and store_independent_points_to_indices_p().

Here is the call graph for this function:

Here is the caller graph for this function:

extended_integer_constant_expression_p_to_int()

bool extended_integer_constant_expression_p_to_int	(	expression	e,
		int *	result
	)

Parameters

result

esult

Definition at line 874 of file expression.c.

{
  value v = EvalExpression(e);
  bool ice_p = false;
 
  if(value_constant_p(v)) {
    constant c = value_constant(v);
 
    ice_p = constant_int_p(c);
    if (ice_p) *result = constant_int(c);
  }
  free_value(v);
  return ice_p;
}

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

Referenced by perform_array_element_substitutions_in_transformer(), range_contains_at_least_one_point_p(), and range_contains_nothing_p().

Here is the call graph for this function:

Here is the caller graph for this function:

false_expression_p()

bool false_expression_p

(

expression

e

)

Definition at line 1118 of file expression.c.

{
  return operator_expression_p(e,FALSE_OPERATOR_NAME);
}

References FALSE_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

field_expression_p()

bool field_expression_p

(

expression

e

)

The expression is of kind "a", where "a" is a field of some struct "s".

Definition at line 498 of file expression.c.

{
  return expression_reference_p(e)
    && entity_field_p(reference_variable(expression_reference(e)));
}

References entity_field_p(), expression_reference(), expression_reference_p(), and reference_variable.

Referenced by complete_points_to_reference_with_fixed_subscripts(), opkill_may_vreference(), and reference_with_constant_indices_p().

Here is the call graph for this function:

Here is the caller graph for this function:

find_ith_argument()

expression find_ith_argument	(	list	args,
		int	n
	)

Parameters

args

rgs

Definition at line 1147 of file expression.c.

{
    int i;
    pips_assert("find_ith_argument", n > 0);
 
    for(i=1; i<n && !ENDP(args); i++, POP(args))
        ;
    if(i==n && !ENDP(args))
        return EXPRESSION(CAR(args));
    else
        return expression_undefined;
}

References CAR, ENDP, EXPRESSION, expression_undefined, pips_assert, and POP.

Referenced by abc_with_allocation_size(), add_formal_to_actual_bindings(), bottom_up_abc_base_reference_implied_do(), bottom_up_abc_reference(), formal_and_actual_parameters_association(), fortran_user_call_to_transformer(), initial_code_abc_reference(), list_of_same_or_equivalence_arguments(), offset_in_caller(), same_dimension_p(), same_or_equivalence_argument_add_aliases(), size_of_actual_array(), subscript_value(), subscript_value_stride(), top_down_abc_call(), and translate_to_module_frame().

Here is the caller graph for this function:

find_ith_expression()

expression find_ith_expression	(	list	le,
		int	r
	)

find_ith_expression() is obsolet; use find_ith_argument() instead

the first element is one

two local variables, useless but for debugging

Parameters

le

e

Definition at line 1161 of file expression.c.

{
    /* the first element is one */
    /* two local variables, useless but for debugging */
    list cle;
    int i;
 
    pips_assert("find_ith_expression", r > 0);
 
    for(i=r, cle=le ; i>1 && !ENDP(cle); i--, POP(cle))
        ;
 
    if(ENDP(cle))
        pips_internal_error("not enough elements in expresion list");
 
    return EXPRESSION(CAR(cle));
}

References CAR, ENDP, EXPRESSION, pips_assert, pips_internal_error, and POP.

Referenced by set_dimensions_of_local_variable_family().

Here is the caller graph for this function:

float_to_expression()

expression float_to_expression

(

float

c

)

Definition at line 1229 of file expression.c.

{
    entity e = float_to_entity(c);
    return call_to_expression(make_call(e,NIL));
}

References call_to_expression(), float_to_entity(), make_call(), and NIL.

Referenced by complex_to_expression(), make_0val_expression(), make_1val_expression(), monome_to_expression(), and set_the_i().

Here is the call graph for this function:

Here is the caller graph for this function:

fortran_string_compare()

int fortran_string_compare	(	string	fs1,
		string	fs2
	)

compare pips fortran string constants from the fortran point of view.

expression.c

as of 3.1 and 6.3.5 of the Fortran 77 standard, the character order is not fully specified. It states:

• A < B < C ... < Z
• 0 < 1 < 2 ... < 9
• blank < 0
• blank < A
• 9 < A OR Z < 0 since these rules are ascii compatible, we'll take ascii. in practice, this may be implementation dependent?

Parameters

fs1	constant fortran string (entity name is fine)
fs2	constant fortran string (entity name is fine)

Returns

-n 0 +n depending on < == >, n first differing char.

skip headers, trailers...

collating sequence comparison.

equal string header case.

Parameters

fs1	s1
fs2	s2

Definition at line 101 of file expression.c.

{
  int l1, l2, i, c = 0;
  string s1, s2;
 
  /* skip headers, trailers... */
  s1 = actual_fortran_string_to_compare(fs1, &l1);
  s2 = actual_fortran_string_to_compare(fs2, &l2);
 
  /* collating sequence comparison. */
  for (i=0; c==0 && i<l1 && i<l2; i++)
  {
    if (s1[i] < s2[i]) c = -i-1;
    if (s1[i] > s2[i]) c = i+1;
  }
 
  /* equal string header case. */
  if (c==0 && l1!=l2)
    c = (l1<l2)? -l1-1: l2+1;
 
  return c;
}

References actual_fortran_string_to_compare(), and s1.

Referenced by constant_constraint_check().

Here is the call graph for this function:

Here is the caller graph for this function:

free_expressions()

void free_expressions

(

list

el

)

Free a list of expressions.

Parameters

el

l

Definition at line 4084 of file expression.c.

{
  FOREACH(EXPRESSION,e, el)
    free_expression(e);
}

References EXPRESSION, FOREACH, and free_expression().

Referenced by user_call_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

generic_reference_add_fixed_subscripts()

void generic_reference_add_fixed_subscripts	(	reference	r,
		type	t,
		bool	zero_p
	)

Add a set of zero subscripts to a reference "r" by side effect.

Used when array names or partial array references have to to converted to the first array element.

Parameters

zero_p

ero_p

Definition at line 236 of file expression.c.

{
  pips_assert("type is of kind variable", type_variable_p(t));
  variable v = type_variable(t);
  //list rsl = reference_indices(r);
 
  // FI: this assert makes sense within the ri-util framework but is
  // too strong for the kind of references used in effects-util
  // pips_assert("scalar type", ENDP(reference_indices(r)));
 
  list dl = variable_dimensions(v);
  //
  //pips_assert("Reference r is correct", gen_length(dl)>=gen_length(rsl));
  //
  //FOREACH(EXPRESSION, rs, rsl)
  //  POP(dl);
  list sl = NIL; // subscript list
  FOREACH(DIMENSION, d, dl) {
    expression s = zero_p? int_to_expression(0) : make_unbounded_expression();
    // reference_indices(r) = CONS(EXPRESSION, s, reference_indices(r));
    sl = CONS(EXPRESSION, s, sl);
  }
  reference_indices(r) = gen_nconc(reference_indices(r), sl);
}

References CONS, DIMENSION, EXPRESSION, FOREACH, gen_nconc(), int_to_expression(), make_unbounded_expression(), NIL, pips_assert, reference_indices, type_variable, type_variable_p, and variable_dimensions.

Referenced by reference_add_unbounded_subscripts(), and reference_add_zero_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

iabs_expression_p()

bool iabs_expression_p

(

expression

e

)

Definition at line 1036 of file expression.c.

{
    return operator_expression_p(e, IABS_OPERATOR_NAME);
}

References IABS_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

int_to_expression()

expression int_to_expression

(

_int

i

)

transform an int into an expression and generate the corresponding entity if necessary; it is not clear if strdup() is always/sometimes necessary and if a memory leak occurs; wait till syntax/expression.c is merged with ri-util/expression.c

Negative constants do not seem to be included in PIPS internal representation.

special hook for VALUE_MIN: the problem is that VALUE_MIN cannot be represented in the IR because -VALUE_MIN does not fit into and _int, so we replace it by VALUE_MIN -1, which is still big ...

Definition at line 1188 of file expression.c.

{
    bool negative_p = i<0;
    /* special hook for VALUE_MIN:
       the problem is that VALUE_MIN cannot be represented in the IR because
       -VALUE_MIN does not fit into and _int, so we replace it by VALUE_MIN -1,
       which is still big ... */
    if(negative_p)
      while(i==-i) { // ie while we have an integer overflow
        ++i;
      }
    // it is unclear whether to call abs/labs/llabs...
    entity e = int_to_entity(negative_p? -i: i);
    expression exp =  call_to_expression(make_call(e, NIL));
    if(negative_p)
      exp = MakeUnaryCall(entity_intrinsic(UNARY_MINUS_OPERATOR_NAME), exp);
    return exp;
}

References call_to_expression(), entity_intrinsic(), exp, int_to_entity(), make_call(), MakeUnaryCall(), NIL, and UNARY_MINUS_OPERATOR_NAME.

Referenced by abc_with_allocation_size(), add_initialization_expression(), add_integer_to_expression(), add_prettyprint_control_list_to_declaration_statement(), add_reduction(), ajoute_constante(), ajoute_new_var(), alias_check(), alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), analyze_expression(), any_basic_update_operation_to_transformer(), any_basic_update_to_transformer_list(), array_access_to_array_ranges(), array_as_template(), array_indices_check(), array_indices_communication(), array_ranges_to_template_ranges(), array_scalar_access_to_bank_communication(), array_scalar_access_to_compute_communication(), array_size_stride(), basic_update_reflhs_with_rhs_to_transformer(), bdt_save_int(), bdt_save_pred(), bottom_up_abc_expression_implied_do(), bound_generation(), bound_to_statement(), bounds_of_expression(), build_bdt_null(), build_call_STEP_init_regionArray(), build_first_comb(), build_flag_assign(), build_flag_test(), build_local_time_test(), build_third_comb(), c_convex_effects_on_actual_parameter_forward_translation(), c_dim_string(), C_loop_range(), c_text_entity(), call_nary_rwt(), check_loop_distribution_feasability(), code_generation(), comEngine_generate_procCode(), compile_master(), compile_one_reduction(), compile_reduction(), complementary_range(), complete_points_to_reference_with_fixed_subscripts(), complex_bound_generation(), compute_final_index_value(), compute_receive_content(), compute_receive_domain(), constant_image_p(), constant_reference_to_normalized_constant_reference(), constraints_to_loop_bound(), contraintes_to_expression(), convert_bound_expression(), create_counter(), create_externalized_function_common(), create_pointer_to_array_stub_points_to(), create_stub_points_to(), CreateLogicalUnits(), cstr_args_check(), ctx_generate_new_statement_cluster_dependant(), dag_normalize(), dag_simplify(), DeclarePointer(), define_node_processor_id(), dimension_to_range(), distance_between_entity(), distance_between_expression(), do_brace_expression_to_statements(), do_brace_expression_to_updated_type(), do_gather_all_expressions(), do_group_constants_terapix(), do_group_count_elements(), do_group_count_elements_reduce(), do_isolate_statement_preconditions_satisified_p(), do_linearize_array_reference(), do_linearize_prepatch(), do_linearize_prepatch_subscript(), do_linearize_prepatch_type(), do_linearize_type(), do_loop_expansion(), do_loop_expansion_init(), do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), do_simdizer_auto_tile_int_to_list(), do_solve_hardware_constraints_on_nb_proc(), do_solve_hardware_constraints_on_volume(), do_symbolic_tiling(), do_terapix_remove_divide(), dynamic_alias_check_flt(), ecrit_une_var(), ecrit_une_var_neg(), edge_cost_polynome(), effects_to_dma(), enclose_in_a_parallel_loop(), entity_ith_bounds(), expand_call(), expr_compute_local_index(), expression_plusplus(), expression_try_find_size(), expression_try_find_string_size(), extract_the_align(), fix_if_condition(), flow_sensitive_malloc_to_points_to_sinks(), free_guards(), full_loop_unroll(), fusion(), fusion_buffer(), gen_mpi_send_recv(), generate_call_get_workchunk_loopbounds(), generate_call_set_regionarray(), generate_code(), generate_compact(), generate_copy_loop_nest(), generate_fifo_stat(), generate_full_copy(), generate_ind_fifo_stat2(), generate_io_wp65_code(), generate_loop_workchunk(), generate_mmcd_stat_from_ref(), generate_monome(), generate_one_message(), generate_prelude(), generate_remapping_guard(), generate_stat_from_ref_list_proc(), generate_stat_from_ref_list_proc_list(), generate_subarray_shift(), GenerateReturn(), generic_effect_find_aliases_with_simple_pointer_values(), generic_reference_add_fixed_subscripts(), get_complement_expression(), get_fifo_from_ref(), get_indExp_from_ref(), get_sizeofexpression_for_region(), gfc2pips_array_ref2indices(), gfc2pips_code2instruction_(), gfc2pips_get_list_of_dimensions2(), gfc2pips_int2dimension(), gfc2pips_vars_(), heap_intrinsic_to_post_pv(), Hierarchical_tiling(), hpfc_add_2(), hpfc_add_n(), hpfc_broadcast_buffers(), hpfc_buffer_initialization(), hpfc_compute_lid(), hpfc_init_run_time_entities(), if_different_pe_and_not_twin(), impact_check(), incrementation_expression_to_increment(), initialization_list_to_statements(), InitializeEnumMemberValues(), inline_statement_crawler(), interprocedural_abc_arrays(), intrinsic_call_to_points_to(), live_mapping_expression(), loop_annotate(), loop_flt(), loop_nest_to_wp65_code(), loop_normalize_of_loop(), loop_strip_mine(), lower_bound_generation(), make_0val_expression(), make_1val_expression(), make_abc_count_statement(), make_array_bounds(), make_bound_expression(), make_bounds(), make_c_stop_statement(), make_condition_from_loop(), make_constraint_expression(), make_datum_movement(), make_emulated_shared_variable(), make_exec_mmcd(), make_exit_statement(), make_expression_with_state_variable(), make_factor_expression(), make_global_common_and_initialize(), make_guard_expression(), make_increment_instruction(), make_increment_statement(), make_init_newInd_stat(), make_lInitStats(), make_list_of_constant(), make_list_of_flags(), make_loadsave_statement(), make_loop_skeleton(), make_lSwitchStats(), make_max_exp(), make_maxval_expression(), make_minval_expression(), make_mmcd_load_store_stat(), make_movement_scalar_wp65(), make_movements_loop_body_wp65(), make_mypos_expression(), make_new_simd_vector_with_prefix(), make_op_exp(), make_rational_exp(), make_reduction_vector_entity(), make_reindex(), make_scanning_over_one_tile(), make_scanning_over_tiles(), make_send_receive_conversion(), make_set_rc_statement(), make_shuffle_statement(), make_special_value(), make_state_variable_assignement_statement(), make_step_inc_statement(), make_toggle_inc_statement(), make_toggle_init_statement(), make_toggle_mmcd(), make_transStat(), make_unbounded_dimensions(), make_vecteur_expression(), make_zero_expression(), MakeArithmIfInst(), MakeAssignedOrComputedGotoInst(), MakeAtom(), MakeDataValueSet(), MakeDimension(), MakeForloop(), MakeIoFileArray(), MakeIoInstA(), MakeWhileDoInst(), malloc_arg_to_type(), merge_lists(), module_initial_parameter_pv(), monome_to_expression(), mpic_make_args_mpi_send_or_receiv(), ndf_normalized_test(), new_local_image_variable(), NewDeclarationOfDistributedArray(), normalize_integer_constant_expression(), normalize_test_leaves(), NormalizeOneTemplateDistribution(), offset_array_reference(), offset_in_caller(), offset_of_struct(), offset_points_to_cell(), original_malloc_to_abstract_location(), outliner_extract_loop_bound(), outliner_patch_parameters(), outliner_smart_references_computation(), overlap_redefine_expression(), parallel_tiling(), perform_array_element_substitutions_in_transformer(), phi_free_contraints_to_expressions(), points_to_cell_types_compatibility(), points_to_cell_update_last_subscript(), polynome_to_expression(), pragma_build_if_condition(), predicate_to_expression(), prepare_array_bounds(), prgm_mapping(), promote_statement(), propagate_constant_image(), psystem_to_expression(), ram_variable_add_aliases(), range_to_expression(), rational_op_exp(), rational_sol_edit(), re_do_it(), reference_add_field_dimension(), reference_add_zero_subscript(), reference_complete_with_zero_subscripts(), reference_filter(), reference_offset(), reference_to_points_to_sinks(), reference_to_points_to_translations(), regenerate_expression(), region_to_address(), region_to_minimal_dimensions(), rename_reduction_ref_walker(), replace_reductions_in_statement(), safe_static_domain_bound(), same_or_equivalence_argument_add_aliases(), save_int(), save_pred(), sc_delimiter(), sc_opposite_exp_of_conjunction(), sesamify(), set_array_status_to_target(), set_dimensions_of_local_variable_family(), shape_one_message(), simdizer_auto_tile(), simplified_reference(), simplify_complex_entity(), simplify_complex_expression(), simplify_dimension(), simplify_relational_expression(), size_of_actual_array(), size_of_dummy_array(), size_of_regions(), SizeOfDimension(), SizeOfDimensions(), split_complex_expression(), sprintf_check_expression(), st_compute_current_computer(), st_compute_current_owners(), st_compute_neighbour(), statement_compute_bounds(), step_local_loopSlices(), step_local_regionArray(), step_parameter(), storage_ram_offset(), subscript_expressions_to_constant_subscript_expressions(), subscript_value(), subscript_value_stride(), substitute_and_create(), substitute_struct_stub_in_transformer(), systeme_to_loop_nest(), template_ranges_to_processors_ranges(), test_bound_generation(), Tiling2_buffer(), Tiling_buffer_allocation(), tiling_transformation(), top_down_abc_dimension(), type_to_array_type(), unary_into_binary_ref(), unary_intrinsic_call_to_points_to_sinks(), update_indices_for_local_computation(), update_operator_to_post_pv(), update_range(), upper_bound_generation(), usual_loop_tiling(), Value_to_expression(), variable_initial_expression(), variable_to_dimensions(), verify_array_element(), verify_array_variable(), verify_scalar_variable(), and words_dimension().

Here is the call graph for this function:

integer_constant_expression_p()

bool integer_constant_expression_p

(

expression

e

)

positive integer constant expression: call to a positive constant or to a sum of positive integer constant expressions (much too restrictive, but enough for the source codes submitted to PIPS up to now).

Likely to fail and need further extension if subtraction and multiplication are used as probably allowed by C standard.

NormalizeExpression() could be used instead, as it is in fact to compute the value of the expression.

Use previous function instead of this one, and -1 will be a constant...

Definition at line 903 of file expression.c.

{
  syntax s = expression_syntax(e);
  bool ice = false;
 
  if(syntax_call_p(s)) {
    call c = syntax_call(s);
    entity cst = call_function(c);
    list args = call_arguments(c);
    int i;
 
    if(integer_constant_p(cst, &i)) {
      ice = true;
    }
    else if(integer_symbolic_constant_p(cst, &i)) {
      ice = true;
    }
    else if(ENTITY_PLUS_P(cst)||ENTITY_PLUS_C_P(cst)) {
      expression e1 = EXPRESSION(CAR(args));
      expression e2 = EXPRESSION(CAR(CDR(args)));
 
      ice = integer_constant_expression_p(e1) && integer_constant_expression_p(e2);
    }
  }
 
  return ice;
}

References call_arguments, call_function, CAR, CDR, ENTITY_PLUS_C_P, ENTITY_PLUS_P, EXPRESSION, expression_syntax, integer_constant_p(), integer_symbolic_constant_p(), syntax_call, and syntax_call_p.

Referenced by full_define_p(), get_final_offset(), integer_constant_expression_value(), integer_divide_to_transformer(), integer_right_shift_to_transformer(), make_send_receive_conversion(), sentence_data_statement(), signed_integer_constant_expression_p(), and test_working_false().

Here is the call graph for this function:

Here is the caller graph for this function:

integer_constant_expression_value()

int integer_constant_expression_value

(

expression

e

)

Definition at line 1545 of file expression.c.

{
  pips_assert("is constant", integer_constant_expression_p(e));
  return signed_integer_constant_expression_value(e);
}

References integer_constant_expression_p(), pips_assert, and signed_integer_constant_expression_value().

Referenced by c_text_related_entities(), full_define_p(), get_final_offset(), integer_divide_to_transformer(), and integer_right_shift_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

integer_expression_p()

bool integer_expression_p

(

expression

e

)

Definition at line 601 of file expression.c.

{
  basic b = basic_of_expression(e);
  bool integer_p = basic_int_p(b);
 
  free_basic(b);
  return integer_p;
}

References basic_int_p, basic_of_expression(), and free_basic().

Referenced by fix_if_condition(), and points_to_cell_to_upper_bound_points_to_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_reference_to_entity_p()

bool is_expression_reference_to_entity_p	(	expression	e,
		entity	v
	)

Test if an expression is a reference to a given variable entity.

Definition at line 541 of file expression.c.

{
  bool is_e_reference_to_v = false;
 
  if(expression_reference_p(e)) {
    reference r = syntax_reference(expression_syntax(e));
 
    is_e_reference_to_v = (reference_variable(r)==v);
  }
  return is_e_reference_to_v;
}

References expression_reference_p(), expression_syntax, reference_variable, and syntax_reference.

Referenced by incrementation_expression_to_increment().

Here is the call graph for this function:

Here is the caller graph for this function:

local_assign_expression()

void local_assign_expression	(	expression	caller,
		expression	field
	)

replace expression caller by expression field , where field is contained by caller

Parameters

caller	aller
field	ield

Definition at line 3571 of file expression.c.

{
     syntax s = expression_syntax(field) ;
     expression_syntax(field)=syntax_undefined;
     free_syntax(expression_syntax(caller));
     expression_syntax(caller)=s;
     free_normalized(expression_normalized(caller));
}

References expression_normalized, expression_syntax, free_normalized(), free_syntax(), and syntax_undefined.

Referenced by simplify_minmax_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_expression_p()

bool logical_expression_p

(

expression

e

)

A logical expression is either one of the following:

• a logical constant
• the symbolic name of a logical constant
• a logical variable name
• a logical array element name
• a logical function reference
• a relational expression (.LT.,.LE.,.EQ.,.NE.,.GT.,.GE.)
• is formed by combining together one or more of the above entities using parentheses and the logical operators .NOT.,.AND.,.OR.,.EQV.,.NEQV.

NN: In fact, I didn't use the PIPS function : basic_of_expression because of 2 reasons :

• the function basic_of_intrinsic use the macro : ENTITY_LOGICAL_OPERATOR_P which is not like the Fortran Standard definition (the above comments)
• the case where an expression is a range is not considered here for a logical expression

The case of symbolic name of a logical constant is not treated here

Definition at line 610 of file expression.c.

{
  /* A logical expression is either one of the following:
   * - a logical constant
   * - the symbolic name of a logical constant
   * - a logical variable name
   * - a logical array element name
   * - a logical function reference
   * - a relational expression (.LT.,.LE.,.EQ.,.NE.,.GT.,.GE.)
   * - is formed by combining together one or more of the above
   *   entities using parentheses and the logical operators
   *   .NOT.,.AND.,.OR.,.EQV.,.NEQV. */
 
  /* NN:  In fact, I didn't use the PIPS function : basic_of_expression because of 2 reasons :
   * - the function basic_of_intrinsic use the macro : ENTITY_LOGICAL_OPERATOR_P
   *   which is not like the Fortran Standard definition (the above comments)
   * - the case where an expression is a range is not considered here for a
   *   logical expression */
 
  syntax s = expression_syntax(e);
  basic b;
  entity func;
 
  pips_debug(2, "\n");
 
  switch(syntax_tag(s)) {
  case is_syntax_reference:
    {
      b = variable_basic(type_variable(entity_type(reference_variable(syntax_reference(s)))));
      if (basic_logical_p(b))
        return true;
      return false;
    }
  case is_syntax_call:
    {
      if (operator_expression_p(e,TRUE_OPERATOR_NAME) ||
          operator_expression_p(e,FALSE_OPERATOR_NAME) ||
          relational_expression_p(e)||
          logical_operator_expression_p(e) )
        return true;
      func = call_function(syntax_call(expression_syntax(e)));
      b = variable_basic(type_variable(functional_result(type_functional(entity_type(func)))));
      if (basic_logical_p(b)) return true;
 
      /* The case of symbolic name of a logical constant is not treated here */
 
      return false;
    }
  case is_syntax_range:
    return false;
  default: pips_internal_error("Bad syntax tag");
    return false;
  }
 
  debug(2, "logical expression", " ends\n");
}

References basic_logical_p, call_function, debug(), entity_type, expression_syntax, FALSE_OPERATOR_NAME, functional_result, is_syntax_call, is_syntax_range, is_syntax_reference, logical_operator_expression_p(), operator_expression_p(), pips_debug, pips_internal_error, reference_variable, relational_expression_p(), syntax_call, syntax_reference, syntax_tag, TRUE_OPERATOR_NAME, type_functional, type_variable, and variable_basic.

Referenced by fix_if_condition(), and MakeWhileDoInst().

Here is the call graph for this function:

Here is the caller graph for this function:

logical_operator_expression_p()

bool logical_operator_expression_p

(

expression

e

)

C xor is missing.

Logical operators are : .NOT.,.AND.,.OR.,.EQV.,.NEQV.

Definition at line 573 of file expression.c.

{
  /* Logical operators are : .NOT.,.AND.,.OR.,.EQV.,.NEQV.*/
  if (expression_call_p(e))
    {
      entity op = call_function(syntax_call(expression_syntax(e)));
      if (ENTITY_AND_P(op) || ENTITY_OR_P(op) || ENTITY_NOT_P(op) ||
          ENTITY_EQUIV_P(op) ||ENTITY_NON_EQUIV_P(op))
        return true;
      return false;
    }
  return false;
}

References call_function, ENTITY_AND_P, ENTITY_EQUIV_P, ENTITY_NON_EQUIV_P, ENTITY_NOT_P, ENTITY_OR_P, expression_call_p(), expression_syntax, and syntax_call.

Referenced by logical_expression_p(), number_of_operators_flt(), and simplify_boolean_expression_with_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

make_address_of_expression()

expression make_address_of_expression

(

expression

e

)

generate a newly allocated expression for &(e)

Definition at line 3956 of file expression.c.

{
  if (expression_call_p(e))
  {
    call c = expression_call(e);
    if (ENTITY_DEREFERENCING_P(call_function(c))) // e is "*x"
    {
      pips_assert("one arg to address operator (&)",
                  gen_length(call_arguments(c))==1);
 
      // result is simply "x"
      return copy_expression(EXPRESSION(CAR(call_arguments(c))));
    }
  }
 
  // result is "*e"
  return MakeUnaryCall(CreateIntrinsic(ADDRESS_OF_OPERATOR_NAME),
                       copy_expression(e));
}

References ADDRESS_OF_OPERATOR_NAME, call_arguments, call_function, CAR, copy_expression(), CreateIntrinsic(), ENTITY_DEREFERENCING_P, EXPRESSION, expression_call(), expression_call_p(), gen_length(), MakeUnaryCall(), and pips_assert.

Referenced by declaration_to_post_pv(), gen_mpi_send_recv(), make_send_receive_conversion(), mpi_initialize(), mpic_make_args_mpi_send_or_receiv(), mpic_make_mpi_comm_rank(), mpic_make_mpi_comm_size(), and mpic_make_mpi_init().

Here is the call graph for this function:

Here is the caller graph for this function:

make_assign_expression()

expression make_assign_expression	(	expression	lhs,
		expression	rhs
	)

Make an assign expression, since in C the assignment is a side effect operator.

Useful in for-loops.

Parameters

lhs	must be a reference
rhs	is the expression to assign

Returns

the expression "lhs = rhs"

RK: this assert should be relaxed to deal with *p and so on. pips_assert("Need a reference as lhs", expression_reference_p(lhs));

Parameters

lhs	hs
rhs	hs

Definition at line 390 of file expression.c.

                                       {
  /* RK: this assert should be relaxed to deal with *p and so on.
     pips_assert("Need a reference as lhs", expression_reference_p(lhs)); */
  return MakeBinaryCall(CreateIntrinsic(ASSIGN_OPERATOR_NAME), lhs, rhs);
}

References ASSIGN_OPERATOR_NAME, CreateIntrinsic(), and MakeBinaryCall().

Referenced by do_loop_nest_unswitching(), and do_loop_to_for_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

make_call_expression()

expression make_call_expression	(	entity	e,
		list	l
	)

Build an expression that call an function entity with an argument list.

Parameters

e	is the function entity to call
l	is the list of argument expressions given to the function to call

Definition at line 321 of file expression.c.

{
  return call_to_expression(make_call(e, l));
}

References call_to_expression(), and make_call().

Referenced by alloc_instrumentation(), compile_reduction(), constraints_to_loop_bound(), expression_plusplus(), gfc2pips_symbol2data_instruction(), hpfc_compute_lid(), init_c_implicit_variables(), make_addition(), make_bin_expression(), make_C_print_statement(), make_false_expression(), make_special_value(), make_stop_statement(), make_strlen_expression(), make_test_condition(), make_true_expression(), MakeBinaryCall(), MakeBraceExpression(), MakeCommaExpression(), MakeDataStatement(), MakeDataValueSet(), MakeForloop(), MakeFunctionExpression(), MakeNullaryCall(), MakeTernaryCall(), MakeUnaryCall(), sprintf_check_expression(), and step_function().

Here is the call graph for this function:

Here is the caller graph for this function:

make_constraint_expression()

expression make_constraint_expression	(	Pvecteur	v,
		Variable	index
	)

Make an expression from a constraint v for a given index.

For example: for a constraint of index I : aI + linear_expr(J,K,TCST) <=0

Returns

the new expression for I that is -expr_linear(J,K,TCST)/a

earch the couple (var,val) where var is equal to index and extract it

If the vector wihout the index is the vector null, we have simply index = 0:

If the coefficient for the index is positive, inverse all the vector since the index goes at the other side of "=":

If coeff is negative, correct the future division rounding (by -coeff) by adding (coeff - 1) to the vector first:

If the vector is simply coeff.index=c, directly generate and return c/coeff:

Generate an expression from the linear vector:

If coeff > 1, divide all the expression by coeff:

FI->YY: before generating a division, you should test if it could not be performed statically; you have to check if ex1 is not a constant expression, which is fairly easy since you still have its linear form, pv

build expressions for the lower and upper bounds

Parameters

index

ndex

Definition at line 1748 of file expression.c.

{
  Pvecteur pv;
  expression ex1, ex2, ex;
  entity div;
  Value coeff;
 
  /*search the couple (var,val) where var is equal to index and extract it */
  pv = vect_dup(v);
  coeff = vect_coeff(index, pv);
  vect_erase_var(&pv, index);
 
  if (VECTEUR_NUL_P(pv))
    /* If the vector wihout the index is the vector null, we have simply
       index = 0: */
    return int_to_expression(0);
 
  /* If the coefficient for the index is positive, inverse all the
     vector since the index goes at the other side of "=": */
  if (value_pos_p(coeff))
    vect_chg_sgn(pv);
  else {
    /* If coeff is negative, correct the future division rounding (by
       -coeff) by adding (coeff - 1) to the vector first: */
    value_absolute(coeff);
    vect_add_elem(&pv, TCST, value_minus(coeff, VALUE_ONE));
  }
 
  if(vect_size(pv) == 1 && vecteur_var(pv) == TCST) {
    /* If the vector is simply coeff.index=c, directly generate and
       return c/coeff: */
    vecteur_val(pv) = value_pdiv(vecteur_val(pv), coeff);
    return make_vecteur_expression(pv);
  }
 
  /* Generate an expression from the linear vector: */
  ex1 = make_vecteur_expression(pv);
 
  if (value_gt(coeff, VALUE_ONE)) {
    /* If coeff > 1, divide all the expression by coeff: */
    /* FI->YY: before generating a division, you should test if it could
       not be performed statically; you have to check if ex1 is not a
       constant expression, which is fairly easy since you still have
       its linear form, pv */
    /* build expressions for the lower and upper bounds */
    if( c_language_module_p(get_current_module_entity()) && !get_bool_property("PRETTYPRINT_DIV_INTRINSICS"))
        div= entity_intrinsic(PIPS_C_DIV_OPERATOR_NAME);
    else  // Fortran case and C intrinsics requested
       div = gen_find_tabulated("TOP-LEVEL:/",entity_domain);
     pips_assert("Division operator not found", div != entity_undefined);
 
    ex2 = int_to_expression(VALUE_TO_INT(coeff));
    ex = make_expression(make_syntax(is_syntax_call,
                                     make_call(div,
                                               CONS(EXPRESSION,ex1,
                                                    CONS(EXPRESSION,
                                                         ex2,NIL)))),
                         normalized_undefined);
    return(ex);
  }
  else
    return(ex1);
}

References c_language_module_p(), CONS, entity_domain, entity_intrinsic(), entity_undefined, EXPRESSION, gen_find_tabulated(), get_bool_property(), get_current_module_entity(), int_to_expression(), is_syntax_call, make_call(), make_expression(), make_syntax(), make_vecteur_expression(), NIL, normalized_undefined, pips_assert, PIPS_C_DIV_OPERATOR_NAME, TCST, value_absolute, value_gt, value_minus, VALUE_ONE, value_pdiv, value_pos_p, VALUE_TO_INT, vect_add_elem(), vect_chg_sgn(), vect_coeff(), vect_dup(), vect_erase_var(), vect_size(), VECTEUR_NUL_P, vecteur_val, and vecteur_var.

Referenced by make_bound_expression(), and make_contrainte_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

make_contrainte_expression()

expression make_contrainte_expression	(	Pcontrainte	pc,
		Variable	index
	)

A wrapper around make_constraint_expression() for compatibility.

Simply call the function on the vector in the constrain system:

Parameters

pc	c
index	ndex

Definition at line 1815 of file expression.c.

                                                                      {
  /* Simply call the function on the vector in the constrain system: */
  return make_constraint_expression(pc->vecteur, index);
}

References make_constraint_expression(), and Scontrainte::vecteur.

Referenced by free_guards().

Here is the call graph for this function:

Here is the caller graph for this function:

make_entity_expression()

expression make_entity_expression	(	entity	e,
		cons *	inds
	)

Parameters

inds

nds

Definition at line 176 of file expression.c.

{
  syntax s = syntax_undefined;
  if( entity_constant_p(e) )
    {
      s = make_syntax_call(make_call(e,NIL));
    }
  else
    {
      reference r = make_reference(e, inds);
      s = make_syntax_reference(r);
    }
  return syntax_to_expression(s);
}

References entity_constant_p, make_call(), make_reference(), make_syntax_call(), make_syntax_reference(), NIL, syntax_to_expression(), and syntax_undefined.

Referenced by alloc_instrumentation(), assign_tmp_to_exp(), atomizer_of_external(), build_flag_assign(), build_flag_test(), build_global_time_test_with_exp(), build_local_time_test(), build_third_comb(), cstr_args_check(), distribute_code(), edge_cost_polynome(), expression_try_find_size(), find_tmp_of_exp(), gen_mpi_send_recv(), get_sp_of_call_p(), loop_header(), loop_inc(), loop_normalize_of_loop(), loop_test(), make_array_communication_statement(), make_com_loopbody(), make_communication_statement(), make_increment_instruction(), make_init_time(), make_loadsave_statement(), make_send_receive_conversion(), make_start_ru_module(), mpi_finalize(), mpi_initialize(), mpic_make_args_mpi_send_or_receiv(), mpic_make_mpi_comm_rank(), mpic_make_mpi_comm_size(), mpic_make_mpi_init(), put_source_ind(), sprintf_check_expression(), and task_time_polynome().

Here is the call graph for this function:

Here is the caller graph for this function:

make_factor_expression()

expression make_factor_expression	(	int	coeff,
		entity	vari
	)

Some functions to generate expressions from vectors and constraint systems.

expression make_factor_expression(int coeff, entity vari) make the expression "coeff*vari" where vari is an entity.

a constant only

Parameters

coeff	oeff
vari	ari

Definition at line 1631 of file expression.c.

{
  expression e1, e2, e3;
 
  e1 = int_to_expression(coeff);
  if (vari==NULL)
    return(e1);                 /* a constant only */
  else {
    e2 = entity_to_expression(vari);
    if (coeff == 1) return(e2);
    else {
      e3 = MakeBinaryCall(entity_intrinsic(MULTIPLY_OPERATOR_NAME),e1,e2);
      return (e3);
    }
  }
}

References entity_intrinsic(), entity_to_expression(), int_to_expression(), MakeBinaryCall(), and MULTIPLY_OPERATOR_NAME.

Referenced by ecrit_une_var(), icm_loop_rwt(), and make_vecteur_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

make_false_expression()

expression make_false_expression

(

void

)

Definition at line 1108 of file expression.c.

{
  return make_call_expression(MakeConstant(FALSE_OPERATOR_NAME,is_basic_logical),NIL);
}

References FALSE_OPERATOR_NAME, is_basic_logical, make_call_expression(), MakeConstant(), and NIL.

Referenced by simplify_boolean_expression_with_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

make_lin_op_exp()

expression make_lin_op_exp	(	entity	op_ent,
		expression	exp1,
		expression	exp2
	)

================================================================

expression make_lin_op_exp(entity op_ent, expression exp1 exp2): returns the expression resulting of the linear operation (ie. + or -) "op_ent" between two integer linear expressions "exp1" and "exp2".

This function uses the linear library for manipulating Pvecteurs. exp1 and exp2 are freed

Pvecteur_to_expression() is a function that rebuilds an expression from a Pvecteur.

Parameters

op_ent	p_ent
exp1	xp1
exp2	xp2

Definition at line 2147 of file expression.c.

{
  Pvecteur V1, V2, newV = VECTEUR_NUL;
 
  debug( 7, "make_lin_op_exp", "doing\n");
  if(normalized_complex_p(expression_normalized(exp1)) ||
     normalized_complex_p(expression_normalized(exp2)) )
    pips_internal_error( "expressions MUST be linear and normalized");
 
  V1 = (Pvecteur) normalized_linear(expression_normalized(exp1));
  V2 = (Pvecteur) normalized_linear(expression_normalized(exp2));
 
  if (ENTITY_PLUS_P(op_ent))
    newV = vect_add(V1, V2);
  else if (ENTITY_MINUS_P(op_ent))
    newV = vect_substract(V1, V2);
  else
    pips_internal_error("operation must be : + or -");
  free_expression(exp1);
  free_expression(exp2);
 
  return(Pvecteur_to_expression(newV));
}

References debug(), ENTITY_MINUS_P, ENTITY_PLUS_P, expression_normalized, free_expression(), normalized_complex_p, normalized_linear, pips_internal_error, Pvecteur_to_expression(), vect_add(), vect_substract(), and VECTEUR_NUL.

Referenced by make_op_exp(), and rational_op_exp().

Here is the call graph for this function:

Here is the caller graph for this function:

make_list_of_constant()

list make_list_of_constant	(	int	val,
		int	number
	)

of expression

the length of the created list

Parameters

val	al
number	the constant value

Definition at line 3369 of file expression.c.

{
  list l=NIL;
 
  pips_assert("valid number", number>=0);
  for(; number; number--)
    l = CONS(EXPRESSION, int_to_expression(val), l);
 
  return l;
}

References CONS, EXPRESSION, int_to_expression(), NIL, and pips_assert.

Referenced by hpfc_compute_lid(), st_compute_current_computer(), st_compute_current_owners(), and translate_to_module_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

make_max_expression()

expression make_max_expression	(	expression	e1,
		expression	e2,
		enum language_utype	lang
	)

Parameters

e1	1
e2	2
lang	ang

Definition at line 1579 of file expression.c.

{
  expression new_exp = expression_undefined;
  if (lang == is_language_c)
    {
      expression comp_exp = MakeBinaryCall(entity_intrinsic(C_LESS_THAN_OPERATOR_NAME),
                                           copy_expression(e1),
                                           copy_expression(e2));
      new_exp = MakeTernaryCall(entity_intrinsic(CONDITIONAL_OPERATOR_NAME),
                               comp_exp,
                               e2,
                               e1);
    }
  else
    {
      new_exp = MakeBinaryCall(entity_intrinsic(MAX_OPERATOR_NAME),
                               e1,e2);
    }
  return  new_exp;
}

References C_LESS_THAN_OPERATOR_NAME, CONDITIONAL_OPERATOR_NAME, copy_expression(), entity_intrinsic(), expression_undefined, is_language_c, MakeBinaryCall(), MakeTernaryCall(), and MAX_OPERATOR_NAME.

Referenced by loop_annotate().

Here is the call graph for this function:

Here is the caller graph for this function:

make_min_expression()

expression make_min_expression	(	expression	e1,
		expression	e2,
		enum language_utype	lang
	)

Parameters

e1	1
e2	2
lang	ang

Definition at line 1600 of file expression.c.

{
  expression new_exp = expression_undefined;
  if (lang == is_language_c)
    {
      expression comp_exp = MakeBinaryCall(entity_intrinsic(C_LESS_THAN_OPERATOR_NAME),
                                           copy_expression(e1),
                                           copy_expression(e2));
      new_exp = MakeTernaryCall(entity_intrinsic(CONDITIONAL_OPERATOR_NAME),
                               comp_exp,
                               e1,
                               e2);
    }
  else
    {
      new_exp = MakeBinaryCall(entity_intrinsic(MIN_OPERATOR_NAME),
                               e1,e2);
    }
  return  new_exp;
}

References C_LESS_THAN_OPERATOR_NAME, CONDITIONAL_OPERATOR_NAME, copy_expression(), entity_intrinsic(), expression_undefined, is_language_c, MakeBinaryCall(), MakeTernaryCall(), and MIN_OPERATOR_NAME.

Referenced by loop_annotate().

Here is the call graph for this function:

Here is the caller graph for this function:

make_op_exp()

expression make_op_exp	(	char *	op_name,
		expression	exp1,
		expression	exp2
	)

================================================================

expression make_op_exp(char *op_name, expression exp1 exp2): Returns an expression containing the operation "op_name" between "exp1" and "exp2". "op_name" must be one of the four classic operations : +, -, * or /.

If both expressions are integer constant values and the operation result is an integer then the returned expression contained the calculated result.

Else, we treat five special cases : _ exp1 and exp2 are integer linear and op_name is + or -. This case is resolved by make_lin_op_exp(). _ exp1 = 0 _ exp1 = 1 _ exp2 = 0 _ exp2 = 1

Else, we create a new expression with a binary call.

Note: The function MakeBinaryCall() comes from Pips/.../syntax/expression.c The function int_to_expression() comes from ri-util.

Warning: using the same semantic as MakeBinaryCall, make_op_exp owns the pointer exp1 and exp2 after the call, beware of not sharing them !

pips_debug(5, "begin OP EXP : %s %s %s\n",

words_to_string(words_expression(exp1, NIL)),

op_name,

words_to_string(words_expression(exp2, NIL)));

ENTITY_DIVIDE_P(op_ent)

we compute here as FORTRAN would do

We need to know the integer linearity of both expressions.

dividing by one or minus one is similar to multiplying

ENTITY_MULTIPLY_P(op_ent) || ENTITY_DIVIDE_P(op_ent)

ENTITY_DIVIDE_P(op_ent)

pips_debug(5, "end OP EXP : %s\n",

words_to_string(words_expression(result_exp, NIL)));

Parameters

op_name	p_name
exp1	xp1
exp2	xp2

Definition at line 2012 of file expression.c.

{
  expression result_exp = expression_undefined;
  entity op_ent, unary_minus_ent;
 
  debug( 7, "make_op_exp", "doing\n");
  op_ent = gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                   op_name), entity_domain);
  unary_minus_ent =
    gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                            UNARY_MINUS_OPERATOR_NAME),
                       entity_domain);
 
  // FI: to avoid cycle between the ri and prettyprint libraries
  /* pips_debug(5, "begin OP EXP : %s  %s  %s\n", */
  /*    words_to_string(words_expression(exp1, NIL)), */
  /*    op_name, */
  /*    words_to_string(words_expression(exp2, NIL))); */
 
  if( ! ENTITY_FIVE_OPERATION_P(op_ent) )
    user_error("make_op_exp", "operation must be : +, -, *, MOD, or /");
 
  intptr_t val1, val2;
  if( expression_integer_value(exp1,&val1) && expression_integer_value(exp2,&val2) )
    {
 
      debug(6, "make_op_exp", "Constant expressions\n");
 
      if (ENTITY_PLUS_P(op_ent))
        result_exp = int_to_expression(val1 + val2);
      else if(ENTITY_MINUS_P(op_ent))
        result_exp = int_to_expression(val1 - val2);
      else if(ENTITY_MULTIPLY_P(op_ent))
        result_exp = int_to_expression(val1 * val2);
      else if(ENTITY_MODULO_P(op_ent))
          result_exp = int_to_expression(val1 % val2);
      else /* ENTITY_DIVIDE_P(op_ent) */
        /* we compute here as FORTRAN would do */
        result_exp = int_to_expression((int) (val1 / val2));
      free_expression(exp1);
      free_expression(exp2);
    }
  else
    {
      /* We need to know the integer linearity of both expressions. */
      normalized nor1 = NORMALIZE_EXPRESSION(exp1);
      normalized nor2 = NORMALIZE_EXPRESSION(exp2);
 
      /* dividing by one or minus one is similar to multiplying */ 
      _int val;
      if(( ENTITY_DIVIDE_P(op_ent) || ENTITY_MULTIPLY_P(op_ent))
              && expression_integer_value(exp2,&val)
              && ( val == -1) ) {
          free_expression(exp2);
          return make_op_exp(MINUS_OPERATOR_NAME,int_to_expression(0),exp1);
      }
 
      if((normalized_linear_p(nor1) && normalized_linear_p(nor2) ) &&
         (ENTITY_PLUS_P(op_ent) || ENTITY_MINUS_P(op_ent) ) )
        {
          pips_debug(6, "Linear operation\n");
 
      result_exp = make_lin_op_exp(op_ent, copy_expression(exp1), copy_expression(exp2));
        }
      else if(expression_equal_integer_p(exp1, 0))
        {
          if (ENTITY_PLUS_P(op_ent)) {
            result_exp = exp2;
        free_expression(exp1);
      }
          else if(ENTITY_MINUS_P(op_ent)) {
            result_exp = MakeUnaryCall(unary_minus_ent, exp2);
        free_expression(exp1);
      }
          else /* ENTITY_MULTIPLY_P(op_ent) || ENTITY_DIVIDE_P(op_ent) */ {
            result_exp = int_to_expression(0);
        free_expression(exp1);free_expression(exp2);
      }
        }
      else if(expression_equal_integer_p(exp1, 1))
        {
          if(ENTITY_MULTIPLY_P(op_ent)) {
            result_exp = exp2;
        free_expression(exp1);
      }
        }
      else if(expression_equal_integer_p(exp2, 0))
        {
      free_expression(exp2);
          if (ENTITY_PLUS_P(op_ent) || ENTITY_MINUS_P(op_ent))
            result_exp = exp1;
          else if (ENTITY_MULTIPLY_P(op_ent)) {
            result_exp = int_to_expression(0);
        free_expression(exp1);
      }
          else /* ENTITY_DIVIDE_P(op_ent) */
            user_error("make_op_exp", "division by zero");
        }
      else if(expression_equal_integer_p(exp2, 1))
        {
          if(ENTITY_MULTIPLY_P(op_ent) || ENTITY_DIVIDE_P(op_ent)) {
            result_exp = exp1;
        free_expression(exp2);
      }
        }
    }
 
  if(result_exp == expression_undefined)
    result_exp = MakeBinaryCall(op_ent, exp1, exp2);
 
  // FI: to avoid cycle between the ri and prettyprint libraries
  /* pips_debug(5, "end   OP EXP : %s\n", */
  /*    words_to_string(words_expression(result_exp, NIL))); */
 
  return (result_exp);
}

References copy_expression(), debug(), ENTITY_DIVIDE_P, entity_domain, ENTITY_FIVE_OPERATION_P, ENTITY_MINUS_P, ENTITY_MODULO_P, ENTITY_MULTIPLY_P, ENTITY_PLUS_P, expression_equal_integer_p(), expression_integer_value(), expression_undefined, free_expression(), gen_find_tabulated(), int_to_expression(), intptr_t, make_entity_fullname(), make_lin_op_exp(), MakeBinaryCall(), MakeUnaryCall(), MINUS_OPERATOR_NAME, NORMALIZE_EXPRESSION, normalized_linear_p, pips_debug, TOP_LEVEL_MODULE_NAME, UNARY_MINUS_OPERATOR_NAME, and user_error.

Referenced by add_integer_to_expression(), ajoute_constante(), ajoute_new_var(), bdt_save_pred(), build_third_comb(), C_loop_range(), calloc_to_abstract_location(), compute_final_index_value(), contraintes_to_expression(), distance_between_entity(), distance_between_expression(), do_gather_all_expressions(), do_group_constants_terapix(), do_group_count_elements_reduce(), do_grouping_replace_reference_by_expression_walker(), do_linearize_array_reference(), do_linearize_type(), do_loop_expansion(), do_loop_expansion_init(), do_sizeofdimension_reduction(), do_solve_hardware_constraints_on_nb_proc(), do_symbolic_tiling(), do_terapix_warmup_patching(), ecrit_une_var(), ecrit_une_var_neg(), generate_call_get_workchunk_loopbounds(), heap_intrinsic_to_post_pv(), initialization_list_to_statements(), loop_annotate(), loop_normalize_of_loop(), loop_strip_mine(), malloc_arg_to_type(), monome_to_expression(), ndf_normalized_test(), normalize_test_leaves(), offset_of_struct(), partial_eval_min_or_max_operator(), polynome_to_expression(), put_source_ind(), range_to_expression(), rational_sol_edit(), reference_offset(), region_to_minimal_dimensions(), save_pred(), sc_opposite_exp_of_conjunction(), sesamify(), simplify_minmax_expression(), SizeOfDimension(), try_reorder_expression_call(), and whileloop_to_complexity().

Here is the call graph for this function:

make_ref_expr()

expression make_ref_expr	(	entity	ent,
		list	args
	)

Parameters

ent	nt
args	rgs

Definition at line 4316 of file expression.c.

{
    return make_expression(make_syntax(is_syntax_reference,
                                       make_reference(ent, args)),
                           normalized_undefined);
}

References is_syntax_reference, make_expression(), make_reference(), make_syntax(), and normalized_undefined.

Referenced by do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), and full_loop_unroll().

Here is the call graph for this function:

Here is the caller graph for this function:

make_subscript_expression()

expression make_subscript_expression	(	expression	a,
		list	sl
	)

Parameters

sl

l

Definition at line 397 of file expression.c.

{
  subscript i = make_subscript(a, sl);
  syntax s = make_syntax_subscript(i);
  expression e = syntax_to_expression(s);
  return e;
}

References make_subscript(), make_syntax_subscript(), and syntax_to_expression().

Here is the call graph for this function:

make_true_expression()

expression make_true_expression

(

void

)

Definition at line 1103 of file expression.c.

{
  return make_call_expression(MakeConstant(TRUE_OPERATOR_NAME,is_basic_logical),NIL);
}

References is_basic_logical, make_call_expression(), MakeConstant(), NIL, and TRUE_OPERATOR_NAME.

Referenced by alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_scalar_variable_in_caller_flt(), alias_check_two_array_variables_in_caller(), alias_check_two_scalar_variables_in_caller(), alias_check_two_scalar_variables_in_module(), expression_less_than_in_context(), insert_flag_before_call_site(), insert_test_before_caller(), make_true_array_dimension_bound_test(), simplify_boolean_expression_with_precondition(), top_down_abc_call(), and top_down_abc_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

make_unbounded_expression()

expression make_unbounded_expression

(

void

)

Definition at line 4339 of file expression.c.

{
  return MakeNullaryCall(CreateIntrinsic(UNBOUNDED_DIMENSION_NAME));
}

References CreateIntrinsic(), MakeNullaryCall(), and UNBOUNDED_DIMENSION_NAME.

Referenced by array_formal_parameter_to_stub_points_to(), binary_arithmetic_operator_to_post_pv(), binary_intrinsic_call_to_points_to_sinks(), complete_points_to_reference_with_fixed_subscripts(), create_pointer_to_array_stub_points_to(), effect_interference(), effect_may_union(), effect_must_union(), effect_to_store_independent(), generic_reference_add_fixed_subscripts(), make_unbounded_dimensions(), make_unbounded_subscripts(), MakeDimension(), malloc_arg_to_type(), module_initial_parameter_pv(), offset_array_reference(), offset_points_to_cell(), points_to_cell_to_upper_bound_points_to_cells(), points_to_cell_types_compatibility(), points_to_cell_update_last_subscript(), points_to_indices_to_subscript_indices(), points_to_indices_to_unbounded_indices(), proper_to_summary_simple_effect(), reference_with_store_independent_indices(), simple_pv_may_union(), simple_pv_must_union(), simplified_reference(), struct_assignment_to_points_to(), struct_variable_to_pointer_locations(), struct_variable_to_pointer_subscripts(), subscript_expressions_to_constant_subscript_expressions(), type_to_array_type(), and update_operator_to_post_pv().

Here is the call graph for this function:

Here is the caller graph for this function:

make_unbounded_subscripts()

list make_unbounded_subscripts

(

int

d

)

FI: this piece of code must have been duplicated somewhere else in an effect library.

Definition at line 4346 of file expression.c.

{
  list sl = NIL;
  int i;
 
  for(i=0; i<d; i++) {
    sl = CONS(EXPRESSION, make_unbounded_expression(), sl);
  }
 
  return sl;
}

References CONS, EXPRESSION, make_unbounded_expression(), and NIL.

Referenced by cells_to_read_or_write_effects().

Here is the call graph for this function:

Here is the caller graph for this function:

make_vecteur_expression()

expression make_vecteur_expression

(

Pvecteur

pv

)

make expression for vector (Pvecteur)

sort: to insure a deterministic generation of the expression. note: the initial system is NOT touched. ??? Sometimes the vectors are shared, so you cant modify them that easily. Many cores in Hpfc (deducables), Wp65, and so. ok, I'm responsible for some of them:-)

(c) FC 24/11/94 SG: added support for generation of C operator when needed

let us avoid -1*var, we prefer -var

choose among C or fortran operator depending on the entity type this limits the use of +C and -C to pointer arithmetic

Parameters

pv

v

Definition at line 1650 of file expression.c.

{
  /* sort: to insure a deterministic generation of the expression.
   * note: the initial system is *NOT* touched.
   * ??? Sometimes the vectors are shared, so you cant modify them
   *     that easily. Many cores in Hpfc (deducables), Wp65, and so.
   * ok, I'm responsible for some of them:-)
   *
   *  (c) FC 24/11/94
   *  SG: added support for generation of C operator when needed
   */
  Pvecteur
    v_sorted = vect_sort(pv, compare_Pvecteur),
    v = v_sorted;
  expression factor1, factor2;
  entity op_add, op_sub,
         c_op_add, c_op_sub;
  int coef;
 
  op_add = entity_intrinsic(PLUS_OPERATOR_NAME);
  op_sub = entity_intrinsic(MINUS_OPERATOR_NAME);
  c_op_add = entity_intrinsic(PLUS_C_OPERATOR_NAME);
  c_op_sub = entity_intrinsic(MINUS_C_OPERATOR_NAME);
 
  if (VECTEUR_NUL_P(v))
    return int_to_expression(0);
 
  coef = VALUE_TO_INT(vecteur_val(v));
 
  entity var = (entity) vecteur_var(v);
  bool next_op_is_c = var !=TCST && entity_pointer_p(var);
  if (coef==-1) /* let us avoid -1*var, we prefer -var */
    {
      entity op_ums = entity_intrinsic(UNARY_MINUS_OPERATOR_NAME);
      factor1 = make_factor_expression(1, (entity) vecteur_var(v));
      factor1 = call_to_expression
        (make_call(op_ums, CONS(EXPRESSION, factor1, NIL)));
    }
  else
    factor1 = make_factor_expression(coef, (entity) vecteur_var(v));
 
  for (v=v->succ; v!=NULL; v=v->succ)
    {
      var = (entity) vecteur_var(v);
      coef = VALUE_TO_INT(vecteur_val(v));
      pips_assert("some coefficient", coef!=0);
      factor2 = make_factor_expression(ABS(coef), var);
      /* choose among C or fortran operator depending on the entity type
       * this limits the use of +C and -C to pointer arithmetic
       */
      entity op =
          ( next_op_is_c ) ?
          ( coef> 0 ? c_op_add : c_op_sub ) :
          ( coef> 0 ? op_add   : op_sub ) ;
      factor1 = MakeBinaryCall(op,factor1,factor2);
      next_op_is_c = var !=TCST && entity_pointer_p(var);
    }
 
  vect_rm(v_sorted);
 
  return factor1;
}

References ABS, call_to_expression(), compare_Pvecteur(), CONS, entity_intrinsic(), entity_pointer_p(), EXPRESSION, int_to_expression(), make_call(), make_factor_expression(), MakeBinaryCall(), MINUS_C_OPERATOR_NAME, MINUS_OPERATOR_NAME, NIL, pips_assert, PLUS_C_OPERATOR_NAME, PLUS_OPERATOR_NAME, TCST, UNARY_MINUS_OPERATOR_NAME, VALUE_TO_INT, vect_rm(), vect_sort(), VECTEUR_NUL_P, vecteur_val, and vecteur_var.

Referenced by array_indices_communication(), array_scalar_access_to_bank_communication(), build_esv_list(), build_third_comb(), complex_bound_generation(), constraints_to_loop_bound(), contraintes_to_expression(), eval_var(), expression_to_expression_newbase(), generate_subarray_shift(), get_exp_schedule(), lower_bound_generation(), make_array_bounds(), make_constraint_expression(), make_datum_movement(), make_movement_scalar_wp65(), make_movements_loop_body_wp65(), make_rational_exp(), negate_expression(), partial_eval_expression(), Pcontrainte_to_expression_list(), phi_free_contraints_to_expressions(), predicate_to_expression(), psystem_to_expression(), put_source_ind(), Pvecteur_to_assign_statement(), Pvecteur_to_expression(), reduce_loop_bound(), reference_conversion_computation(), test_bound_generation(), upper_bound_generation(), vect_to_string(), and vectors_to_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

make_zero_expression()

expression make_zero_expression

(

void

)

Make a zero expression.

It is useful compared to int_to_expression(0) because it is much easier to search in source text.

Definition at line 1212 of file expression.c.

{
  return int_to_expression(0);
}

References int_to_expression().

Referenced by array_formal_parameter_to_stub_points_to(), create_scalar_stub_sink_cell(), find_points_to_subscript_for_type(), generic_reference_to_transformer(), pointer_source_to_sinks(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeBinaryCall()

expression MakeBinaryCall	(	entity	f,
		expression	eg,
		expression	ed
	)

Creates a call expression to a function with 2 arguments.

Parameters

f	is the function entity to call
eg	is the first argument expression given to the function to call
ed	is the second argument expression given to the function to call

Parameters

eg	g
ed	d

Definition at line 354 of file expression.c.

                                                                  {
  return make_call_expression(f, CONS(EXPRESSION, eg,
                                      CONS(EXPRESSION, ed, NIL)));
}

References CONS, EXPRESSION, f(), make_call_expression(), and NIL.

Referenced by any_basic_update_operation_to_transformer(), any_basic_update_to_transformer_list(), any_update_to_transformer_list(), array_scalar_access_to_bank_communication(), basic_update_reflhs_with_rhs_to_transformer(), binary_arithmetic_operator_to_post_pv(), bound_to_statement(), buffer_full_condition(), c_dim_string(), c_reference(), call_rwt(), compile_master(), compute_final_index_value(), constraints_to_loop_bound(), convert_bound_expression(), ctx_generate_new_statement_cluster_dependant(), derived_formal_parameter_to_stub_points_to(), dimensions_to_dma(), do_array_to_pointer_walk_expression(), do_brace_expression_to_statements(), do_expression_reduction(), do_loop_expansion(), do_loop_to_for_loop(), do_loop_to_while_loop(), do_loop_unroll_with_epilogue(), do_loop_unroll_with_prologue(), do_reduction_atomization(), do_solve_hardware_constraints_on_nb_proc(), do_split_structure(), do_terapix_remove_divide(), do_terapix_warmup_patching(), expand_call(), expr_compute_local_index(), expression_list_to_binary_operator_call(), fix_if_condition(), gen_if_rank(), generate_monome(), get_allocatable_data_expr(), gfc2pips_buildCaseTest(), gfc2pips_code2instruction_(), gfc2pips_dumpSELECT(), gfc2pips_expr2expression(), gfc2pips_reduce_repeated_values(), gfc2pips_symbol2data_instruction(), guard_expanded_statement(), heap_intrinsic_to_post_pv(), hpfc_add_2(), hpfc_add_n(), loop_annotate(), loop_strip_mine(), make_assign_expression(), make_body_from_loop(), make_condition_from_loop(), make_expression_with_state_variable(), make_factor_expression(), make_fields_assignment_instruction(), make_increment_statement(), make_max_exp(), make_max_expression(), make_min_expression(), make_movements_loop_body_wp65(), make_op_exp(), make_scalar_communication_module(), make_scanning_over_tiles(), make_start_ru_module(), make_vecteur_expression(), MakeArithmIfInst(), MakeAssignedOrComputedGotoInst(), MakeComplexConstantExpression(), MakeDimension(), MakeFortranBinaryCall(), makeTransfertSizeExpression(), MakeWhileDoInst(), ndf_normalized_test(), normalize_test_leaves(), outliner_extract_loop_bound(), overlap_redefine_expression(), partial_eval_binary_operator_old(), partial_eval_mult_operator(), partial_eval_plus_or_minus_operator(), Pcontrainte_to_expression_list(), phi_free_contraints_to_expressions(), predicate_to_expression(), psystem_to_expression(), rational_op_exp(), regenerate_expression(), region_to_address(), region_to_minimal_dimensions(), sc_conditional(), sc_opposite_exp_of_conjunction(), sesamify(), simdizer_auto_tile(), simplify_complex_expression(), split_complex_expression(), split_update_call(), st_send_to_computer_if_necessary(), step_local_regionArray(), string_to_expression(), terapix_normalize_tests(), translate_to_module_frame(), typedef_formal_parameter_to_stub_points_to(), unsugared_loop_inc(), unsugared_loop_test(), update_indices_for_local_computation(), update_operation_to_transformer(), update_range(), update_reflhs_with_rhs_to_transformer(), update_test_condition(), and words_dimension().

Here is the call graph for this function:

MakeBraceExpression()

expression MakeBraceExpression

(

list

l

)

Definition at line 3927 of file expression.c.

{
  return make_call_expression(CreateIntrinsic(BRACE_INTRINSIC),l);
}

References BRACE_INTRINSIC, CreateIntrinsic(), and make_call_expression().

Here is the call graph for this function:

MakeCastExpression()

expression MakeCastExpression	(	type	t,
		expression	e
	)

exp = (t) e

Definition at line 3911 of file expression.c.

{
  syntax s = make_syntax_cast(make_cast(t,e));
  expression exp = make_expression(s,normalized_undefined);
  return exp; /* exp = (t) e */
}

References exp, make_cast(), make_expression(), make_syntax_cast(), and normalized_undefined.

Referenced by cast_STEP_ARG().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeCommaExpression()

expression MakeCommaExpression

(

list

l

)

Definition at line 3918 of file expression.c.

{
  if (ENDP(l))
    return expression_undefined;
  if (gen_length(l)==1)
    return EXPRESSION(CAR(l));
  return make_call_expression(CreateIntrinsic(COMMA_OPERATOR_NAME),l);
}

References CAR, COMMA_OPERATOR_NAME, CreateIntrinsic(), ENDP, EXPRESSION, expression_undefined, gen_length(), and make_call_expression().

Referenced by MakeArrayExpression(), and MakeWhileLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeNullaryCall()

expression MakeNullaryCall

(

entity

f

)

Creates a call expression to a function with zero arguments.

Parameters

f	is the function entity to call

Definition at line 331 of file expression.c.

{
  return make_call_expression(f, NIL);
}

References f(), make_call_expression(), and NIL.

Referenced by bool_to_expression(), DeclarePointer(), dims_array_init(), expression_list_to_conjonction(), gfc2pips_array_ref2indices(), gfc2pips_code2instruction_(), gfc2pips_expr2expression(), gfc2pips_exprIO2(), gfc2pips_exprIO3(), gfc2pips_get_list_of_dimensions2(), make_simple_Fortran_io_instruction(), make_unbounded_expression(), MakeAtom(), MakeCharacterConstantExpression(), and MakeSimpleIoInst1().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeSizeofExpression()

expression MakeSizeofExpression

(

expression

e

)

exp = sizeof(e)

Definition at line 3896 of file expression.c.

{
 
  syntax s = make_syntax_sizeofexpression(make_sizeofexpression_expression(e));
  expression exp =  make_expression(s,normalized_undefined);
  return exp; /* exp = sizeof(e)*/
}

References exp, make_expression(), make_sizeofexpression_expression(), make_syntax_sizeofexpression(), and normalized_undefined.

Referenced by get_sizeofexpression_for_region().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeSizeofType()

expression MakeSizeofType

(

type

t

)

exp = sizeof(t)

Definition at line 3904 of file expression.c.

{
  syntax s = make_syntax_sizeofexpression(make_sizeofexpression_type(t));
  expression exp =  make_expression(s,normalized_undefined);
  return exp;  /* exp = sizeof(t) */
}

References exp, make_expression(), make_sizeofexpression_type(), make_syntax_sizeofexpression(), and normalized_undefined.

Referenced by get_sizeofexpression_for_region().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeTernaryCall()

expression MakeTernaryCall	(	entity	f,
		expression	e1,
		expression	e2,
		expression	e3
	)

Creates a call expression to a function with 3 arguments.

Parameters

f	is the function entity to call
e1	is the first argument expression given to the function to call
e2	is the second argument expression given to the function to call
e3	is the second argument expression given to the function to call

Parameters

e1	1
e2	2
e3	3

Definition at line 367 of file expression.c.

                                              {
  return make_call_expression(f,
                              CONS(EXPRESSION, e1,
                                   CONS(EXPRESSION, e2,
                                        CONS(EXPRESSION, e3,
                                             NIL))));
}

References CONS, EXPRESSION, f(), make_call_expression(), and NIL.

Referenced by expr_compute_local_index(), make_max_expression(), make_min_expression(), and make_phi_assign_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeUnaryCall()

expression MakeUnaryCall	(	entity	f,
		expression	a
	)

Creates a call expression to a function with one argument.

Parameters

f	is the function entity to call
a	is the argument expression given to the function to call

Definition at line 342 of file expression.c.

{
  return make_call_expression(f, CONS(EXPRESSION, a, NIL));
}

References CONS, EXPRESSION, f(), make_call_expression(), and NIL.

Referenced by binary_arithmetic_operator_to_post_pv(), binary_intrinsic_call_to_points_to_sinks(), call_STEP_subroutine3(), compute_final_index_value(), dag_normalize(), dereference_expression(), dimensions_to_dma(), do_array_to_pointer_walk_expression(), do_linearize_array_manage_callers(), do_outliner_smart_replacment(), do_terapix_argument_handler(), ecrit_une_var_neg(), expr_compute_local_index(), generate_compact(), generate_monome(), get_expression_addr(), heap_intrinsic_to_post_pv(), if_conv_init_statement(), incrementation_expression_to_increment(), initialization_list_to_statements(), inline_expression_call(), int_to_expression(), intrinsic_call_to_points_to(), make_address_of_expression(), make_op_exp(), make_substitution(), MakeArithmIfInst(), MakeFortranUnaryCall(), normalize_microcode(), normalize_test_leaves(), outliner_patch_parameters(), outliner_smart_references_computation(), rational_op_exp(), recover_structured_while(), regenerate_expression(), region_to_address(), replace_reductions_in_statement(), scalopify(), simplify_complex_expression(), st_make_nice_test(), static_controlize_statement(), string_to_expression(), translate_to_module_frame(), and update_range().

Here is the call graph for this function:

Here is the caller graph for this function:

max0_expression_p()

bool max0_expression_p

(

expression

e

)

Definition at line 1061 of file expression.c.

{
    return operator_expression_p(e, MAX0_OPERATOR_NAME) ||
        operator_expression_p(e, MAX_OPERATOR_NAME);
}

References MAX0_OPERATOR_NAME, MAX_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

min0_expression_p()

bool min0_expression_p

(

expression

e

)

Definition at line 1054 of file expression.c.

{
    return operator_expression_p(e, MIN0_OPERATOR_NAME) ||
        operator_expression_p(e, MIN_OPERATOR_NAME);
}

References MIN0_OPERATOR_NAME, MIN_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

modulo_expression_p()

bool modulo_expression_p

(

expression

e

)

Definition at line 1006 of file expression.c.

{
    return operator_expression_p(e, MODULO_OPERATOR_NAME);
}

References MODULO_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

monome_to_expression()

expression monome_to_expression

(

Pmonome

pm

)

converts a monome to an expression

Parameters

pm

m

Definition at line 3589 of file expression.c.

{
    if (MONOME_UNDEFINED_P(pm))
        return expression_undefined;
    else {
        expression coeff;
        float x= monome_coeff(pm);
        if(x == (int)x)
            coeff = (x==1.f)? expression_undefined:int_to_expression((int)x);
        else
            coeff = float_to_expression(x);
        expression term = expression_undefined;
        for(Pvecteur v = monome_term(pm);!VECTEUR_NUL_P(v);v=vecteur_succ(v)) {
            Value exp = vecteur_val(v);
            Variable var = vecteur_var(v);
            expression tmp ;
            if(exp==0||var==TCST) tmp = int_to_expression(1); 
            else {
                Value val = exp>0 ? exp: -exp;
                tmp = entity_to_expression((entity)var);
                while(--val)
                    tmp=make_op_exp(MULTIPLY_OPERATOR_NAME,tmp,entity_to_expression((entity)var));
                if(exp<0)
                    tmp=make_op_exp(DIVIDE_OPERATOR_NAME,int_to_expression(1),tmp);
            }
            term=expression_undefined_p(term)?tmp:make_op_exp(MULTIPLY_OPERATOR_NAME,term,tmp);
        }
        return expression_undefined_p(coeff)?term:
            make_op_exp(MULTIPLY_OPERATOR_NAME, coeff, term);
    }
}

References DIVIDE_OPERATOR_NAME, entity_to_expression(), exp, expression_undefined, expression_undefined_p, float_to_expression(), int_to_expression(), make_op_exp(), monome_coeff, monome_term, MONOME_UNDEFINED_P, MULTIPLY_OPERATOR_NAME, TCST, term(), VECTEUR_NUL_P, vecteur_succ, vecteur_val, vecteur_var, and x.

Referenced by polynome_to_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

normalize_subscript_expression()

void normalize_subscript_expression

(

expression

e

)

Normalization of subscript in expressions.

The C parser generates no more than one index in each subscript construct:

subscript = array:expression x indices:expression* ; syntax = reference + range + call + cast + sizeofexpression

• subscript + application + va_arg:sizeofexpression* ; expression = syntax x normalized ;

If the array expression points to a multidimensional array, the indices list should be as long as possible, compatible with the array dimension.

               e (expression)
               |
               es (syntax)
               |
              esub (subscript)
              /  \
             /    \
             a    il -> -> (indices list)
             |        \
             as        \
             |          \
            asub         \
            /  \          \
           /    \          \
          sa    sil -> -> ->

The recursive normalization function works bottom up and, when facing the pattern above, concatenate the il index list (or a sublist) to the sil list. If the il list becomes empty, e is connected directly to as and the pieces of data structure es, esub and a are removed.

gen_recurse() is used to apply the transformation on the way up in expression trees. In the C parser, the transformation is applied to a module statement and to the initialization expressions present in the declarations.

Definition at line 4407 of file expression.c.

{
  syntax es = expression_syntax(e);
  if(syntax_subscript_p(es)) {
    subscript esub = syntax_subscript(es);
    expression a = subscript_array(esub);
    syntax as = expression_syntax(a);
    if(syntax_subscript_p(as)) {
      subscript asub = syntax_subscript(as);
      // FI: bad, imported from effects-util :-( We could use
      // expression_to_type and then convert it into a concrete type
      //extern type points_to_expression_to_concrete_type(expression);
      // type t = points_to_expression_to_concrete_type(a);
      type t = expression_to_concrete_type(a);
      // This might be wrong: a is likely to be a pointer to a sub-array
      // or a pointer to a scalar for 1D array.
      if(pointer_type_p(t) || array_type_p(t)) { // FI: should always be true for a subscript?
        int nm = 0;
        if(pointer_type_p(t)) {
          type et = type_to_pointed_type(t);
          nm = (int) array_type_dimension(et) + 1;
        }
        else
          nm = (int) array_type_dimension(t);
        //list sil = subscript_indices(asub);
        // int nsi = (int) gen_length(sil);
        // FI: the efficient way would be to cut of the il list into two
        // parts and to use only one call to gen_nconc()
        list il = subscript_indices(esub);
        for(int i=0;i<nm && !ENDP(il); i++) {
          list ni = il; // new index/subscript
          POP(il);
          CDR(ni) = NIL;
          subscript_indices(asub) = 
            gen_nconc(subscript_indices(asub), ni);
        }
        if(ENDP(il)) {
          // The top subscript can be removed
          expression_syntax(e) = as;
          expression_syntax(a) = syntax_undefined;
          subscript_indices(esub) = NIL;
          free_syntax(es);
        }
        else if(il!=subscript_indices(esub)) {
          // Update the new index list with the remaining indices
          subscript_indices(esub) = il;
        }
        else {
          // No restructuring
          ;
        }
      }
      free_type(t);
    }
  }
}

References array_type_dimension(), array_type_p(), CDR, ENDP, expression_syntax, expression_to_concrete_type(), free_syntax(), free_type(), gen_nconc(), int, NIL, pointer_type_p(), POP, subscript_array, subscript_indices, syntax_subscript, syntax_subscript_p, syntax_undefined, and type_to_pointed_type().

Referenced by expression_normalize_subscripts(), and statement_normalize_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

operator_expression_p()

bool operator_expression_p	(	expression	e,
		string	op_name
	)

Parameters

op_name

p_name

Definition at line 1087 of file expression.c.

{
    syntax s = expression_syntax(e);
 
    if(syntax_call_p(s)) {
        call c = syntax_call(s);
        entity op = call_function(c);
 
        return strcmp(op_name, entity_local_name(op)) == 0;
    }
    else
        return false;
}

References call_function, entity_local_name(), expression_syntax, syntax_call, and syntax_call_p.

Referenced by abs_expression_p(), add_expression_p(), assignment_expression_p(), cabs_expression_p(), dabs_expression_p(), divide_expression_p(), false_expression_p(), iabs_expression_p(), logical_expression_p(), max0_expression_p(), min0_expression_p(), modulo_expression_p(), power_expression_p(), sub_expression_p(), substraction_expression_p(), true_expression_p(), and unary_minus_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

pointer_reference_to_expression()

expression pointer_reference_to_expression

(

reference

r

)

Assume p is a pointer.

Compute expression "*(p+i)" from reference r = "p[i]".

rsl is fully copied into two sub-lists: the effective array indices and then the pointer indices.

We build a proper reference to an element of p

We build the equivalent pointer arithmetic expression

Definition at line 4004 of file expression.c.

{
  entity p = reference_variable(r);
  type t = entity_basic_concrete_type(p);
  list rsl = reference_indices(r);
  int p_d = variable_dimension_number(type_variable(t)); // pointer dimension
  int r_d = (int) gen_length(rsl); // reference dimension
 
  pips_assert("The reference dimension is strictly greater than "
              "the array of pointers dimension", r_d>p_d);
 
  /* rsl is fully copied into two sub-lists: the effective array
     indices and then the pointer indices. */
  list esl = NIL;
  list psl = NIL;
  list crsl = rsl;
  int i;
  for(i = 0; i<r_d; i++) {
    expression se = EXPRESSION(CAR(crsl));
    i<p_d? (esl = CONS(EXPRESSION, copy_expression(se), esl))
      :  (psl = CONS(EXPRESSION, copy_expression(se), psl));
    POP(crsl);
  }
  esl = gen_nreverse(esl), psl = gen_nreverse(psl);
 
  pips_assert("The pointer index list is not empty", !ENDP(psl));
 
  /* We build a proper reference to an element of p */
  reference nr = make_reference(p, esl);
  expression nre = reference_to_expression(nr);
 
  /* We build the equivalent pointer arithmetic expression */
  expression pae = nre;
  // FI: would be better to compute the two operators before entering the loop
  // entity plus = ;
  // entity indirection = ;
  FOREACH(EXPRESSION, pse, psl) {
    pae = binary_intrinsic_expression(PLUS_C_OPERATOR_NAME, pae, pse);
    pae = unary_intrinsic_expression(DEREFERENCING_OPERATOR_NAME, pae);
  }
 
  return pae;
}

References binary_intrinsic_expression, CAR, CONS, copy_expression(), DEREFERENCING_OPERATOR_NAME, ENDP, entity_basic_concrete_type(), EXPRESSION, FOREACH, gen_length(), gen_nreverse(), int, make_reference(), NIL, pips_assert, PLUS_C_OPERATOR_NAME, POP, reference_indices, reference_to_expression(), reference_variable, type_variable, unary_intrinsic_expression, and variable_dimension_number().

Referenced by pointer_reference_dereferencing_to_points_to(), and pointer_reference_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

polynome_to_expression()

expression polynome_to_expression

(

Ppolynome

pp

)

converts a polynomial to expression

Parameters

pp

p

Definition at line 3622 of file expression.c.

{
    expression r =expression_undefined;
 
    if (POLYNOME_UNDEFINED_P(pp))
        r = expression_undefined;
    else if (POLYNOME_NUL_P(pp))
        r = int_to_expression(0);
    else {
        while (!POLYNOME_NUL_P(pp)) {
            expression s =      monome_to_expression(polynome_monome(pp));
            if(expression_undefined_p(r)) r=s;
            else
                r=make_op_exp(PLUS_OPERATOR_NAME, r, s);
            pp = polynome_succ(pp);
        }
    }
    return r;
}

References expression_undefined, expression_undefined_p, int_to_expression(), make_op_exp(), monome_to_expression(), PLUS_OPERATOR_NAME, polynome_monome, POLYNOME_NUL_P, polynome_succ, and POLYNOME_UNDEFINED_P.

Referenced by do_group_statement_constant(), do_solve_hardware_constraints_on_volume(), edge_cost_polynome(), and simplify_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

power_expression_p()

bool power_expression_p

(

expression

e

)

Definition at line 1018 of file expression.c.

{
    return operator_expression_p(e, POWER_OPERATOR_NAME);
}

References operator_expression_p(), and POWER_OPERATOR_NAME.

Here is the call graph for this function:

Pvecteur_to_assign_statement()

statement Pvecteur_to_assign_statement	(	entity	var,
		Pvecteur	v
	)

generates var = linear expression from the Pvecteur.

var is removed if necessary.

??? should manage an (positive remainder) integer divide ? Have a look to make_constraint_expression instead?

Parameters

var

ar

Definition at line 1720 of file expression.c.

{
  statement result;
  Pvecteur vcopy;
  Value coef;
 
  coef = vect_coeff((Variable) var, v);
  assert(value_le(value_abs(coef),VALUE_ONE));
 
  vcopy = vect_dup(v);
 
  if (value_notzero_p(coef)) vect_erase_var(&vcopy, (Variable) var);
  if (value_one_p(coef)) vect_chg_sgn(vcopy);
 
  result = make_assign_statement(entity_to_expression(var),
                                 make_vecteur_expression(vcopy));
  vect_rm(vcopy);
 
  return result;
}

References assert, entity_to_expression(), make_assign_statement(), make_vecteur_expression(), value_abs, value_le, value_notzero_p, VALUE_ONE, value_one_p, vect_chg_sgn(), vect_coeff(), vect_dup(), vect_erase_var(), and vect_rm().

Referenced by generate_deducables(), and hpfc_compute_lid().

Here is the call graph for this function:

Here is the caller graph for this function:

Pvecteur_to_expression()

expression Pvecteur_to_expression

(

Pvecteur

vect

)

AP, sep 25th 95 : some usefull functions moved from static_controlize/utils.c.

rather use make_vecteur_expression which was already there

Parameters

vect

ect

Definition at line 1825 of file expression.c.

{
    return make_vecteur_expression(vect);
}

References make_vecteur_expression().

Referenced by analyze_expression(), build_first_comb(), build_third_comb(), do_gather_all_expressions_perms(), do_terapix_warmup_patching(), free_guards(), fusion(), fusion_buffer(), Hierarchical_tiling(), include_trans_on_LC_in_ref(), make_lin_op_exp(), make_reindex(), outliner_smart_references_computation(), prgm_mapping(), reconfig_expression(), simplify_dimension(), simplify_relational_expression(), Tiling2_buffer(), Tiling_buffer_allocation(), and translate_to_module_frame().

Here is the call graph for this function:

Here is the caller graph for this function:

range_equal_p()

bool range_equal_p	(	range	r1,
		range	r2
	)

Parameters

r1	1
r2	2

Definition at line 1522 of file expression.c.

{
  return expression_equal_p(range_lower(r1), range_lower(r2))
    && expression_equal_p(range_upper(r1), range_upper(r2))
    && expression_equal_p(range_increment(r1), range_increment(r2));
}

References expression_equal_p(), range_increment, range_lower, and range_upper.

Referenced by free_guards(), and syntax_equal_p().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_add_unbounded_subscripts()

void reference_add_unbounded_subscripts	(	reference	r,
		type	t
	)

Definition at line 300 of file expression.c.

{
  generic_reference_add_fixed_subscripts(r, t, false);
}

References generic_reference_add_fixed_subscripts().

Referenced by points_to_cell_add_fixed_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_add_zero_subscript()

void reference_add_zero_subscript

(

reference

r

)

No check on reference r.

This may generate an illegal reference if not called properly

Definition at line 267 of file expression.c.

{
  expression z = int_to_expression(0);
  reference_indices(r) = gen_nconc(reference_indices(r),
                                   CONS(EXPRESSION, z, NIL));
}

References CONS, EXPRESSION, gen_nconc(), int_to_expression(), NIL, and reference_indices.

Referenced by points_to_cell_add_zero_subscript().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_add_zero_subscripts()

void reference_add_zero_subscripts	(	reference	r,
		type	t
	)

Definition at line 261 of file expression.c.

{
  generic_reference_add_fixed_subscripts(r, t, true);
}

References generic_reference_add_fixed_subscripts().

Referenced by anywhere_source_to_sinks(), points_to_cell_add_fixed_subscripts(), points_to_cell_types_compatibility(), reference_add_field_dimension(), and struct_assignment_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_complete_with_zero_subscripts()

void reference_complete_with_zero_subscripts

(

reference

r

)

Reference r to an array maybe partial, as is possible in C: with declaration "int a[10][10]", references "a", "a[i]" and "a[i][j]" are all legal.

The subscript list of reference r is completed with 0 subscript to reference an array element.

Definition at line 278 of file expression.c.

{
  list rsl = reference_indices(r);
  entity e = reference_variable(r);
  type t = entity_basic_concrete_type(e);
  pips_assert("t is a type of kind variable", type_variable_p(t));
  variable v = type_variable(t);
  list dl = variable_dimensions(v);
 
  if(gen_length(dl)>gen_length(rsl)) {
    FOREACH(EXPRESSION, rs, rsl)
      POP(dl);
    list sl = NIL; // subscript list
    FOREACH(DIMENSION, d, dl) {
      // expression s = zero_p? int_to_expression(0) : make_unbounded_expression();
      expression s = int_to_expression(0);
      sl = CONS(EXPRESSION, s, sl);
    }
    reference_indices(r) = gen_nconc(reference_indices(r), sl);
  }
}

References CONS, DIMENSION, entity_basic_concrete_type(), EXPRESSION, FOREACH, gen_length(), gen_nconc(), int_to_expression(), NIL, pips_assert, POP, reference_indices, reference_variable, type_variable, type_variable_p, and variable_dimensions.

Referenced by points_to_cell_complete_with_zero_subscripts().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_equal_p()

bool reference_equal_p	(	reference	r1,
		reference	r2
	)

Parameters

r1	1
r2	2

Definition at line 1500 of file expression.c.

{
  entity v1 = reference_variable(r1);
  entity v2 = reference_variable(r2);
 
  list dims1 = reference_indices(r1);
  list dims2 = reference_indices(r2);
 
  if(v1 != v2) {
    if(entity_field_p(v1) && entity_field_p(v2)) {
      // FI: because of separate compilation, the same field is
      // represented by different entities
      return same_field_entity_p(v1, v2);
    }
    else
      return false;
  }
 
  return gen_equals(dims1,dims2,(gen_eq_func_t)expression_equal_p);
}

References entity_field_p(), expression_equal_p(), gen_equals(), reference_indices, reference_variable, and same_field_entity_p().

Referenced by adg_write_reference_list(), attach_ref_to_stat(), build_successors_with_rhs(), call_flt(), cell_equal_p(), check_alias_args(), check_for_conflict(), checkReplaceReference(), comEngine_replace_reference_in_stat_rwt(), compact_phi_functions(), count_dataflows_on_ref(), create_realFifo_proc(), da_process_list(), daExpressionReplaceReference(), dataflows_on_ref(), dataflows_on_reference(), dmas_invert_p(), do_expression_reduction(), do_reduction_atomization(), do_reduction_detection(), do_reduction_propagation(), effect_sup_difference(), expression_verbose_reduction_p_and_return_increment(), find_or_create_fifo_from_ref(), fsr_reference_flt(), generate_fifo_stats(), generate_fifo_stats2(), generate_scalar_variables(), generate_scalar_variables_from_list(), get_fifoExp_from_ref(), get_HRE_buff_ent_from_ref(), get_indExp_from_ref(), in_effect_list_p(), merge_two_reductions(), opkill_may_reference(), opkill_must_reference(), perform_substitution_in_expression(), points_to_cell_equal_p(), potential_reduction_substitution_valid_p(), process_ref_lists(), reduction_in_statement_walker(), ref_subs_in_exp(), reference_conflicting_p(), reference_conflicting_test_and_update(), reference_dependence_variable_check_and_add(), reference_in_list_p(), reference_list_update(), rename_reduction_ref_walker(), same_reduction_p(), similarity(), stats_has_rw_conf_p(), and syntax_equal_p().

Here is the call graph for this function:

reference_offset()

expression reference_offset

(

reference

ref

)

computes the offset of a C reference with its origin

iterate on the dimensions & indices to create the index expression

there may be more dimensions than indices

there may be more indices than dimensions

Parameters

ref

ef

Definition at line 3807 of file expression.c.

{
    if(ENDP(reference_indices(ref))) return int_to_expression(0);
    else {
        expression address_computation = copy_expression(EXPRESSION(CAR(reference_indices(ref))));
 
        /* iterate on the dimensions & indices to create the index expression */
        list dims = variable_dimensions(type_variable(ultimate_type(entity_type(reference_variable(ref)))));
        list indices = reference_indices(ref);
        POP(indices);
        if(!ENDP(dims)) POP(dims); // the first dimension is unused
        FOREACH(DIMENSION,dim,dims)
        {
            expression dimension_size = make_op_exp(
                    PLUS_OPERATOR_NAME,
                    make_op_exp(
                        MINUS_OPERATOR_NAME,
                        copy_expression(dimension_upper(dim)),
                        copy_expression(dimension_lower(dim))
                        ),
                    int_to_expression(1));
 
            if( !ENDP(indices) ) { /* there may be more dimensions than indices */
                expression index_expression = EXPRESSION(CAR(indices));
                address_computation = make_op_exp(
                        PLUS_OPERATOR_NAME,
                        copy_expression(index_expression),
                        make_op_exp(
                            MULTIPLY_OPERATOR_NAME,
                            dimension_size,address_computation
                            )
                        );
                POP(indices);
            }
            else {
                address_computation = make_op_exp(
                        MULTIPLY_OPERATOR_NAME,
                        dimension_size,address_computation
                        );
            }
        }
 
        /* there may be more indices than dimensions */
        FOREACH(EXPRESSION,e,indices)
        {
            address_computation = make_op_exp(
                    PLUS_OPERATOR_NAME,
                    address_computation,copy_expression(e)
                    );
        }
        return address_computation ;
    }
}

References CAR, copy_expression(), DIMENSION, dimension_lower, dimension_size(), dimension_upper, ENDP, entity_type, EXPRESSION, FOREACH, indices, int_to_expression(), make_op_exp(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, POP, ref, reference_indices, reference_variable, type_variable, ultimate_type(), and variable_dimensions.

Referenced by do_group_constants_terapix(), do_grouping_replace_reference_by_expression_walker(), and sreference_offset().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_scalar_p()

bool reference_scalar_p

(

reference

r

)

This function returns true if Reference r is scalar.

Definition at line 3530 of file expression.c.

{
  entity v = reference_variable(r);
  assert(!reference_undefined_p(r) && r!=NULL && v!=NULL);
  return (reference_indices(r) == NIL &&  entity_scalar_p(v));
}

References assert, entity_scalar_p(), NIL, reference_indices, reference_undefined_p, and reference_variable.

Referenced by call_instruction_to_communications(), do_reduction_propagation(), first_reference_certainly_includes_second_reference_p(), guess_potential_reduction(), loop_nest_movement_generation(), loop_nest_to_wp65_code(), partial_eval_update_operators(), and references_must_conflict_p().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_to_expression()

expression reference_to_expression

(

reference

r

)

Definition at line 196 of file expression.c.

{
  expression e;
  syntax s = make_syntax(is_syntax_reference, r);
 
  e = make_expression(s, normalize_reference(r));
 
  return e;
}

References is_syntax_reference, make_expression(), make_syntax(), and normalize_reference().

Referenced by alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_variable_in_caller_flt(), bound_to_statement(), conflict_is_a_real_conflict_p(), define_node_processor_id(), do_brace_expression_to_statements(), do_expression_reduction(), do_group_constants_terapix(), do_reduction_atomization(), do_reduction_propagation(), entity_to_expression(), expand_points_to_domain(), generate_c1_alpha(), generate_compact(), generate_copy_loop_nest(), generate_full_copy(), generate_get_value_locally(), generate_mmcd_stat_from_ref(), generate_parallel_body(), generate_prelude(), generate_remapping_guard(), generate_update_values_on_computer_and_nodes(), hpfc_buffer_reference(), hpfc_generate_message(), initialization_list_to_statements(), initialize_array_variable(), live_mapping_expression(), loop_annotate(), make_abc_count_statement(), make_check_io_statement(), make_com_loopbody(), make_lInitStats(), make_list_of_flags(), make_loadsave_statement(), make_lSwitchStats(), make_mypos_expression(), make_phi_assign_instruction(), make_read_loopbody(), make_reference_expression(), make_statement_copy_i(), make_write_loopbody(), MakeArrayExpression(), outliner_smart_references_computation(), pointer_reference_to_expression(), pointer_subscript_to_expression(), process_true_call_stat(), reference_to_address_entity(), replace_array_ref_with_fifos(), replace_array_ref_with_fifos2(), replace_reductions_in_statement(), set_array_status_to_target(), split_complex_expression(), st_call_send_or_receive(), st_compute_current_computer(), st_compute_current_owners(), st_compute_ith_local_index(), struct_assignment_to_points_to(), struct_initialization_to_points_to(), Tiling_buffer_allocation(), translate_to_module_frame(), and verify_array_variable().

Here is the call graph for this function:

reference_with_constant_indices_p()

bool reference_with_constant_indices_p

(

reference

r

)

Definition at line 3022 of file expression.c.

{
  list sel = reference_indices(r);
  bool constant_p = true;
 
  FOREACH(EXPRESSION, se, sel) {
    if(!extended_integer_constant_expression_p(se)
       && !field_expression_p(se) ) { // for points-to references
      constant_p = false;
      break;
    }
  }
  return constant_p;
}

References constant_p(), EXPRESSION, extended_integer_constant_expression_p(), field_expression_p(), FOREACH, and reference_indices.

Referenced by store_independent_effect_p(), and store_independent_reference_p().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_with_store_independent_indices()

reference reference_with_store_independent_indices

(

reference

r

)

Return by side effect a reference whose memory locations includes the memory locations of r in case the subcript expressions are changed by a store change.

Constant subscript expressions are preserved.

Store varying subscript expressions are replaced by unbounded expressions.

Definition at line 3045 of file expression.c.

{
  list sel = reference_indices(r);
  list sec = list_undefined;
 
  for(sec = sel; !ENDP(sec); POP(sec)) {
    expression se = EXPRESSION(CAR(sec));
 
    if(!extended_integer_constant_expression_p(se)) {
      free_expression(se);
      EXPRESSION_(CAR(sec)) = make_unbounded_expression();
    }
  }
 
  return r;
}

References CAR, ENDP, EXPRESSION, EXPRESSION_, extended_integer_constant_expression_p(), free_expression(), list_undefined, make_unbounded_expression(), POP, and reference_indices.

Referenced by effect_to_non_pointer_store_independent_effect(), and reference_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

reference_with_unbounded_indices_p()

bool reference_with_unbounded_indices_p

(

reference

r

)

indices can be constant or unbounded: they are store independent.

See next function, reference_with_unbounded_subscript_p()

Definition at line 3066 of file expression.c.

{
  list sel = reference_indices(r);
  bool unbounded_p = true;
 
  FOREACH(EXPRESSION, se, sel) {
      if(!extended_integer_constant_expression_p(se)
         && !unbounded_expression_p(se)) {
        unbounded_p = false;
        break;
      }
    }
  return unbounded_p;
}

References EXPRESSION, extended_integer_constant_expression_p(), FOREACH, reference_indices, and unbounded_expression_p().

Here is the call graph for this function:

reference_with_unbounded_subscript_p()

bool reference_with_unbounded_subscript_p

(

reference

r

)

See if the reference uses the unbounded function '*'.

See previous function, reference_with_unbounded_indices_p()

Definition at line 3085 of file expression.c.

{
  list sel = reference_indices(r);
  bool unbounded_p = false;
 
  FOREACH(EXPRESSION, se, sel) {
      if(unbounded_expression_p(se)) {
        unbounded_p = true;
        break;
      }
    }
  return unbounded_p;
}

References EXPRESSION, FOREACH, reference_indices, and unbounded_expression_p().

Referenced by generic_apply_effect_to_transformer().

Here is the call graph for this function:

Here is the caller graph for this function:

references_do_not_conflict_p()

bool references_do_not_conflict_p	(	reference	r1,
		reference	r2
	)

If true is returned, the two references cannot conflict unless array bound declarations are violated.

If false is returned, the two references may conflict.

true is returned if the two references are array references and if the two references entities are equal and if at least one dimension can be used to desambiguate the two references using constant subscript expressions. This test is store independent and certainly does not replace a dependence test. It may beused to compute ude-def chains.

If needed, an extra effort could be made for aliased arrays.

FI: OK, it would be better to use their normalized forms

Parameters

r1	1
r2	2

Definition at line 1888 of file expression.c.

{
  bool do_not_conflict = false;
  entity v1 = reference_variable(r1);
  entity v2 = reference_variable(r2);
 
  if(v1==v2) {
    list s1 = reference_indices(r1);
    list s2 = reference_indices(r2);
    if(!ENDP(s1) && gen_length(s1)==gen_length(s2)) {
      list cs1, cs2;
      for(cs1=s1, cs2=s2; !ENDP(cs1) && !do_not_conflict; POP(cs1), POP(cs2)) {
        expression sub1 = EXPRESSION(CAR(cs1));
        expression sub2 = EXPRESSION(CAR(cs2));
        if(expression_constant_p(sub1) && expression_constant_p(sub2)) {
          /* FI: OK, it would be better to use their normalized forms */
          do_not_conflict = (expression_to_int(sub1)!=expression_to_int(sub2));
        }
      }
    }
  }
 
  return do_not_conflict;
}

References CAR, ENDP, EXPRESSION, expression_constant_p(), expression_to_int(), gen_length(), POP, reference_indices, reference_variable, and s1.

Here is the call graph for this function:

relational_expression_p()

bool relational_expression_p

(

expression

e

)

A relational expression is a call whose function is either one of the following : .LT.,.LE.,.EQ.,.NE.,.GT.,.GE.

Definition at line 587 of file expression.c.

{
  /* A relational expression is a call whose function is either one of the following :
   * .LT.,.LE.,.EQ.,.NE.,.GT.,.GE. */
  if (expression_call_p(e))
    {
      entity op = call_function(syntax_call(expression_syntax(e)));
      if (ENTITY_RELATIONAL_OPERATOR_P(op))
        return true;
      return false;
    }
  return false;
}

References call_function, ENTITY_RELATIONAL_OPERATOR_P, expression_call_p(), expression_syntax, and syntax_call.

Referenced by logical_expression_p(), simplify_relational_expression(), and trivial_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_expression_content()

expression replace_expression_content	(	expression	e1,
		expression	e2
	)

Use side effects to move the content of e2, s2 and n2, into e1; s1 and n1 are freed, as well as e2.

This is useful if you need to keep the handle on e1. e1 is returned, although it is redundant.

Parameters

e1	1
e2	2

Definition at line 3864 of file expression.c.

{
  syntax s1 = expression_syntax(e1);
  normalized n1 = expression_normalized(e1);
  syntax s2 = expression_syntax(e2);
  normalized n2 = expression_normalized(e2);
 
  expression_syntax(e1) = s2;
  expression_normalized(e1) = n2;
  expression_syntax(e2) = syntax_undefined;
  expression_normalized(e2) = normalized_undefined;
  free_syntax(s1);
  free_normalized(n1);
  free_expression(e2);
 
  return e1;
}

References expression_normalized, expression_syntax, free_expression(), free_normalized(), free_syntax(), normalized_undefined, s1, and syntax_undefined.

Referenced by simplify_boolean_expression_with_precondition().

Here is the call graph for this function:

Here is the caller graph for this function:

same_expression_in_list_p()

bool same_expression_in_list_p	(	expression	e,
		list	le
	)

This function returns true, if there exists a same expression in the list false, otherwise.

Parameters

le

e

Definition at line 557 of file expression.c.

{
  MAP(EXPRESSION, f, if (same_expression_p(e,f)) return true, le);
  return false;
}

References EXPRESSION, f(), MAP, and same_expression_p().

Referenced by add_array_dimension_bound_test(), add_array_test(), expression_in_array_subscript(), top_down_abc_array(), and top_down_abc_call().

Here is the call graph for this function:

Here is the caller graph for this function:

same_expression_p()

bool same_expression_p	(	expression	e1,
		expression	e2
	)

this is slightly different from expression_equal_p, as it will return true for a+b vs b+a

lazy normalization.

Parameters

e1	1
e2	2

Definition at line 1426 of file expression.c.

{
 
  /* lazy normalization.
   */
  NORMALIZE_EXPRESSION(e1);
  NORMALIZE_EXPRESSION(e2);
 
  normalized n1, n2;
  n1 = expression_normalized(e1);
  n2 = expression_normalized(e2);
 
 
 
  if (normalized_linear_p(n1) && normalized_linear_p(n2))
    return vect_equal(normalized_linear(n1), normalized_linear(n2));
  else
    return expression_equal_p(e1, e2);
}

References expression_equal_p(), expression_normalized, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, and vect_equal().

Referenced by alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), bottom_up_abc_expression_implied_do(), check_loop_distribution_feasability(), compact_phi_functions(), expression_equal_in_context_p(), expression_in_array_subscript(), full_define_p(), interprocedural_abc_arrays(), make_loadsave_statement(), outliner_smart_references_computation(), prune_singleton(), same_dimension_p(), same_expression_in_list_p(), size_of_actual_array(), subscript_value(), subscript_value_stride(), substitute_expression_walker(), and try_reorder_expression_call().

Here is the call graph for this function:

Here is the caller graph for this function:

signed_integer_constant_expression_p()

bool signed_integer_constant_expression_p

(

expression

e

)

Definition at line 932 of file expression.c.

{
  if(!integer_constant_expression_p(e)) {
    syntax s = expression_syntax(e);
 
    if(syntax_call_p(s)) {
        call c = syntax_call(s);
        entity um = call_function(c);
 
        if(um == gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                         UNARY_MINUS_OPERATOR_NAME),
                                    entity_domain)) {
          expression e2 = binary_call_lhs(c);
 
          return integer_constant_expression_p(e2);
        }
    }
    return false;
  }
  else {
    return true;
  }
}

References binary_call_lhs, call_function, entity_domain, expression_syntax, gen_find_tabulated(), integer_constant_expression_p(), make_entity_fullname(), syntax_call, syntax_call_p, TOP_LEVEL_MODULE_NAME, and UNARY_MINUS_OPERATOR_NAME.

Referenced by signed_integer_constant_expression_value().

Here is the call graph for this function:

Here is the caller graph for this function:

signed_integer_constant_expression_value()

int signed_integer_constant_expression_value

(

expression

e

)

could be coded by geting directly the value of the constant entity...

also available as integer_constant_p() which has two arguments

Definition at line 1551 of file expression.c.

{
  /* could be coded by geting directly the value of the constant entity... */
  /* also available as integer_constant_p() which has *two* arguments */
 
  normalized n = normalized_undefined;
  int val = 0;
 
  pips_assert("is signed constant", signed_integer_constant_expression_p(e));
 
  n = NORMALIZE_EXPRESSION(e);
  if(normalized_linear_p(n)) {
    Pvecteur v = (Pvecteur) normalized_linear(n);
 
    if(vect_constant_p(v)) {
      Value x = vect_coeff(TCST, v);
      val = VALUE_TO_INT(x);
    }
    else
      pips_internal_error("non constant expression");
  }
  else
    pips_internal_error("non affine expression");
 
  return val;
}

References NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, normalized_undefined, pips_assert, pips_internal_error, signed_integer_constant_expression_p(), TCST, VALUE_TO_INT, vect_coeff(), vect_constant_p(), and x.

Referenced by integer_constant_expression_value().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_C_expression()

bool simplify_C_expression

(

expression

e

)

Replace C operators "+C" and "-C" which can handle pointers by arithmetic operators "+" and "-" when it is safe to do so, i.e.

when no pointer arithmetic is involved.

FI: Also, it might be useful to normalize the expression in order not to leave an undefined field in it. But this is a recursive function and probably not the right place to cope with this.

FI: see C_syntax/block_scope12.c. The source code line number where the problem occurs cannot be given because we are not in the c_syntax library.

FI: What if not? core dump?

The variable type can hide a functional type via a typedef

Might be wrong, but necessary

Should not occur in old C code

Should not occur in old C code

FI: The index expressions should be simplified too...

What is the type of the constant?

Should not occur in C, before C99

Check "+C" and "-C"

Try to simplify the arguments, do not hope much from the result type because of overloading.

a void expression such as (void) 0 results in an undefined basic. And so may do a condition c? (void *) 0 : (void *) 0.

FI: I guess, typedef equivalent to those could also be declared substituable

Should not occur in C

e must be a void expression, i.e. an expression returning no value

for gcc

Definition at line 2814 of file expression.c.

{
  syntax s = expression_syntax(e);
  bool can_be_substituted_p = false;
 
  pips_debug(9, "Begin\n");
 
  switch(syntax_tag(s)) {
  case is_syntax_reference:
    {
      entity re = reference_variable(syntax_reference(s));
      type rt = entity_type(re);
 
      if(type_undefined_p(rt)) {
        /* FI: see C_syntax/block_scope12.c. The source code line
           number where the problem occurs cannot be given because we
           are not in the c_syntax library. */
        pips_user_warning("Variable \"%s\" is probably used before it is defined\n",
                          entity_user_name(re));
        can_be_substituted_p = false;
      }
      else {
        basic bt = basic_undefined;
 
        if(type_variable_p(rt)) { /* FI: What if not? core dump? */
          /* The variable type can hide a functional type via a
             typedef */
          type urt = ultimate_type(rt);
          if(type_variable_p(urt)) {
            bt = variable_basic(type_variable(urt));
 
            can_be_substituted_p =
              basic_int_p(bt)
              || basic_float_p(bt)
              || basic_overloaded_p(bt) /* Might be wrong, but necessary */
              || basic_complex_p(bt) /* Should not occur in old C code */
              || basic_logical_p(bt); /* Should not occur in old C code */
 
            pips_debug(9, "Variable %s is an arithmetic variable: %s\n",
                       entity_local_name(re), bool_to_string(can_be_substituted_p));
          }
        }
      }
      break; /* FI: The index expressions should be simplified too... */
    }
  case is_syntax_call:
    {
      call c = syntax_call(s);
 
      if(expression_constant_p(e)) {
        /* What is the type of the constant? */
        entity cste = call_function(c);
        basic rb = variable_basic(type_variable(functional_result(type_functional(entity_type(cste)))));
 
        can_be_substituted_p =
          basic_int_p(rb)
          || basic_float_p(rb)
          || basic_complex_p(rb); /* Should not occur in C, before C99 */
      }
      else if(gen_length(call_arguments(c))==2) {
        /* Check "+C" and "-C" */
        expression e1 = binary_call_lhs(c);
        expression e2 = binary_call_rhs(c);
        bool can_be_substituted_p1 = simplify_C_expression(e1);
        bool can_be_substituted_p2 = simplify_C_expression(e2);
        can_be_substituted_p = can_be_substituted_p1 && can_be_substituted_p2;
        if(can_be_substituted_p) {
          entity op = call_function(c);
          if(ENTITY_PLUS_C_P(op)) {
            call_function(c) = entity_intrinsic(PLUS_OPERATOR_NAME);
          }
          else if(ENTITY_MINUS_C_P(op)) {
            call_function(c) = entity_intrinsic(MINUS_OPERATOR_NAME);
          }
        }
      }
      else {
        /* Try to simplify the arguments, do not hope much from the result
           type because of overloading. */
        type ft = call_to_functional_type(c, true);
        type rt = ultimate_type(functional_result(type_functional(ft)));
        entity f = call_function(c);
 
        //pips_assert("The function type is functional", type_functional_p(entity_type(f)));
 
        FOREACH(EXPRESSION, se, call_arguments(c)) {
          (void) simplify_C_expression(se);
        }
 
        if(ENTITY_CONDITIONAL_P(f) || ENTITY_COMMA_P(f)) {
            can_be_substituted_p = false;
        }
        else if(type_variable_p(rt)) {
          basic rb = variable_basic(type_variable(rt));
 
          if(basic_overloaded_p(rb)) {
            /* a void expression such as (void) 0 results in an
             * undefined basic. And so may do a condition c? (void *)
             * 0 : (void *) 0.
             */
            rb = basic_of_expression(e);
          }
          else
            rb = copy_basic(rb);
 
          if(!basic_undefined_p(rb)) {
            /* FI: I guess, typedef equivalent to those could also be declared substituable */
            can_be_substituted_p =
              basic_int_p(rb)
              || basic_float_p(rb)
              || basic_complex_p(rb); /* Should not occur in C */
            free_basic(rb);
          }
          else {
            /* e must be a void expression, i.e. an expression returning no value */
            can_be_substituted_p = false;
          }
        }
        else {
          can_be_substituted_p = false;
        }
      }
      break;
    }
  case is_syntax_range:
    {
      range r = syntax_range(s);
      expression le = range_lower(r);
      expression ue = range_upper(r);
      expression ince = range_increment(r);
      (void) simplify_C_expression(le);
      (void) simplify_C_expression(ue);
      (void) simplify_C_expression(ince);
      can_be_substituted_p = false;
      break;
      }
  case is_syntax_cast:
  case is_syntax_sizeofexpression:
  case is_syntax_subscript:
  case is_syntax_application:
  case is_syntax_va_arg:
      can_be_substituted_p = false;
      break;
  default: pips_internal_error("Bad syntax tag");
    can_be_substituted_p = false; /* for gcc */
  }
 
  pips_debug(9, "End: %s\n", bool_to_string(can_be_substituted_p));
  return can_be_substituted_p;
}

References basic_complex_p, basic_float_p, basic_int_p, basic_logical_p, basic_of_expression(), basic_overloaded_p, basic_undefined, basic_undefined_p, binary_call_lhs, binary_call_rhs, bool_to_string(), call_arguments, call_function, call_to_functional_type(), copy_basic(), ENTITY_COMMA_P, ENTITY_CONDITIONAL_P, entity_intrinsic(), entity_local_name(), ENTITY_MINUS_C_P, ENTITY_PLUS_C_P, entity_type, entity_user_name(), EXPRESSION, expression_constant_p(), expression_syntax, f(), FOREACH, free_basic(), functional_result, gen_length(), 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, MINUS_OPERATOR_NAME, pips_debug, pips_internal_error, pips_user_warning, PLUS_OPERATOR_NAME, range_increment, range_lower, range_upper, reference_variable, syntax_call, syntax_range, syntax_reference, syntax_tag, type_functional, type_undefined_p, type_variable, type_variable_p, ultimate_type(), and variable_basic.

Referenced by MakeForloop().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_expression()

bool simplify_expression

(

expression *

pexp

)

use polynomials to simplify an expression in some cases this operation can change the basic of the expression.

E.g. n/4 -> .25 * n In that case we just undo the simplification

Parameters

pexp

exp

Definition at line 3770 of file expression.c.

                                            {
    expression exp = *pexp;
    bool result =false;
    if(!expression_undefined_p(exp)) {
        basic oldb = basic_of_expression(exp);
        Ppolynome pu = expression_to_polynome(exp);
        if((result=!POLYNOME_UNDEFINED_P(pu))) {
            expression pue = polynome_to_expression(pu);
            basic nbasic = basic_of_expression(pue);
            if(basic_equal_p(oldb,nbasic)) {
                free_expression(exp);
                *pexp=pue;
            }
            else {
                free_expression(pue);
            }
            free_basic(nbasic);
            polynome_rm(&pu);
        }
        free_basic(oldb);
    }
    return result;
}

References basic_equal_p(), basic_of_expression(), exp, expression_to_polynome(), expression_undefined_p, free_basic(), free_expression(), polynome_rm(), polynome_to_expression(), and POLYNOME_UNDEFINED_P.

Referenced by distance_between_expression(), do_simplify_expressions(), loop_annotate(), and simd_loop_unroll().

Here is the call graph for this function:

Here is the caller graph for this function:

simplify_expressions()

void simplify_expressions

(

void *

obj

)

Parameters

obj

bj

Definition at line 3801 of file expression.c.

                                     {
    gen_recurse(obj,call_domain,gen_true, do_simplify_expressions);
}

References call_domain, do_simplify_expressions(), gen_recurse, and gen_true().

Referenced by optimize_expressions().

Here is the call graph for this function:

Here is the caller graph for this function:

size_of_actual_array()

expression size_of_actual_array	(	entity	actual_array,
		list	l_actual_ref,
		int	i
	)

ifdebug(3)

{

fprintf(stderr, "\n Size of actual array without subscript value \n");

print_expression(e);

}

ifdebug(4)

{

fprintf(stderr, "\n j = %d \n",j);

fprintf(stderr, "\n prod : \n");

print_expression(prod);

fprintf(stderr, "\n sum =: \n");

print_expression(sum);

}

ifdebug(2)

{

fprintf(stderr, "\n Size of actual array - subscript value : \n");

print_expression(e);

}

ifdebug(2)

{

fprintf(stderr, "\n Size of actual array:\n");

print_expression(e);

}

Parameters

actual_array	ctual_array
l_actual_ref	_actual_ref

Definition at line 4197 of file expression.c.

{
  expression e = expression_undefined;
  variable actual_var = type_variable(entity_type(actual_array));
  list l_actual_dims = variable_dimensions(actual_var);
  int num_dim = gen_length(l_actual_dims), j;
  for (j=i+1; j<= num_dim; j++)
  {
    dimension dim_j = find_ith_dimension(l_actual_dims,j);
    expression lower_j = dimension_lower(dim_j);
    expression upper_j = dimension_upper(dim_j);
    expression size_j;
    if (expression_constant_p(lower_j) && (expression_to_int(lower_j)==1))
      size_j = copy_expression(upper_j);
    else
    {
      size_j = binary_intrinsic_expression(MINUS_OPERATOR_NAME,upper_j,lower_j);
      size_j =  binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                    copy_expression(size_j),int_to_expression(1));
    }
    if (expression_undefined_p(e))
      e = copy_expression(size_j);
    else
      e = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,copy_expression(e),size_j);
  }
  // FI: to avoid cycles between librairies ri-util and prettyprint
  /* ifdebug(3) */
  /* { */
  /*   fprintf(stderr, "\n Size of actual array without subscript value \n"); */
  /*   print_expression(e); */
  /* } */
  if (l_actual_ref!=NIL)
  {
    // the actual argument is an array element name,
    // we have to compute the subscript value also
    expression sum = expression_undefined, prod = expression_undefined;
    ifdebug(3)
      fprintf(stderr, "\n actual argument is an array element name:");
    for (j=i+1; j<= num_dim; j++)
    {
      dimension dim_j = find_ith_dimension(l_actual_dims,j);
      expression lower_j = dimension_lower(dim_j);
      expression sub_j = find_ith_argument(l_actual_ref,j);
      expression upper_j = dimension_upper(dim_j);
      expression size_j,sub_low_j,elem_j;
      if ( expression_constant_p(lower_j) && (expression_to_int(lower_j)==1))
        size_j = copy_expression(upper_j);
      else
            {
              size_j = binary_intrinsic_expression(
          MINUS_OPERATOR_NAME, upper_j, lower_j);
              size_j =  binary_intrinsic_expression(
          PLUS_OPERATOR_NAME, copy_expression(size_j),int_to_expression(1));
            }
      // CAUTION : heuristic
      // We can distinguish or not the special case: lower_bound = subscript,
      // 1. If not, we do not lose information such as in SPEC95/applu.f :
            //    real u(5,33,33,33)
            //    call exact(i,j,1,u(1,i,j,1))
                  // => size = 5.33.33.33 -((i-1)5 +(j-1)5.33 +(k-1)5.33.33),
                  //    not 5.33.33.33 -((i-1)5 +(j-1)5.33) (as k=1)
                  // subroutine exact(i,j,k,u000ijk)
                  // We will have more combinations, but more chance to translate
                  // the size of actual array to the callee's frame
            // 2. If yes, there are so much combinations =>
      //    it takes long time to compute, such as in SPEC95/turb3d.f
            //  CONCLUSION : for time efficiency, we distinguish this case
      if (!same_expression_p(sub_j,lower_j))
            {
              sub_low_j = binary_intrinsic_expression(MINUS_OPERATOR_NAME,
                                                sub_j,lower_j);
              if (expression_undefined_p(prod))
          elem_j = copy_expression(sub_low_j);
              else
          elem_j = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,
                                               sub_low_j,prod);
              if (expression_undefined_p(sum))
          sum = copy_expression(elem_j);
              else
          sum = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                            sum, elem_j);
            }
      if (expression_undefined_p(prod))
        prod = copy_expression(size_j);
      else
        prod = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,
                                           prod,size_j);
      // FI: to avoid cycles between librairies ri-util and prettyprint
      /* ifdebug(4) */
      /*            { */
      /*              fprintf(stderr, "\n j = %d \n",j); */
      /*              fprintf(stderr, "\n prod : \n"); */
      /*              print_expression(prod); */
      /*              fprintf(stderr, "\n sum =: \n"); */
      /*              print_expression(sum); */
      /*            } */
    }
    if (!expression_undefined_p(sum))
    {
      e =  binary_intrinsic_expression(MINUS_OPERATOR_NAME,
                                       copy_expression(e),sum);
      // FI: to avoid cycles between librairies ri-util and prettyprint
      /* ifdebug(2) */
      /*            { */
      /*              fprintf(stderr, "\n Size of actual array - subscript value : \n"); */
      /*              print_expression(e); */
      /*            } */
    }
  }
      // FI: to avoid cycles between librairies ri-util and prettyprint
  /* ifdebug(2) */
  /* { */
  /*   fprintf(stderr, "\n Size of actual array:\n"); */
  /*   print_expression(e); */
  /* } */
  return e;
}

References binary_intrinsic_expression, copy_expression(), dimension_lower, dimension_upper, entity_type, expression_constant_p(), expression_to_int(), expression_undefined, expression_undefined_p, find_ith_argument(), find_ith_dimension(), fprintf(), gen_length(), ifdebug, int_to_expression(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, NIL, PLUS_OPERATOR_NAME, same_expression_p(), sum(), type_variable, and variable_dimensions.

Referenced by interprocedural_abc_arrays().

Here is the call graph for this function:

Here is the caller graph for this function:

sizeofexpression_equal_p()

bool sizeofexpression_equal_p	(	sizeofexpression	s0,
		sizeofexpression	s1
	)

Parameters

s0	0
s1	1

Definition at line 1446 of file expression.c.

{
    if(sizeofexpression_type_p(s0) && sizeofexpression_type_p(s1))
        return type_equal_p(sizeofexpression_type(s0), sizeofexpression_type(s1));
    if(sizeofexpression_expression_p(s0) && sizeofexpression_expression_p(s1))
        return expression_equal_p(sizeofexpression_expression(s0),sizeofexpression_expression(s1));
    return false;
}

References expression_equal_p(), s1, sizeofexpression_expression, sizeofexpression_expression_p, sizeofexpression_type, sizeofexpression_type_p, and type_equal_p().

Referenced by syntax_equal_p().

Here is the call graph for this function:

Here is the caller graph for this function:

statement_normalize_subscripts()

void statement_normalize_subscripts

(

statement

s

)

To be used for module statements.

Definition at line 4471 of file expression.c.

{
  gen_recurse(s, expression_domain, gen_true, normalize_subscript_expression);
}

References expression_domain, gen_recurse, gen_true(), and normalize_subscript_expression().

Referenced by actual_c_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

store_independent_reference_p()

bool store_independent_reference_p

(

reference

r

)

Does this reference define the same set of memory locations regardless of the current (environment and) memory state?

This function copes with standard references, extended to pointer references such as p[i], not with general points-to references, which are extended to cope with structs and implicit dereferencing. Points-to references are/should be handled in effects-util, not in ri-util.

Definition at line 3108 of file expression.c.

{
  bool independent_p = true;
  //list ind = reference_indices(r);
  entity v = reference_variable(r);
  type t = ultimate_type(entity_type(v));
 
  if(pointer_type_p(t)) {
    independent_p = false;
  }
  else {
    independent_p = reference_with_constant_indices_p(r);
  }
 
  return independent_p;
}

References entity_type, pointer_type_p(), reference_variable, reference_with_constant_indices_p(), and ultimate_type().

Referenced by basic_update_reflhs_with_rhs_to_transformer(), generic_reference_to_transformer(), opkill_may_reference(), and opkill_must_reference().

Here is the call graph for this function:

Here is the caller graph for this function:

struct_initialization_expression_to_expressions()

list struct_initialization_expression_to_expressions

(

expression

e

)

Returns a list of expressions hidden by the brace function.

First cut: FI not too sure about recursive calls to the brace function.

Definition at line 4073 of file expression.c.

{
  pips_assert("rhs is a C initialization expression",
              C_initialization_expression_p(e));
  syntax s = expression_syntax(e);
  call c = syntax_call(s);
  list el = call_arguments(c);
  return el;
}

References C_initialization_expression_p(), call_arguments, expression_syntax, pips_assert, and syntax_call.

Referenced by struct_initialization_to_points_to().

Here is the call graph for this function:

Here is the caller graph for this function:

sub_expression_p()

bool sub_expression_p

(

expression

e

)

Definition at line 991 of file expression.c.

                                    {
  return operator_expression_p(e, MINUS_OPERATOR_NAME)
    || operator_expression_p(e, MINUS_C_OPERATOR_NAME)
    ;
}

References MINUS_C_OPERATOR_NAME, MINUS_OPERATOR_NAME, and operator_expression_p().

Referenced by incrementation_expression_to_increment().

Here is the call graph for this function:

Here is the caller graph for this function:

subscript_equal_p()

bool subscript_equal_p	(	subscript	s1,
		subscript	s2
	)

Parameters

s1	1
s2	2

Definition at line 1495 of file expression.c.

                                                   {
            return expression_equal_p(subscript_array(s1),subscript_array(s2))
        && gen_equals(subscript_indices(s1),subscript_indices(s2),(gen_eq_func_t)expression_equal_p);
}

References expression_equal_p(), gen_equals(), s1, subscript_array, and subscript_indices.

Referenced by syntax_equal_p().

Here is the call graph for this function:

Here is the caller graph for this function:

subscript_expressions_to_constant_subscript_expressions()

list subscript_expressions_to_constant_subscript_expressions

(

list

sl

)

make a full copy of the subscript expression list, preserve constant subscripts, replace non-constant subscript by the star subscript expression.

Parameters

sl

l

Definition at line 3981 of file expression.c.

{
  list nsl = NIL;
 
  FOREACH(EXPRESSION, s, sl){
    expression ni = expression_undefined;
    value v = EvalExpression(s);
    if(value_constant_p(v) && constant_int_p(value_constant(v))) {
      int i = constant_int(value_constant(v));
      ni = int_to_expression(i);
    }
    else {
      ni = make_unbounded_expression();
    }
    nsl = CONS(EXPRESSION, ni, nsl);
  }
  nsl = gen_nreverse(nsl);
  return nsl;
}

References CONS, constant_int, constant_int_p, EvalExpression(), EXPRESSION, expression_undefined, FOREACH, gen_nreverse(), int_to_expression(), make_unbounded_expression(), NIL, value_constant, and value_constant_p.

Referenced by reference_dereferencing_to_points_to(), and subscript_to_points_to_sinks().

Here is the call graph for this function:

Here is the caller graph for this function:

subscript_value_stride()

expression subscript_value_stride	(	entity	arr,
		list	l_inds
	)

ifdebug(4)

{

pips_debug(4,"\nStride of subscript value:");

print_expression(retour);

}

Parameters

arr	rr
l_inds	_inds

Definition at line 4127 of file expression.c.

{
  expression retour = int_to_expression(0);
  if (!ENDP(l_inds))
  {
    variable var = type_variable(entity_type(arr));
    expression prod = expression_undefined;
    list l_dims = variable_dimensions(var);
    int num_dim = gen_length(l_inds),i;
    basic b = variable_basic(type_variable(entity_type(arr)));
    expression e_size = int_to_expression(SizeOfElements(b));
    for (i=1; i<= num_dim; i++)
    {
      dimension dim_i = find_ith_dimension(l_dims,i);
      expression lower_i = dimension_lower(dim_i);
      expression sub_i = find_ith_argument(l_inds,i);
      expression upper_i = dimension_upper(dim_i);
      expression size_i;
      if ( expression_constant_p(lower_i) && (expression_to_int(lower_i)==1))
        size_i = copy_expression(upper_i);
      else
            {
              size_i = binary_intrinsic_expression(
          MINUS_OPERATOR_NAME, upper_i, lower_i);
              size_i =  binary_intrinsic_expression(
          PLUS_OPERATOR_NAME, copy_expression(size_i), int_to_expression(1));
            }
      if (!same_expression_p(sub_i,lower_i))
            {
              expression sub_low_i =
          binary_intrinsic_expression(MINUS_OPERATOR_NAME, sub_i, lower_i);
              expression elem_i;
              if (expression_undefined_p(prod))
          elem_i = copy_expression(sub_low_i);
              else
          elem_i = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,
                                               sub_low_i,prod);
              if (expression_equal_integer_p(retour,0))
          retour = copy_expression(elem_i);
              else
          retour = binary_intrinsic_expression(PLUS_OPERATOR_NAME,
                                               retour, elem_i);
            }
      if (expression_undefined_p(prod))
        prod = copy_expression(size_i);
      else
        prod = binary_intrinsic_expression(MULTIPLY_OPERATOR_NAME,
                                           prod,size_i);
    }
    if (!expression_equal_integer_p(retour,0))
      retour = binary_intrinsic_expression(
        MULTIPLY_OPERATOR_NAME, copy_expression(retour), e_size);
  }
  // FI: to avoid cycles between librairies ri-util and prettyprint
  /* ifdebug(4) */
  /* { */
  /*   pips_debug(4,"\nStride of subscript value:"); */
  /*   print_expression(retour); */
  /* } */
  return retour;
}

References binary_intrinsic_expression, copy_expression(), dimension_lower, dimension_upper, ENDP, entity_type, expression_constant_p(), expression_equal_integer_p(), expression_to_int(), expression_undefined, expression_undefined_p, find_ith_argument(), find_ith_dimension(), gen_length(), int_to_expression(), MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, PLUS_OPERATOR_NAME, same_expression_p(), SizeOfElements(), type_variable, variable_basic, and variable_dimensions.

Referenced by add_aliases_for_current_call_site(), alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), dynamic_alias_check_flt(), offset_in_caller(), and same_or_equivalence_argument_add_aliases().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_entity_in_call()

static void substitute_entity_in_call ( call  c, ctx_substitute_t *  ctx  )

static

Definition at line 2750 of file expression.c.

                                                                      {
  entity old = ctx->old;
  entity new = ctx->new;
 
  if (same_entity_p(call_function(c),old)) {
    call_function(c) = new;
  }
}

References call_function, ctx_substitute::new, ctx_substitute::old, and same_entity_p().

Referenced by substitute_entity_in_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_entity_in_expression()

expression substitute_entity_in_expression	(	entity	old,
		entity	new,
		expression	e
	)

This function replaces all the occurences of an old entity in the expression exp by the new entity.

It returns the expression modified. I think we can write this function by using gen_context_multi_recurse ... * To do .... NN gen_context_multi_recurse done in r22231 Modify the entry expression e by side effect

Parameters

old	entity to replace
new	entity that will replace old
e	expression in will the entity old will be replaced

Returns

e expression modified by side effect

Parameters

old	ld
new	ew

Definition at line 2792 of file expression.c.

{
  ctx_substitute_t ctx;
  ctx.old = old;
  ctx.new = new;
 
  gen_context_multi_recurse(
      e, &ctx,
      reference_domain, gen_true, substitute_variable_in_reference,
      call_domain, gen_true, substitute_entity_in_call,
      NULL);
  return e;
}

References call_domain, gen_context_multi_recurse(), gen_true(), ctx_substitute::new, ctx_substitute::old, reference_domain, substitute_entity_in_call(), and substitute_variable_in_reference().

Here is the call graph for this function:

substitute_entity_variable_in_expression()

expression substitute_entity_variable_in_expression	(	entity	old,
		entity	new,
		expression	e
	)

(This function isn't use for the moment) This function replaces all the occurrences of an old entity in the expression exp by the new entity.

It returns the expression modified. It replaces only entity when it's an variable. So a recurse can be made on reference to replace the entity. (to not consider only variable entity have to make a special case for call, call_function) Modify the entry expression e by side effect

Parameters

old	entity to replace
new	entity that will replace old
e	expression in will the entity old will be replaced

Returns

e expression modified by side effect

Parameters

old	ld
new	ew

Definition at line 2772 of file expression.c.

{
  ctx_substitute_t ctx;
  ctx.old = old;
  ctx.new = new;
 
  gen_context_recurse(e, &ctx, reference_domain, gen_true2, substitute_variable_in_reference);
  return e;
}

References gen_context_recurse, gen_true2(), ctx_substitute::new, ctx_substitute::old, reference_domain, and substitute_variable_in_reference().

Here is the call graph for this function:

substitute_variable_in_reference()

static void substitute_variable_in_reference ( reference  r, ctx_substitute_t *  ctx  )

static

Definition at line 2741 of file expression.c.

                                                                                  {
  entity old = ctx->old;
  entity new = ctx->new;
 
  if (same_entity_p(reference_variable(r), old)) {
    reference_variable(r) = new;
  }
}

References ctx_substitute::new, ctx_substitute::old, reference_variable, and same_entity_p().

Referenced by substitute_entity_in_expression(), and substitute_entity_variable_in_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

substraction_expression_p()

bool substraction_expression_p

(

expression

e

)

Test if an expression is an substraction.

Definition at line 1000 of file expression.c.

                                             {
  return operator_expression_p(e, MINUS_OPERATOR_NAME)
    || operator_expression_p(e, MINUS_C_OPERATOR_NAME);
}

References MINUS_C_OPERATOR_NAME, MINUS_OPERATOR_NAME, and operator_expression_p().

Here is the call graph for this function:

suggest_basic_for_expression()

tag suggest_basic_for_expression

(

expression

e

)

a BASIC tag is returned for the expression this is a preliminary version.

should be improved. was in HPFC.

must be a call

else some clever analysis could be done

Definition at line 130 of file expression.c.

{
  tag   result = basic_tag(expression_basic(e));
 
  if (result==is_basic_overloaded)
    {
      syntax s = expression_syntax(e);
 
      /*  must be a call
       */
      assert(syntax_call_p(s));
 
      if (ENTITY_RELATIONAL_OPERATOR_P(call_function(syntax_call(s))))
        result = is_basic_logical;
      else
        {
          /* else some clever analysis could be done
           */
          pips_user_warning("an overloaded is turned into an int...\n");
          result = is_basic_int;
        }
    }
 
  return result;
}

References assert, basic_tag, call_function, ENTITY_RELATIONAL_OPERATOR_P, expression_basic(), expression_syntax, is_basic_int, is_basic_logical, is_basic_overloaded, pips_user_warning, syntax_call, and syntax_call_p.

Here is the call graph for this function:

syntax_equal_p()

bool syntax_equal_p	(	syntax	s1,
		syntax	s2
	)

Parameters

s1	1
s2	2

Definition at line 1462 of file expression.c.

{
  tag t1 = syntax_tag(s1);
  tag t2 = syntax_tag(s2);
 
  if(t1!=t2)
    return false;
 
  switch(t1) {
  case is_syntax_reference:
    return reference_equal_p(syntax_reference(s1), syntax_reference(s2));
  case is_syntax_range:
    return range_equal_p(syntax_range(s1), syntax_range(s2));
  case is_syntax_call:
    return call_equal_p(syntax_call(s1), syntax_call(s2));
  case is_syntax_cast:
    return cast_equal_p(syntax_cast(s1), syntax_cast(s2));
  case is_syntax_sizeofexpression:
    return sizeofexpression_equal_p(syntax_sizeofexpression(s1),syntax_sizeofexpression(s2));
  case is_syntax_subscript:
    return subscript_equal_p(syntax_subscript(s1),syntax_subscript(s2));
  case is_syntax_application:
  case is_syntax_va_arg:
    pips_internal_error("Not implemented for syntax tag %d\n", t1);
  default:
    return false;
    break;
  }
 
  pips_internal_error("illegal. syntax tag %d", t1);
  return false;
}

References call_equal_p(), cast_equal_p(), 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, pips_internal_error, range_equal_p(), reference_equal_p(), s1, sizeofexpression_equal_p(), subscript_equal_p(), syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_subscript, and syntax_tag.

Referenced by expression_equal_p().

Here is the call graph for this function:

Here is the caller graph for this function:

syntax_to_expression()

expression syntax_to_expression

(

syntax

s

)

generates an expression from a syntax

Definition at line 3581 of file expression.c.

                                          {
  return make_expression(
      s,
      normalized_undefined
      );
}

References make_expression(), and normalized_undefined.

Referenced by initialization_list_to_statements(), isolate_patch_reference(), make_entity_expression(), and make_subscript_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

syntax_to_reference_list()

list syntax_to_reference_list	(	syntax	s,
		list	lr
	)

Parameters

lr

r

Definition at line 1270 of file expression.c.

{
    switch(syntax_tag(s)) {
    case is_syntax_reference:
        lr = gen_nconc(lr, CONS(REFERENCE, syntax_reference(s), NIL));
        MAPL(ce, {
            expression e = EXPRESSION(CAR(ce));
            lr = expression_to_reference_list(e, lr);
            },
             reference_indices(syntax_reference(s)));
        break;
    case is_syntax_range:
        lr = expression_to_reference_list(range_lower(syntax_range(s)), lr);
        lr = expression_to_reference_list(range_upper(syntax_range(s)), lr);
        lr = expression_to_reference_list(range_increment(syntax_range(s)),
                                          lr);
        break;
    case is_syntax_call:
        MAPL(ce, {
            expression e = EXPRESSION(CAR(ce));
            lr = expression_to_reference_list(e, lr);
            },
             call_arguments(syntax_call(s)));
        break;
    case is_syntax_cast: {
      cast c = syntax_cast(s);
      expression e = cast_expression(c);
      lr = expression_to_reference_list(e, lr);
      break;
    }
    case is_syntax_sizeofexpression: {
      sizeofexpression soe = syntax_sizeofexpression(s);
      if(sizeofexpression_expression_p(soe)) {
        expression e = sizeofexpression_expression(soe);
        lr = expression_to_reference_list(e, lr);
      }
      break;
    }
    case is_syntax_subscript: {
      subscript sub = syntax_subscript(s);
      expression e = subscript_array(sub);
      list il = subscript_indices(sub);
      lr = expression_to_reference_list(e, lr);
      FOREACH(EXPRESSION, i,il) {
      lr = expression_to_reference_list(i, lr);
      }
      break;
    }
    case is_syntax_application: {
      application app = syntax_application(s);
      expression f = application_function(app);
      list al = application_arguments(app);
      lr = expression_to_reference_list(f, lr);
      FOREACH(EXPRESSION, a,al) {
      lr = expression_to_reference_list(a, lr);
      }
      break;
    }
    case is_syntax_va_arg: {
      list two = syntax_va_arg(s);
      FOREACH(SIZEOFEXPRESSION, soe, two) {
        if(sizeofexpression_expression_p(soe)) {
          expression e = sizeofexpression_expression(soe);
          lr = expression_to_reference_list(e, lr);
        }
      }
      break;
    }
    default:
        pips_internal_error("illegal tag %d",
                   syntax_tag(s));
 
    }
    return lr;
}

References application_arguments, application_function, call_arguments, CAR, cast_expression, CONS, EXPRESSION, expression_to_reference_list(), f(), FOREACH, gen_nconc(), 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, MAPL, NIL, pips_internal_error, range_increment, range_lower, range_upper, REFERENCE, reference_indices, SIZEOFEXPRESSION, sizeofexpression_expression, sizeofexpression_expression_p, subscript_array, subscript_indices, syntax_application, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_subscript, syntax_tag, and syntax_va_arg.

Referenced by expression_to_reference_list().

Here is the call graph for this function:

Here is the caller graph for this function:

trivial_expression_p()

int trivial_expression_p

(

expression

e

)

This function returns:

1, if e is a relational expression that is always true

-1, if e is a relational expression that is always false

0, otherwise.

It should be called trivial_condition_p().

If e is a relational expression

ifdebug(3) {

fprintf(stderr, "Normalizes of expression:");

print_expression(e);

print_normalized(n1);

print_normalized(n2);

}

The test if an expression is trivial (always true or false) or not depends on the operator of the expression : (op= {<=,<,>=,>,==,!=}) so we have to treat each different case

Expression : v != 0

Expression : v == 0

Expression : v >= 0

Expression : v <= 0

Expression : v < 0

Expression : v > 0

Definition at line 679 of file expression.c.

{
  if (relational_expression_p(e))
    {
      /* If e is a relational expression*/
      list args = call_arguments(syntax_call(expression_syntax(e)));
      expression e1 =  EXPRESSION(CAR(args));
      expression e2 = EXPRESSION(CAR(CDR(args)));
      normalized n1,n2;
      entity op;
      if (expression_undefined_p(e1) ||expression_undefined_p(e2) ) return 0;
      n1 = NORMALIZE_EXPRESSION(e1);
      n2 = NORMALIZE_EXPRESSION(e2);
      op = call_function(syntax_call(expression_syntax(e)));
 
      // FI: no cycle between the ri-util and prettyprint libraries
      /* ifdebug(3) { */
      /*        fprintf(stderr, "Normalizes of  expression:"); */
      /*        print_expression(e); */
      /*        print_normalized(n1); */
      /*        print_normalized(n2); */
      /* } */
 
      if (normalized_linear_p(n1) && normalized_linear_p(n2))
        {
          Pvecteur v1 = normalized_linear(n1);
          Pvecteur v2 = normalized_linear(n2);
          Pvecteur v = vect_substract(v1,v2);
 
          /* The test if an expression is trivial (always true or false) or not
           * depends on the operator of the expression :
           * (op= {<=,<,>=,>,==,!=}) so we have to treat each different case */
 
          if (vect_constant_p(v))
            {
              if (ENTITY_NON_EQUAL_P(op))
                {
                  /* Expression :  v != 0 */
                  if (VECTEUR_NUL_P(v)) return -1;
                  if (value_zero_p(val_of(v))) return -1;
                  if (value_notzero_p(val_of(v))) return 1;
                }
              if (ENTITY_EQUAL_P(op))
                {
                  /* Expression :  v == 0 */
                  if (VECTEUR_NUL_P(v)) return 1;
                  if (value_zero_p(val_of(v))) return 1;
                  if (value_notzero_p(val_of(v))) return -1;
                }
              if (ENTITY_GREATER_OR_EQUAL_P(op))
                {
                  /* Expression :  v >= 0 */
                  if (VECTEUR_NUL_P(v)) return 1;
                  if (value_posz_p(val_of(v))) return 1;
                  if (value_neg_p(val_of(v))) return -1;
                }
              if (ENTITY_LESS_OR_EQUAL_P(op))
                {
                  /* Expression :  v <= 0 */
                  if (VECTEUR_NUL_P(v)) return 1;
                  if (value_negz_p(val_of(v))) return 1;
                  if (value_pos_p(val_of(v))) return -1;
                }
              if (ENTITY_LESS_THAN_P(op))
                {
                  /* Expression :  v < 0 */
                  if (VECTEUR_NUL_P(v)) return -1;
                  if (value_neg_p(val_of(v))) return 1;
                  if (value_posz_p(val_of(v))) return -1;
                }
              if (ENTITY_GREATER_THAN_P(op))
                {
                  /* Expression :  v > 0 */
                  if (VECTEUR_NUL_P(v)) return -1;
                  if (value_pos_p(val_of(v))) return 1;
                  if (value_negz_p(val_of(v))) return -1;
                }
            }
          return 0;
        }
      return 0;
    }
  return 0;
}

References call_arguments, call_function, CAR, CDR, ENTITY_EQUAL_P, ENTITY_GREATER_OR_EQUAL_P, ENTITY_GREATER_THAN_P, ENTITY_LESS_OR_EQUAL_P, ENTITY_LESS_THAN_P, ENTITY_NON_EQUAL_P, EXPRESSION, expression_syntax, expression_undefined_p, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, relational_expression_p(), syntax_call, val_of, value_neg_p, value_negz_p, value_notzero_p, value_pos_p, value_posz_p, value_zero_p, vect_constant_p(), vect_substract(), and VECTEUR_NUL_P.

Referenced by abc_with_allocation_size(), alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_and_scalar_variable_in_module_flt(), alias_check_array_variable_in_caller_flt(), alias_check_array_variable_in_module_flt(), alias_check_scalar_and_array_variables_in_caller(), alias_check_scalar_and_array_variables_in_module(), alias_check_two_array_variables_in_caller(), alias_check_two_array_variables_in_module(), alias_check_two_scalar_variables_in_caller(), alias_check_two_scalar_variables_in_module(), bottom_up_abc_base_reference_implied_do(), bottom_up_abc_reference(), impact_check_two_scalar_variables_in_path(), and top_down_abc_call().

Here is the call graph for this function:

Here is the caller graph for this function:

true_expression_p()

bool true_expression_p

(

expression

e

)

Definition at line 1113 of file expression.c.

{
  return operator_expression_p(e,TRUE_OPERATOR_NAME);
}

References operator_expression_p(), and TRUE_OPERATOR_NAME.

Referenced by add_array_dimension_bound_test(), alias_check_array_and_scalar_variable_in_caller_flt(), alias_check_array_variable_in_caller_flt(), insert_test_before_caller(), insert_test_before_statement(), make_bottom_up_abc_tests(), make_interprocedural_abc_tests(), and top_down_abc_array().

Here is the call graph for this function:

Here is the caller graph for this function:

unary_minus_expression_p()

bool unary_minus_expression_p

(

expression

e

)

Definition at line 1030 of file expression.c.

{
    return operator_expression_p(e, UNARY_MINUS_OPERATOR_NAME);
}

References operator_expression_p(), and UNARY_MINUS_OPERATOR_NAME.

Referenced by expression_opposite_p().

Here is the call graph for this function:

Here is the caller graph for this function:

unbounded_dimension_p()

bool unbounded_dimension_p

(

dimension

dim

)

bool unbounded_dimension_p(dim) input : a dimension of an array entity.

output : true if the last dimension is unbounded (*), false otherwise. modifies : nothing comment :

Parameters

dim

im

Definition at line 1130 of file expression.c.

{
    syntax dim_synt = expression_syntax(dimension_upper(dim));
    bool res = false;
 
    if (syntax_call_p(dim_synt)) {
        const char* dim_nom = entity_local_name(call_function(syntax_call(dim_synt)));
 
        if (same_string_p(dim_nom, UNBOUNDED_DIMENSION_NAME))
            res = true;
    }
 
    return(res);
}

References call_function, dimension_upper, entity_local_name(), expression_syntax, same_string_p, syntax_call, syntax_call_p, and UNBOUNDED_DIMENSION_NAME.

Referenced by array_bounded_p(), assumed_size_array_p(), bottom_up_abc_base_reference_implied_do(), bottom_up_abc_reference(), build_call_STEP_init_regionArray(), C_pointer_type_p(), C_type_to_pointed_type(), entity_unbounded_p(), subscript_to_points_to_sinks(), top_down_abc_call(), top_down_abc_dimension(), and words_dimension().

Here is the call graph for this function:

Here is the caller graph for this function:

unbounded_entity_p()

bool unbounded_entity_p

(

entity

f

)

Definition at line 4323 of file expression.c.

{
  const char* n = entity_local_name(f);
  return (same_string_p(n, UNBOUNDED_DIMENSION_NAME));
}

References entity_local_name(), f(), same_string_p, and UNBOUNDED_DIMENSION_NAME.

Referenced by store_independent_points_to_indices_p(), and unbounded_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

unbounded_expression_p()

bool unbounded_expression_p

(

expression

e

)

Definition at line 4329 of file expression.c.

{
  syntax s = expression_syntax(e);
  if (syntax_call_p(s)) {
    entity f = call_function(syntax_call(s));
    return unbounded_entity_p(f);
  }
  return false;
}

References call_function, expression_syntax, f(), syntax_call, syntax_call_p, and unbounded_entity_p().

Referenced by any_expression_to_transformer(), array_references_may_conflict_p(), cell_is_xxx_p(), cell_reference_compare(), compatible_points_to_subscripts_p(), constant_reference_to_normalized_constant_reference(), do_brace_expression_to_updated_type(), effect_to_store_independent(), equal_must_vreference(), exact_points_to_subscript_list_p(), expression_to_points_to_sinks_with_offset(), flow_sensitive_malloc_to_points_to_sinks(), generic_atomic_points_to_reference_p(), malloc_arg_to_type(), module_initial_parameter_pv(), old_effects_conflict_p(), opkill_may_vreference(), opkill_must_vreference(), points_to_indices_to_subscript_indices(), points_to_indices_to_unbounded_indices(), points_to_reference_included_p(), points_to_subscripts_to_number_of_unbounded_dimensions(), proper_to_summary_simple_effect(), reference_to_points_to_translations(), reference_unbounded_indices_p(), reference_with_unbounded_indices_p(), reference_with_unbounded_subscript_p(), refine_points_to_cell_subscripts(), simple_cell_reference_preceding_p(), simple_cells_inclusion_p(), simple_cells_intersection_p(), unique_location_cell_p(), variable_references_may_conflict_p(), words_range(), and words_subscript_range().

Here is the call graph for this function:

Here is the caller graph for this function:

update_expression_syntax()

void update_expression_syntax	(	expression	e,
		syntax	s
	)

frees expression syntax of e and replace it by the new syntax s

Definition at line 3564 of file expression.c.

{
    unnormalize_expression(e);
    free_syntax(expression_syntax(e));
    expression_syntax(e)=s;
}

References expression_syntax, free_syntax(), and unnormalize_expression().

Referenced by cleanup_subscript_pre(), convert_pointer_to_array(), convert_pointer_to_array_aux(), do_array_to_pointer_patch_call_expression(), do_array_to_pointer_walk_call_and_patch(), do_array_to_pointer_walk_expression(), do_atomize_call(), do_expression_reduction(), do_linearize_pointer_is_expression(), do_linearize_prepatch_subscript(), do_linearize_remove_dereferencment_walker(), do_loop_nest_unswitching(), do_reduction_atomization(), do_simplify_constant_address_expression(), do_symbolic_tiling(), do_terapix_loop_optimizer(), isolate_patch_reference(), partial_eval_syntax(), perform_substitution_in_expression(), rename_op(), replace_entities_expression_walker(), replace_entity_by_expression_expression_walker(), replace_subscript(), simplify_subscript(), substitute_expression_walker(), terapix_normalize_tests(), and try_reorder_expression_call().

Here is the call graph for this function:

Here is the caller graph for this function:

user_call_p()

bool user_call_p

(

call

c

)

Test if a call is a user call.

Definition at line 4361 of file expression.c.

                         {
  entity f = call_function(c);
  value v = entity_initial(f);
  return value_code_p(v);
}

References call_function, entity_initial, f(), and value_code_p.

Referenced by copy_from_call(), copy_to_call(), costly_task(), look_for_user_call(), pragma_scop(), and statement_contains_user_call_p().

Here is the call graph for this function:

Here is the caller graph for this function:

user_function_call_p()

bool user_function_call_p

(

expression

e

)

Definition at line 1068 of file expression.c.

{
    syntax s = expression_syntax(e);
    bool user_function_call_p = false;
 
    if(syntax_call_p(s)) {
        call c = syntax_call(s);
        entity f = call_function(c);
        value v = entity_initial(f);
        user_function_call_p = value_code_p(v);
    }
    else {
        user_function_call_p = false;
    }
 
    return user_function_call_p;
}

References call_function, entity_initial, expression_syntax, f(), syntax_call, syntax_call_p, and value_code_p.

Here is the call graph for this function:

Value_to_expression()

expression Value_to_expression

(

Value

v

)

added interface for linear stuff.

it is not ok if Value is not an int, but if Value is changed sometime, I guess code that use this function will not need any change. FC.

Definition at line 1251 of file expression.c.

{
    return(int_to_expression(VALUE_TO_INT(v)));
}

References int_to_expression(), and VALUE_TO_INT.

Referenced by array_access_to_array_ranges(), constraints_to_loop_bound(), do_solve_hardware_constraints_on_nb_proc(), extract_the_align(), fusion(), fusion_buffer(), generate_one_message(), Hierarchical_tiling(), hpfc_broadcast_buffers(), make_rational_exp(), Tiling2_buffer(), Tiling_buffer_allocation(), and update_indices_for_local_computation().

Here is the call graph for this function:

Here is the caller graph for this function:

zero_expression_p()

bool zero_expression_p

(

expression

e

)

Definition at line 1217 of file expression.c.

{
  bool zero_p = false;
  if(expression_call_p(e)) {
    call c = expression_call(e);
    entity f = call_function(c);
    if(f==int_to_entity(0))
      zero_p = true;
  }
  return zero_p;
}

References call_function, expression_call(), expression_call_p(), f(), and int_to_entity().

Referenced by binary_intrinsic_call_to_points_to_sinks(), make_send_receive_conversion(), offset_points_to_cell(), points_to_translation_of_formal_parameters(), and reference_to_points_to_translations().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

out_flt

FILE* out_flt = NULL

static

Definition at line 2719 of file expression.c.

Referenced by davinci_dump_all_expressions(), and expr_flt().