special_cases.c File Reference

#include "defines-local.h"
#include "conversion.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"

Include dependency graph for special_cases.c:

Go to the source code of this file.

Data Structures
struct	t_reduction

Macros
#define	MAX_REDUCTION   1
	HPFC module, Fabien Coelho, May 1993. More...
#define	MIN_REDUCTION   2
#define	SUM_REDUCTION   3
#define	expression_complex_p(e)    (normalized_complex_p(expression_normalized(e)))
	bool subarray_shift_p(s, pe, plvect) statement s; entity *pe; list *plvect; More...
#define	XDEBUG(msg)    pips_debug(6, "statement %p: " msg "\n", (void*) s)
	bool full_copy_p(statement s, reference * pleft, reference * pright) More...

Typedefs
typedef struct t_reduction	t_reduction

Functions
static t_reduction *	find_reduction (const char *s)
	static t_reduction *find_reduction(c) More...
bool	hpfc_entity_reduction_p (entity e)
	bool call_reduction_p(c) More...
bool	call_reduction_p (call c)
static void	reduction_parameters (call c, t_reduction **pred, basic *pb, int *pdim, entity *pe, list *pl)
static char *	reduction_name (int kind)
static entity	make_reduction_function (string prefix, int ndim, int kind, basic base, int nargs)
	find or create an entity for the reduction function... More...
bool	compile_reduction (statement initial, statement *phost, statement *pnode)
	bool compile_reduction(initial, phost, pnode) More...
static bool	ref_filter (reference r)
static reduction_operator	get_operator (entity e, statement s)
static hpfc_reductions	reduction_of_in (entity e, statement s)
	finally, I can do without replacement: the host keeps and contributes the initial value! More...
list	handle_hpf_reduction (statement s)
	of hpfc_reductions More...
static string	new_reduction_name (reduction_operator op)
	for reduction directive: More...
static entity	make_new_reduction_function (reduction_operator op, bool prolog, bool host, basic base)
	name is {H,N}{PRE,POST}_{SUM,PROD,MIN,...}_{REAL4,INTERGER4,...} More...
static statement	compile_one_reduction (hpfc_reductions red, bool prolog, bool host)
list	compile_hpf_reduction (list lr, bool prolog, bool host)
	of statement More...
void	free_vector_list (list l)
static bool	locally_constant_vector_p (Pvecteur v)
static bool	subarray_shift_assignment_p (call c)
static bool	loop_filter (loop l)
static bool	call_filter (call c)
static bool	cannot_be_a_shift (_UNUSED_ void *x)
bool	subarray_shift_p (statement s, entity *pe, list *plvect)
static entity	make_shift_subroutine (entity var)
	generates the needed subroutine More...
Psysteme	get_read_effect_area (list le, entity var)
list	make_rectangular_area (statement st, entity var)
statement	generate_subarray_shift (statement s, entity var, list lshift)
	statement generate_subarray_shift(s, var, lshift) statement s; entity var; list lshift; More...
void	hpfc_special_cases_error_handler ()
static bool	not_simple (_UNUSED_ void *x)
static bool	check_simple (call c)
statement	simple_statement (statement s)
static loop	find_loop (entity index, list ll)
	bool full_define_p (reference r, list ll) More...
bool	full_define_p (reference r, list ll)
static int	number_of_non_empty_statements (list ls)
bool	full_copy_p (statement s, reference *pleft, reference *pright)
statement	generate_full_copy (reference left, reference right)
	statement generate_full_copy(reference left, reference right) More...

Variables
static t_reduction	all_reductions []
static entity	searched_variable
	hpfc_reductions = initial:entity x replacement:entity x operator:reduction ; reduction = { min , max , sum , prod , and , or } ; More...
static tag	found_operator
static bool	subarray_shift_ok = true
	some static variables used for the detection... More...
static entity	array = entity_undefined
static list	current_regions = NIL
static list	lvect = NIL
static statement	simple_found
	tests whether a loop nest is a full copy loop nest, i.e. More...
static bool	ok

Macro Definition Documentation

expression_complex_p

#define expression_complex_p

(

e

)

(normalized_complex_p(expression_normalized(e)))

bool subarray_shift_p(s, pe, plvect) statement s; entity *pe; list *plvect;

checks whether a loop nest is a subarray shift, that is a parallel loop nest with one assign in the body which is a 1D shift of a locally constant value. returns false if this dimension is not distributed, because the overlap analysis will make a better job. should also check that the accessed subarray is a section. and that it is a block distribution. ??? should also check for a 1 alignment

the entity returned *pe is the shifted array the list returned is the list of the vector shifts for each dimension

Definition at line 379 of file special_cases.c.

MAX_REDUCTION

#define MAX_REDUCTION   1

HPFC module, Fabien Coelho, May 1993.

Definition at line 39 of file special_cases.c.

MIN_REDUCTION

#define MIN_REDUCTION   2

Definition at line 40 of file special_cases.c.

SUM_REDUCTION

#define SUM_REDUCTION   3

Definition at line 41 of file special_cases.c.

XDEBUG

#define XDEBUG

(

msg

)

pips_debug(6, "statement %p: " msg "\n", (void*) s)

bool full_copy_p(statement s, reference * pleft, reference * pright)

what: tells whether a loop nest is a 'full copy' one, that is it fully define an array from another, with perfect alignment. how: pattern matching of what we are looking for... input: the statement output: the bool result, plus both references. side effects:

• uses some static data bugs or features:
• pattern matching done this way is just a hack...

Definition at line 857 of file special_cases.c.

Typedef Documentation

t_reduction

typedef struct t_reduction t_reduction

Function Documentation

call_filter()

static bool call_filter ( call  c )

static

else: private variable assigned in a parallel loop, ok?!

Definition at line 505 of file special_cases.c.

{
    entity e = call_function(c);
 
    pips_debug(9, "function: %s\n", entity_name(e));
 
    if (ENTITY_CONTINUE_P(e)) return false;
    if (ENTITY_ASSIGN_P(e)) 
    {
        if (ref_to_dist_array_p(c))
          subarray_shift_ok = subarray_shift_ok && 
            (entity_undefined_p(array))? subarray_shift_assignment_p(c): false;
        /* else: private variable assigned in a parallel loop, ok?! */
    }
    else
        subarray_shift_ok = false; 
    
    return false;
}

References array, call_function, ENTITY_ASSIGN_P, ENTITY_CONTINUE_P, entity_name, entity_undefined_p, pips_debug, ref_to_dist_array_p(), subarray_shift_assignment_p(), and subarray_shift_ok.

Referenced by subarray_shift_p().

Here is the call graph for this function:

Here is the caller graph for this function:

call_reduction_p()

bool call_reduction_p

(

call

c

)

Definition at line 87 of file special_cases.c.

{
    return hpfc_entity_reduction_p(call_function(c));
}

References call_function, and hpfc_entity_reduction_p().

Referenced by compile_reduction(), and hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

cannot_be_a_shift()

static bool cannot_be_a_shift ( _UNUSED_ void *  x )

static

Definition at line 525 of file special_cases.c.

{
    return subarray_shift_ok = false;
}

References subarray_shift_ok.

Referenced by subarray_shift_p().

Here is the caller graph for this function:

check_simple()

static bool check_simple ( call  c )

static

Definition at line 718 of file special_cases.c.

{
    if (!same_string_p(entity_local_name(call_function(c)),
                       CONTINUE_FUNCTION_NAME))
    {
        if (simple_found) 
        {
            ok = false;
            gen_recurse_stop(NULL);
        }
        else
            simple_found = current_stmt_head();
    }
 
    return false;
}

References call_function, CONTINUE_FUNCTION_NAME, current_stmt_head, entity_local_name(), gen_recurse_stop(), ok, same_string_p, and simple_found.

Referenced by simple_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_hpf_reduction()

list compile_hpf_reduction	(	list	lr,
		bool	prolog,
		bool	host
	)

of statement

of statement

Parameters

lr	of hpfc_reductions
prolog	rolog
host	ost

Definition at line 347 of file special_cases.c.

{
    list /* of statement */ ls = NIL;
    MAP(HPFC_REDUCTIONS, r, 
        ls = CONS(STATEMENT, compile_one_reduction(r, prolog, host), ls),
        lr);
    return ls;
}

References compile_one_reduction(), CONS, HPFC_REDUCTIONS, MAP, NIL, and STATEMENT.

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_one_reduction()

static statement compile_one_reduction ( hpfc_reductions  red, bool  prolog, bool  host  )

static

Definition at line 327 of file special_cases.c.

{
    entity var = hpfc_reductions_initial(red);
 
    return call_to_statement
        (make_call(make_new_reduction_function
            (hpfc_reductions_operator(red), prolog, host, entity_basic(var)),
             CONS(EXPRESSION, entity_to_expression(var), 
             CONS(EXPRESSION, int_to_expression(element_number(
                 variable_basic(type_variable(entity_type(var))),
                 variable_dimensions(type_variable(entity_type(var))))),
                  NIL))));
}

References call_to_statement, CONS, element_number(), entity_basic(), entity_to_expression(), entity_type, EXPRESSION, hpfc_reductions_initial, hpfc_reductions_operator, int_to_expression(), make_call(), make_new_reduction_function(), NIL, type_variable, variable_basic, and variable_dimensions.

Referenced by compile_hpf_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_reduction()

bool compile_reduction	(	statement	initial,
		statement *	phost,
		statement *	pnode
	)

bool compile_reduction(initial, phost, pnode)

true is the compiler succeeded in compiling the reduction that way. ??? many conditions are not yet checked...

Parameters

initial	nitial
phost	host
pnode	node

Definition at line 148 of file special_cases.c.

{
    instruction i = statement_instruction(initial);
    list args = NIL;
    expression ref, cll;
    call reduction;
    t_reduction *red ;
    basic b;
    int dim = 0, arraynum = -1;
    list largs = NIL;
    entity array, hostfunction, nodefunction;
 
    pips_assert("assignment",
                (instruction_call_p(i) && 
                 ENTITY_ASSIGN_P(call_function(instruction_call(i))) &&
                 (gen_length(call_arguments(instruction_call(i)))==2)));
 
    args = call_arguments(instruction_call(i));
    ref  = EXPRESSION(CAR(args));
    cll  = EXPRESSION(CAR(CDR(args)));
 
    pips_assert("reference", (syntax_reference_p(expression_syntax(ref)) &&
            syntax_call_p(expression_syntax(cll))));
 
    reduction = syntax_call(expression_syntax(cll));
    
    pips_debug(7, "call to %s\n", entity_name(call_function(reduction)));
 
    pips_assert("reduction call", call_reduction_p(reduction));
 
    reduction_parameters(reduction, &red, &b, &dim, &array, &largs);
 
    /*
     * the array must be distributed accross the processors, not replicated,
     * and the reference variable mustn't be distributed.
     */
 
    if (!array_distributed_p(array) || 
        (array_distributed_p
         (reference_variable(syntax_reference(expression_syntax(ref))))))
        return(false);
 
    arraynum = load_hpf_number(array);
 
    hostfunction = make_reduction_function("H", dim, red->kind, b, 0);
    nodefunction = make_reduction_function("N", dim, red->kind, b, 4*dim+2);
 
    *phost = make_assign_statement( copy_expression(ref),
                                   make_call_expression(hostfunction, NIL));
    *pnode = 
        make_assign_statement
            ( copy_expression(ref),
             make_call_expression
             (nodefunction,
              CONS(EXPRESSION, entity_to_expression(array),
              CONS(EXPRESSION, int_to_expression(arraynum),
                   gen_nconc(array_lower_upper_bounds_list(array),
                             largs)))));
    
    return(true);
}

References array, array_distributed_p(), array_lower_upper_bounds_list(), call_arguments, call_function, call_reduction_p(), CAR, CDR, CONS, copy_expression(), ENTITY_ASSIGN_P, entity_name, entity_to_expression(), EXPRESSION, expression_syntax, gen_length(), gen_nconc(), instruction_call, instruction_call_p, int_to_expression(), t_reduction::kind, load_hpf_number(), make_assign_statement(), make_call_expression(), make_reduction_function(), NIL, pips_assert, pips_debug, reduction_parameters(), ref, reference_variable, statement_instruction, syntax_call, syntax_call_p, syntax_reference, and syntax_reference_p.

Referenced by hpf_compile_call().

Here is the call graph for this function:

Here is the caller graph for this function:

find_loop()

static loop find_loop ( entity  index, list  ll  )

static

bool full_define_p (reference r, list ll)

what: true if the loop nest ll fully scans r how: not very beautiful. input: r and ll output: the bool result side effects: none bugs or features:

if not found

Parameters

ll

of loops

Definition at line 765 of file special_cases.c.

{
    MAP(LOOP, l, if (loop_index(l)==index) return l, ll);
    return (loop) NULL; /* if not found */
}

References LOOP, loop_index, and MAP.

Referenced by full_define_p().

Here is the caller graph for this function:

find_reduction()

static t_reduction* find_reduction ( const char *  s )

static

static t_reduction *find_reduction(c)

look for the presence of the reduction in the reduction list.

Definition at line 67 of file special_cases.c.

{
     t_reduction *red;
     
     for (red=all_reductions; red->kind; red++)
         if (same_string_p(s, red->name)) return red;
     
     return NULL;
 }

References all_reductions, t_reduction::kind, t_reduction::name, and same_string_p.

Referenced by hpfc_entity_reduction_p(), and reduction_parameters().

Here is the caller graph for this function:

free_vector_list()

void free_vector_list

(

list

l

)

Definition at line 382 of file special_cases.c.

{
    gen_map((gen_iter_func_t)vect_rm, l);
    gen_free_list(l);
}

References gen_free_list(), gen_map(), and vect_rm().

Referenced by generate_subarray_shift(), subarray_shift_assignment_p(), and subarray_shift_p().

Here is the call graph for this function:

Here is the caller graph for this function:

full_copy_p()

bool full_copy_p	(	statement	s,
		reference *	pleft,
		reference *	pright
	)

of lists

of loops

of expressions

the loop nest must be perfect... !!! should check for continues?

the body must be a simple assignment

compatible arities

number of enclosing loops

the lhs should be fully defined by the loop nest... but it does not matter for the rhs!

both lhs and rhs references must be aligned

??? should check the new declarations...

Parameters

pleft	left
pright	right

Definition at line 869 of file special_cases.c.

{
    list /* of lists */ lb = NIL, l,
         /* of loops */ ll = NIL,
         /* of expressions */ la = NIL;
    statement body = parallel_loop_nest_to_body(s, &lb, &ll), simple;
    expression e;
    reference left, right;
    int len;
 
    DEBUG_STAT(6, "considering statement", s);
 
    /* the loop nest must be perfect... !!!
     * should check for continues?
     */
    for (l=lb; l; POP(l)) 
        if (number_of_non_empty_statements(CONSP(CAR(l)))>1) 
            {
                XDEBUG("non perfectly nested");
                gen_free_list(lb), gen_free_list(ll); return false;
            }
 
    gen_free_list(lb), lb = NIL;
 
    /* the body must be a simple assignment
     */
    simple = simple_statement(body);
 
    if (!simple || !instruction_assign_p(statement_instruction(simple)))
    { 
        XDEBUG("body not simple"); gen_free_list(ll); return false;
    }
 
    la = call_arguments(instruction_call(statement_instruction(simple)));
    pips_assert("2 arguments to assign", gen_length(la)==2);
 
    left = expression_reference(EXPRESSION(CAR(la)));
    e = EXPRESSION(CAR(CDR(la)));
 
    if (!expression_reference_p(e))
    {
        XDEBUG("rhs not a reference"); gen_free_list(ll); return false;
    }
 
    right = expression_reference(e);
 
    /* compatible arities 
     */
    len = (int) gen_length(ll); /* number of enclosing loops */
 
    if ((int) gen_length(reference_indices(left))!=len ||
        (int) gen_length(reference_indices(right))!=len)
    {
        XDEBUG("incompatible arities"); gen_free_list(ll); return false;
    }
 
    /* the lhs should be fully defined by the loop nest...
     * but it does not matter for the rhs!
     */
    if (!full_define_p(left, ll))
    {
        XDEBUG("lhs not fully defined"); gen_free_list(ll); return false;
    }
 
    gen_free_list(ll); 
 
    /* both lhs and rhs references must be aligned
     */
    if (!references_aligned_p(left, right))
    {
        XDEBUG("references not aligned"); return false;
    }
 
    /* ??? should check the new declarations...
     */
 
    XDEBUG("ok");
    *pleft = left;
    *pright = right;
    return true;
}

References call_arguments, CAR, CDR, CONSP, DEBUG_STAT, EXPRESSION, expression_reference(), expression_reference_p(), full_define_p(), gen_free_list(), gen_length(), instruction_assign_p(), instruction_call, int, NIL, number_of_non_empty_statements(), parallel_loop_nest_to_body(), pips_assert, POP, reference_indices, references_aligned_p(), simple, simple_statement(), statement_instruction, and XDEBUG.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

full_define_p()

bool full_define_p	(	reference	r,
		list	ll
	)

of expression

of dimension

of entity

checks that the indices are simply the loop indexes, and that the whole dimension is scanned. Also avoids (i,i)...

checks that the loop range scans the whole dimension

increment must be 1. lowers and uppers must be equal.

Parameters

ll

of loops

Definition at line 771 of file special_cases.c.

{
    entity array = reference_variable(r);
    list /* of expression */ li = reference_indices(r),
         /* of dimension */ ld,
         /* of entity */ lseen = NIL;
    int ndim;
    
    pips_assert("variable", entity_variable_p(array));
 
    ld = variable_dimensions(type_variable(entity_type(array)));
    pips_assert("same arity", gen_length(ll)==gen_length(ld));
 
    /* checks that the indices are *simply* the loop indexes,
     * and that the whole dimension is scanned. Also avoids (i,i)...
     */
    for(ndim=1; li; POP(li), POP(ld), ndim++)
    {
        syntax s = expression_syntax(EXPRESSION(CAR(li)));
        entity index;
        dimension dim;
        range rg;
        loop l;
        expression inc;
 
        if (!syntax_reference_p(s)) 
        {
            gen_free_list(lseen);
            return false;
        }
 
        index = reference_variable(syntax_reference(s));
 
        if (gen_in_list_p(index, lseen))
        {
            gen_free_list(lseen);
            return false;
        }
 
        lseen = CONS(ENTITY, index, lseen);
 
        l = find_loop(index, ll);
        
        if (!l) 
        {
            gen_free_list(lseen);
            return false;
        }
 
        /* checks that the loop range scans the whole dimension */
 
        rg = loop_range(l);
        inc = range_increment(rg);
        dim = DIMENSION(CAR(ld));
        
        /* increment must be 1.
         * lowers and uppers must be equal.
         */
        if (!integer_constant_expression_p(inc) ||
            integer_constant_expression_value(inc)!=1 ||
            !same_expression_p(range_lower(rg), dimension_lower(dim)) ||
            !same_expression_p(range_upper(rg), dimension_upper(dim)))
        {
            pips_debug(9, "incomplete scan of %s[dim=%d]\n", 
                       entity_name(array), ndim);
            gen_free_list(lseen);
            return false;
        }
    }
 
    gen_free_list(lseen);
    return true;
}

References array, CAR, CONS, DIMENSION, dimension_lower, dimension_upper, ENTITY, entity_name, entity_type, entity_variable_p, EXPRESSION, expression_syntax, find_loop(), gen_free_list(), gen_in_list_p(), gen_length(), integer_constant_expression_p(), integer_constant_expression_value(), loop_range, NIL, pips_assert, pips_debug, POP, range_increment, range_lower, range_upper, reference_indices, reference_variable, same_expression_p(), syntax_reference, syntax_reference_p, type_variable, and variable_dimensions.

Referenced by full_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_full_copy()

statement generate_full_copy	(	reference	left,
		reference	right
	)

statement generate_full_copy(reference left, reference right)

what: copies directly right into left, that must conform... how: direct loop nest on local data input: both entities output: the returned statement side effects: bugs or features:

• assumes that the references are ok, that is they come from a full_copy_p execution.
• code generated based on the original entities. thus the code cleaning pass is trusted.

of entity

of dimension

indexes are reused. bounds are taken from the node entity declaration.

Parameters

left	eft
right	ight

Definition at line 964 of file special_cases.c.

{
    statement body;
    int ndim, i;
    list /* of entity */ lindexes, l,
         /* of dimension */ ld;
    entity array = reference_variable(left), 
           new_array = load_new_node(array);
 
    ndim = gen_length(variable_dimensions(type_variable(entity_type(array))));
 
    body = make_assign_statement(reference_to_expression(copy_reference(left)),
                              reference_to_expression(copy_reference(right)));
    
    /* indexes are reused. bounds are taken from the node entity declaration.
     */
    lindexes = expressions_to_entities(reference_indices(left));
    ld = variable_dimensions(type_variable(entity_type(new_array)));
 
    for(i=1, l=lindexes; i<=ndim; i++, POP(lindexes), POP(ld))
    {
        dimension d = DIMENSION(CAR(ld));
 
        body = loop_to_statement(make_loop
           (ENTITY(CAR(lindexes)),
            make_range(copy_expression(dimension_lower(d)),
                       copy_expression(dimension_upper(d)),
                       int_to_expression(1)),
            body,
            entity_empty_label(),
            make_execution(is_execution_sequential, UU),
            NIL));
    }
 
    gen_free_list(l);
    return body;    
}

References array, CAR, copy_expression(), copy_reference(), DIMENSION, dimension_lower, dimension_upper, ENTITY, entity_empty_label(), entity_type, expressions_to_entities(), gen_free_list(), gen_length(), int_to_expression(), is_execution_sequential, load_new_node(), loop_to_statement, make_assign_statement(), make_execution(), make_loop(), make_range(), NIL, POP, reference_indices, reference_to_expression(), reference_variable, type_variable, UU, and variable_dimensions.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_subarray_shift()

statement generate_subarray_shift	(	statement	s,
		entity	var,
		list	lshift
	)

statement generate_subarray_shift(s, var, lshift) statement s; entity var; list lshift;

generates a call to the runtime library shift subroutine for the given array, the given shift and the corresponding region in statement s. this function assumes that subarray_shift_p was true on s, and does not checks the conditions again.

gets the shifted dimension and the shift

all the arguments

Parameters

var	ar
lshift	shift

Definition at line 643 of file special_cases.c.

{
    entity subroutine = make_shift_subroutine(var);
    int array_number = load_hpf_number(array), shifted_dim = 0;
    expression shift = expression_undefined;
    list ldecl = array_lower_upper_bounds_list(array), largs;
    Pvecteur v;
 
    /*  gets the shifted dimension and the shift
     */
    MAPL(cv,
     {
         v = (Pvecteur) PVECTOR(CAR(cv));
         shifted_dim++;
 
         if (!vecteur_nul_p(v)) 
         {
             shift = make_vecteur_expression(v);
             break;
         }
     },
         lshift);
 
    pips_assert("shift defined", shift!=expression_undefined);
    free_vector_list(lshift);
    
    /*  all the arguments
     */
    largs = 
        CONS(EXPRESSION, entity_to_expression(array),
        CONS(EXPRESSION, int_to_expression(array_number),
        CONS(EXPRESSION, int_to_expression(shifted_dim),
        CONS(EXPRESSION, shift,
             gen_nconc(ldecl, make_rectangular_area(s, var))))));
 
    return hpfc_make_call_statement(subroutine, largs);
}

References array, array_lower_upper_bounds_list(), CAR, CONS, entity_to_expression(), EXPRESSION, expression_undefined, free_vector_list(), gen_nconc(), hpfc_make_call_statement(), int_to_expression(), load_hpf_number(), make_rectangular_area(), make_shift_subroutine(), make_vecteur_expression(), MAPL, pips_assert, PVECTOR, and vecteur_nul_p().

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

get_operator()

static reduction_operator get_operator ( entity  e, statement  s  )

static

Definition at line 248 of file special_cases.c.

{
    make_current_call_stack();
    found_operator = tag_undefined;
    searched_variable = e;
    gen_multi_recurse(s,
                      call_domain, current_call_filter, current_call_rewrite,
                      reference_domain, ref_filter, gen_null,
                      NULL);
    free_current_call_stack();
 
    pips_assert("some operator found", found_operator!=tag_undefined);
    return make_reduction_operator(found_operator, UU);
}

References call_domain, found_operator, gen_multi_recurse(), gen_null(), make_reduction_operator(), pips_assert, ref_filter(), reference_domain, searched_variable, tag_undefined, and UU.

Referenced by reduction_of_in().

Here is the call graph for this function:

Here is the caller graph for this function:

get_read_effect_area()

Psysteme get_read_effect_area	(	list	le,
		entity	var
	)

Parameters

le	e
var	ar

Definition at line 584 of file special_cases.c.

{
    MAP(EFFECT, e,
     {
         if (action_read_p(effect_action(e)) &&
             reference_variable(effect_any_reference(e))==var)
             return effect_system(e);
     },
         le);
 
    return SC_UNDEFINED;
}

References action_read_p, EFFECT, effect_action, effect_any_reference, effect_system, MAP, and reference_variable.

Referenced by make_rectangular_area().

Here is the caller graph for this function:

handle_hpf_reduction()

list handle_hpf_reduction

(

statement

s

)

of hpfc_reductions

of hpfc_reductions

Definition at line 274 of file special_cases.c.

{
    list /* of hpfc_reductions */ lr = NIL;
 
    MAP(ENTITY, e, 
        lr = CONS(HPFC_REDUCTIONS, reduction_of_in(e, s), lr),
        entities_list(load_hpf_reductions(s)));
 
    return lr;
}

References CONS, entities_list, ENTITY, HPFC_REDUCTIONS, load_hpf_reductions(), MAP, NIL, and reduction_of_in().

Referenced by hpf_compiler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_entity_reduction_p()

bool hpfc_entity_reduction_p

(

entity

e

)

bool call_reduction_p(c)

special_cases.c

true if a given call is a call to reduction function. ??? a generic function name should be managed here?

Definition at line 82 of file special_cases.c.

{
    return find_reduction(module_local_name(e)) != NULL;
}

References find_reduction(), and module_local_name().

Referenced by call_reduction_p(), hpfc_compile(), and hpfc_directives_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_special_cases_error_handler()

void hpfc_special_cases_error_handler

(

void

)

Definition at line 705 of file special_cases.c.

{
    error_reset_current_stmt_stack();
    error_reset_current_call_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

locally_constant_vector_p()

static bool locally_constant_vector_p ( Pvecteur  v )

static

Definition at line 395 of file special_cases.c.

{
    for(; v!=NULL; v=v->succ)
        if (var_of(v)!=TCST && written_effect_p((entity) var_of(v), 
                                                current_regions))
            return false;
 
    return true;
}

References current_regions, Svecteur::succ, TCST, var_of, and written_effect_p().

Referenced by subarray_shift_assignment_p().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_filter()

static bool loop_filter ( loop  l )

static

Definition at line 499 of file special_cases.c.

{
    int stride = HpfcExpressionToInt(range_increment(loop_range(l)));
    return subarray_shift_ok = subarray_shift_ok && (stride==1 || stride==-1);
}

References HpfcExpressionToInt(), loop_range, range_increment, and subarray_shift_ok.

Referenced by subarray_shift_p().

Here is the call graph for this function:

Here is the caller graph for this function:

make_new_reduction_function()

static entity make_new_reduction_function ( reduction_operator  op, bool  prolog, bool  host, basic  base  )

static

name is {H,N}{PRE,POST}_{SUM,PROD,MIN,...}_{REAL4,INTERGER4,...}

Definition at line 311 of file special_cases.c.

{
    char buffer[100];
 
    (void) sprintf(buffer, "%s", concatenate
             (host? "H": "N", prolog? "PRE": "POST", " ",
              new_reduction_name(op), " ", pvm_what_options(base), NULL));
 
    return MakeRunTimeSupportSubroutine(buffer, 1);
}

References base, buffer, concatenate(), MakeRunTimeSupportSubroutine(), new_reduction_name(), and pvm_what_options().

Referenced by compile_one_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

make_rectangular_area()

list make_rectangular_area	(	statement	st,
		entity	var
	)

Parameters

st	t
var	ar

Definition at line 597 of file special_cases.c.

{
    list l = NIL;
    Psysteme
        s = sc_dup(get_read_effect_area(load_statement_local_regions(st),
                                         var));
    Pcontrainte c, lower = CONTRAINTE_UNDEFINED, upper = CONTRAINTE_UNDEFINED;
    Variable idx;
    entity div = hpfc_name_to_entity(IDIVIDE);
    int dim = gen_length(variable_dimensions(type_variable(entity_type(var))));
 
    sc_transform_eg_in_ineg(s);
    c = sc_inegalites(s);
    sc_inegalites(s) = (Pcontrainte)NULL, 
    sc_rm(s);
 
    for(; dim>0; dim--)
    {
        idx = (Variable) get_ith_region_dummy(dim);
 
        constraints_for_bounds(idx, &c, &lower, &upper);
 
        l = CONS(EXPRESSION, constraints_to_loop_bound(lower, idx, true, div),
            CONS(EXPRESSION, constraints_to_loop_bound(upper, idx, false, div),
                 l));
 
        (void) contraintes_free(lower), lower=NULL;
        (void) contraintes_free(upper), upper=NULL;
    }
 
    (void) contraintes_free(c);
    
    return l;
}

References CONS, constraints_for_bounds(), constraints_to_loop_bound(), CONTRAINTE_UNDEFINED, contraintes_free(), entity_type, EXPRESSION, gen_length(), get_ith_region_dummy(), get_read_effect_area(), hpfc_name_to_entity(), IDIVIDE, load_statement_local_regions(), NIL, sc_dup(), sc_rm(), sc_transform_eg_in_ineg(), type_variable, and variable_dimensions.

Referenced by generate_subarray_shift().

Here is the call graph for this function:

Here is the caller graph for this function:

make_reduction_function()

static entity make_reduction_function ( string  prefix, int  ndim, int  kind, basic  base, int  nargs  )

static

find or create an entity for the reduction function...

Definition at line 128 of file special_cases.c.

{
    char buffer[100];
 
    (void) sprintf(buffer, "%sRED %d %s %s",
                   prefix, ndim, pvm_what_options(base), reduction_name(kind));
 
    return MakeRunTimeSupportFunction(buffer, nargs, basic_tag(base));
}

References base, basic_tag, buffer, MakeRunTimeSupportFunction(), prefix, pvm_what_options(), and reduction_name().

Referenced by compile_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

make_shift_subroutine()

static entity make_shift_subroutine ( entity  var )

static

generates the needed subroutine

Definition at line 565 of file special_cases.c.

{
    char buffer[100];
    type t;
    variable v;
    int ndim;
    
    pips_assert("defined", !entity_undefined_p(var)); t = entity_type(var);
    pips_assert("variable", type_variable_p(t)); v = type_variable(t);
 
    ndim = gen_length(variable_dimensions(v));
 
    (void) sprintf(buffer, "%s SHIFT %d",
                   pvm_what_options(variable_basic(v)),
                   ndim);
 
    return MakeRunTimeSupportSubroutine(buffer, ndim*4+4);
}

References buffer, entity_type, entity_undefined_p, gen_length(), MakeRunTimeSupportSubroutine(), pips_assert, pvm_what_options(), type_variable, type_variable_p, variable_basic, and variable_dimensions.

Referenced by generate_subarray_shift().

Here is the call graph for this function:

Here is the caller graph for this function:

new_reduction_name()

static string new_reduction_name ( reduction_operator  op )

static

for reduction directive:

Definition at line 287 of file special_cases.c.

{
    if (reduction_operator_sum_p(op)) 
        return "SUM";
    else if (reduction_operator_prod_p(op))
        return "PROD";
    else if (reduction_operator_min_p(op))
        return "MIN";
    else if (reduction_operator_max_p(op))
        return "MAX";
    else if (reduction_operator_and_p(op))
        return "AND";
    else if (reduction_operator_or_p(op))
        return "OR";
    else
        pips_internal_error("unexpected reduction_operator tag (%d)",
                            reduction_operator_tag(op));
 
    return "unknown";
}

References pips_internal_error, reduction_operator_and_p, reduction_operator_max_p, reduction_operator_min_p, reduction_operator_or_p, reduction_operator_prod_p, reduction_operator_sum_p, and reduction_operator_tag.

Referenced by make_new_reduction_function().

Here is the caller graph for this function:

not_simple()

static bool not_simple ( _UNUSED_ void *  x )

static

Definition at line 711 of file special_cases.c.

{
    ok = false;
    gen_recurse_stop(NULL);
    return false;
}

References gen_recurse_stop(), and ok.

Referenced by simple_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

number_of_non_empty_statements()

static int number_of_non_empty_statements ( list  ls )

static

Parameters

ls	of statement

Definition at line 861 of file special_cases.c.

{
    int n = 0;
    MAP(STATEMENT, s, if (!empty_code_p(s)) n++, ls);
    return n;
}

References empty_code_p(), MAP, and STATEMENT.

Referenced by full_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_name()

static char* reduction_name ( int  kind )

static

Definition at line 117 of file special_cases.c.

{
    static char *reduction_names[] = {"MAX", "MIN", "SUM"};
    pips_assert("valid kind", kind>=0 && kind<3);
    return(reduction_names[kind-1]);
}

References pips_assert.

Referenced by make_reduction_function(), and translate_reduction().

Here is the caller graph for this function:

reduction_of_in()

static hpfc_reductions reduction_of_in ( entity  e, statement  s  )

static

finally, I can do without replacement: the host keeps and contributes the initial value!

Definition at line 266 of file special_cases.c.

{
    pips_debug(5, "considering %s in %p\n", entity_name(e), s);
 
    return make_hpfc_reductions(e, entity_undefined, get_operator(e, s));
}

References entity_name, entity_undefined, get_operator(), make_hpfc_reductions(), and pips_debug.

Referenced by handle_hpf_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

reduction_parameters()

static void reduction_parameters ( call  c, t_reduction **  pred, basic *  pb, int *  pdim, entity *  pe, list *  pl  )

static

Definition at line 97 of file special_cases.c.

{
    expression
        arg = EXPRESSION(CAR(call_arguments(c)));
 
    pips_assert("reference", syntax_reference_p(expression_syntax(arg)));
 
    *pe   = reference_variable(syntax_reference(expression_syntax(arg)));
    *pl   = CDR(call_arguments(c));
    *pdim = NumberOfDimension(*pe);
    *pred = find_reduction(module_local_name(call_function(c)));
    *pb   = entity_basic(*pe);
}

References call_arguments, call_function, CAR, CDR, entity_basic(), EXPRESSION, expression_syntax, find_reduction(), module_local_name(), NumberOfDimension(), pips_assert, pl, reference_variable, syntax_reference, and syntax_reference_p.

Referenced by compile_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

ref_filter()

static bool ref_filter ( reference  r )

static

get the call just above – well, what about intermediate casts ???

Definition at line 223 of file special_cases.c.

{
    entity fun;
 
    if (searched_variable!=reference_variable(r)) return false;
 
    /* get the call just above -- well, what about intermediate casts ??? */
    fun = call_function(current_call_head()); 
 
    if (ENTITY_PLUS_P(fun)||ENTITY_MINUS_P(fun)) 
        found_operator=is_reduction_operator_sum;
    else if (ENTITY_MULTIPLY_P(fun)) 
        found_operator=is_reduction_operator_prod;
    else if (ENTITY_MIN_P(fun)||ENTITY_MIN0_P(fun))
        found_operator=is_reduction_operator_min;
    else if (ENTITY_MAX_P(fun)||ENTITY_MAX0_P(fun))
        found_operator=is_reduction_operator_max;
    else if (ENTITY_AND_P(fun))
        found_operator=is_reduction_operator_and;
    else if (ENTITY_OR_P(fun))
        found_operator=is_reduction_operator_or;
 
    return false;
}

References call_function, ENTITY_AND_P, ENTITY_MAX0_P, ENTITY_MAX_P, ENTITY_MIN0_P, ENTITY_MIN_P, ENTITY_MINUS_P, ENTITY_MULTIPLY_P, ENTITY_OR_P, ENTITY_PLUS_P, found_operator, is_reduction_operator_and, is_reduction_operator_max, is_reduction_operator_min, is_reduction_operator_or, is_reduction_operator_prod, is_reduction_operator_sum, reference_variable, and searched_variable.

Referenced by get_operator().

Here is the caller graph for this function:

simple_statement()

statement simple_statement

(

statement

s

)

Definition at line 735 of file special_cases.c.

{
    ok = true;
    simple_found = (statement) NULL;
    make_current_stmt_stack();
 
    gen_multi_recurse
        (s,
         statement_domain,  current_stmt_filter, current_stmt_rewrite,
         test_domain,       not_simple,          gen_null,
         loop_domain,       not_simple,          gen_null,
         call_domain,       check_simple,        gen_null,
         expression_domain, gen_false,           gen_null,
         NULL);
 
    free_current_stmt_stack();
 
    return (ok && simple_found) ? simple_found : NULL;
}

References call_domain, check_simple(), expression_domain, gen_false(), gen_multi_recurse(), gen_null(), loop_domain, not_simple(), ok, simple_found, statement_domain, and test_domain.

Referenced by full_copy_p().

Here is the call graph for this function:

Here is the caller graph for this function:

subarray_shift_assignment_p()

static bool subarray_shift_assignment_p ( call  c )

static

LHS must be a reference

is RHS a reference?

same array, and a block-distributed one ?

compute the difference of every indices, if possible.

else compute the difference

now checks for a constant shift on a distributed dimension and that's all. ??? I could deal with other constant shifts on non distributed dims

else the vector is not null

Definition at line 405 of file special_cases.c.

{
    list lhs_ind, rhs_ind, args = call_arguments(c);
    expression
        lhs = EXPRESSION(CAR(args)),
        rhs = EXPRESSION(CAR(CDR(args)));
    reference lhs_ref, rhs_ref;
    bool shift_was_seen = false;
    int dim;
 
    /*  LHS *must* be a reference
     */ 
    pips_assert("reference", expression_reference_p(lhs));
 
    /* is RHS a reference?
     */
    if (!expression_reference_p(rhs)) return false;
 
    lhs_ref = syntax_reference(expression_syntax(lhs)),
    rhs_ref = syntax_reference(expression_syntax(rhs));
    array = reference_variable(lhs_ref);
 
    /*  same array, and a block-distributed one ?
     */
    if (array!=reference_variable(rhs_ref) ||
        !array_distributed_p(array) || 
        !block_distributed_p(array))
        return false;
    
    lhs_ind = reference_indices(lhs_ref),
    rhs_ind = reference_indices(rhs_ref);
    
    pips_assert("same arity", gen_length(lhs_ind)==gen_length(rhs_ind));
 
    /*  compute the difference of every indices, if possible.
     */
    for(;
        !ENDP(lhs_ind);
        lhs_ind=CDR(lhs_ind), rhs_ind=CDR(rhs_ind))
    {
        expression
            il = EXPRESSION(CAR(lhs_ind)),
            ir = EXPRESSION(CAR(rhs_ind));
 
        if (expression_complex_p(il) || expression_complex_p(ir))
        {
            free_vector_list(lvect), lvect = NIL;
            return false;
        }
 
        /* else compute the difference */
        lvect = 
            CONS(PVECTOR, (VECTOR)
                 vect_substract(normalized_linear(expression_normalized(il)),
                                normalized_linear(expression_normalized(ir))),
                 lvect);
    }
 
    lvect = gen_nreverse(lvect);
 
    /* now checks for a constant shift on a distributed dimension
     * and that's all.
     * ??? I could deal with other constant shifts on non distributed dims
     */
    dim = 0;
    MAPL(cv,
     {
         Pvecteur v = (Pvecteur) PVECTOR(CAR(cv));
         int p;
 
         dim++;
 
         if (vecteur_nul_p(v)) continue;
 
         /* else the vector is not null
          */
         if (shift_was_seen || 
             !ith_dim_distributed_p(array, dim, &p) ||
             !locally_constant_vector_p(v))
         {
             pips_debug(7, "false on array %s, dimension %d\n",
                        entity_local_name(array), dim);
             free_vector_list(lvect);
             lvect = NIL;
             return false;
         }
 
         shift_was_seen = true;
     },
         lvect);
 
    return true;
}

References array, array_distributed_p(), block_distributed_p(), call_arguments, CAR, CDR, CONS, ENDP, entity_local_name(), EXPRESSION, expression_complex_p, expression_normalized, expression_reference_p(), expression_syntax, free_vector_list(), gen_length(), gen_nreverse(), ith_dim_distributed_p(), locally_constant_vector_p(), lvect, MAPL, NIL, normalized_linear, pips_assert, pips_debug, PVECTOR, reference_indices, reference_variable, syntax_reference, vect_substract(), vecteur_nul_p(), and VECTOR.

Referenced by call_filter().

Here is the call graph for this function:

Here is the caller graph for this function:

subarray_shift_p()

bool subarray_shift_p	(	statement	s,
		entity *	pe,
		list *	plvect
	)

Parameters

pe	e
plvect	lvect

Definition at line 530 of file special_cases.c.

{
    array = entity_undefined;
    subarray_shift_ok = true;
    lvect = NIL;
    current_regions = load_statement_local_regions(s);
 
    DEBUG_STAT(8, "considering statement", s);
 
    gen_multi_recurse(s,
                      call_domain, call_filter, gen_null,
                      loop_domain, loop_filter, gen_null,
                      test_domain, cannot_be_a_shift, gen_null,
                      expression_domain, gen_false, gen_null,
                      NULL);
 
    subarray_shift_ok &= !entity_undefined_p(array) &&
        rectangular_must_region_p(array, s);
 
    if (subarray_shift_ok)
        *pe = array,
        *plvect = lvect;
    else
        free_vector_list(lvect), lvect = NIL;
    current_regions = NIL;
 
    pips_debug(8, "returning %s\n", subarray_shift_ok? "TRUE": "FALSE");
    return subarray_shift_ok;
}

References array, call_domain, call_filter(), cannot_be_a_shift(), current_regions, DEBUG_STAT, entity_undefined, entity_undefined_p, expression_domain, free_vector_list(), gen_false(), gen_multi_recurse(), gen_null(), load_statement_local_regions(), loop_domain, loop_filter(), lvect, NIL, pips_debug, rectangular_must_region_p(), subarray_shift_ok, and test_domain.

Referenced by hpf_compile_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

all_reductions

t_reduction all_reductions[]

static

Initial value:

=
{
  {"REDMIN",  MIN_REDUCTION, -1},
  {"REDMIN1", MIN_REDUCTION, 1},
  {"REDMIN2", MIN_REDUCTION, 2},
  {"REDMIN3", MIN_REDUCTION, 3},
  {"REDMAX",  MAX_REDUCTION, -1},
  {"REDMAX1", MAX_REDUCTION, 1},
  {"REDMAX2", MAX_REDUCTION, 2},
  {"REDMAX3", MAX_REDUCTION, 3},
  {0,         0,             0}
}

Definition at line 50 of file special_cases.c.

Referenced by find_reduction().

array

entity array = entity_undefined

static

Definition at line 392 of file special_cases.c.

Referenced by add_declaration_to_host_and_link(), add_one_bound_argument(), alive_arrays(), argument_bound_entity(), array_access_to_array_ranges(), array_as_template(), array_bounds_list(), array_lower_upper_bounds_list(), array_must_fully_written_by_regions_p(), array_ranges_to_template_ranges(), array_synonym_aligned_as(), atomize_one_message(), block_distributed_p(), bound_parameter_name(), buffer_full_condition(), build_call_STEP_AllToAll(), build_call_STEP_init_regionArray(), call_filter(), clean_distributed_io_system(), clean_shared_io_system(), compile_reduction(), complementary_range(), compute_receive_content(), ComputeNewSizeOfIthDimension(), continue_propagation_p(), create_bound_entity(), create_init_common_param_for_arrays(), create_parameters_h(), deal_with_similars(), dims_array_init(), DistributionParameterOfArrayDim(), entity_to_new_declaration(), eov_add_entity_to_eliminate(), eov_get_replaced_enity(), expr_compute_local_index(), extract_the_align(), full_define_p(), generate_all_liveness_but(), generate_call_set_regionarray(), generate_call_stepalltoall(), generate_compute_local_indices(), generate_distributed_io_system(), generate_dynamic_liveness_for_primary(), generate_dynamic_liveness_management(), generate_full_copy(), generate_get_value_locally(), generate_io_collect_or_update(), generate_io_statements_for_shared_arrays(), generate_io_system(), generate_message_from_3_lists(), generate_one_message(), generate_optimized_code_for_loop_nest(), generate_receive_from_computer(), generate_send_to_computer(), generate_shared_io_system(), generate_subarray_shift(), generate_update_distributed_value_from_host(), generate_update_values_on_computer_and_nodes(), generate_update_values_on_nodes(), GENERATION(), get_alignment(), get_help_topic(), get_help_topics(), get_ith_dim_new_declaration(), global_array_cell_to_local_array_cell(), handle_prescriptive_directive(), hpfc_array_bound(), hpfc_broadcast_if_necessary(), hpfc_buffer_entity(), hpfc_buffer_packing(), hpfc_buffer_reference(), hpfc_check_for_similarities(), hpfc_compute_entity_to_new_declaration(), hpfc_compute_lid(), hpfc_hcast(), hpfc_hmessage(), hpfc_init_dummy_to_prime(), hpfc_lazy_buffer_packing(), hpfc_lazy_packing(), hpfc_nrecv(), hpfc_nsend(), hpfc_packing_of_current__buffer(), hpfc_unstutter_dummies(), initial_alignment(), io_efficient_compile(), ith_dim_distributed_p(), ith_dim_overlapable_p(), loop_nest_guard(), mchoose(), message_manageable_p(), messages_generation(), new_declaration_tag(), NewDeclarationOfDistributedArray(), NewDeclarationsOfDistributedArrays(), one_align_directive(), one_distribute_directive(), one_message_guards_and_neighbour(), one_receive_message(), Overlap_Analysis(), partial_linearization(), pips_get_fortran_list(), pips_get_workspace_list(), processor_loop(), put_variables_in_ordered_lists(), region_reduction_p(), region_to_statement(), remapping_file_name(), remove_from_entities(), remove_not_remapped_leavings(), root_statement_remapping_inits(), safe_static_domain_bound(), schoose(), set_array_dimension_checked(), set_similar_mappings_for_updates(), shape_one_message(), simple_indices_p(), st_compute_ith_local_index(), st_generate_packing(), st_one_message(), st_send_to_computer_if_necessary(), step_local_regionArray(), store_a_new_declaration(), string_array_join(), subarray_shift_assignment_p(), subarray_shift_p(), template_cell_local_mapping(), template_dimension_of_array_dimension(), top_down_abc_array(), top_down_abc_call(), top_down_abc_dimension(), top_down_abc_flt(), top_down_abc_not_exact_case(), and update_indices_for_local_computation().

current_regions

list current_regions = NIL

static

Definition at line 393 of file special_cases.c.

Referenced by locally_constant_vector_p(), and subarray_shift_p().

found_operator

tag found_operator

static

Definition at line 221 of file special_cases.c.

Referenced by get_operator(), and ref_filter().

lvect

list lvect = NIL

static

Definition at line 393 of file special_cases.c.

Referenced by constraint_to_bound(), Overlap_Analysis(), subarray_shift_assignment_p(), subarray_shift_p(), and system_new_var_subst().

ok

bool ok

static

Definition at line 702 of file special_cases.c.

Referenced by adg_suppress_2nd_in_1st_ps(), align_check(), capply(), check_C_function_type(), check_call_mode_consistency(), check_call_types_compatibility(), check_common_inclusion(), check_simple(), check_the_reference(), compact_phi_functions(), comparable_entity_in_list_p(), control_type_in_expression(), cool_enough_for_a_last_substitution(), db_create_workspace(), db_module_exists_p(), db_open_workspace(), db_set_current_module_name(), do_array_expansion(), find_bd_reference(), handle_file_name(), handle_include_file(), internal_sc_feasibility(), load_meta_data(), main(), make_text_resource_and_free(), MakeFortranType(), normalizable_loop_p_retrieved(), not_simple(), number_of_elements(), number_of_items(), NumberOfElements(), partial_eval_min_or_max_operator(), pips_process_file(), print_initial_precondition(), print_points_to_graph(), print_program_precondition(), safe_concurrent_apply(), sc_feasibility_ofl_ctrl(), sc_fourier_motzkin_feasibility_ofl_ctrl_timeout_ctrl(), sc_janus_feasibility(), sc_janus_feasibility_ofl_ctrl_timeout_ctrl(), sc_simplexe_feasibility_ofl_ctrl_timeout_ctrl(), signed_constant_expression_p(), simple_statement(), SizeOfArray(), subscripted_field_list_to_type(), suppress_sc_in_sc(), terapix_gram_allocate(), test_run_time_communications(), TestDependence(), and ValueSizeOfDimension().

searched_variable

entity searched_variable

static

hpfc_reductions = initial:entity x replacement:entity x operator:reduction ; reduction = { min , max , sum , prod , and , or } ;

looking for the reduction operator is a basic recursion. no check.

Definition at line 220 of file special_cases.c.

Referenced by get_operator(), and ref_filter().

simple_found

statement simple_found

static

tests whether a loop nest is a full copy loop nest, i.e.

it copies an array into another, both being aligned. ??? it should share some code with the subarray shift detection... ??? another quick hack for testing purposes (remappings). statement simple_statement(statement s)

what: tells whether s is (after simplification) a simple statement, i.e. a call, and returns it (may be hidden by blocks and continues). how: recursion thru the IR. input: statement s output: returned statement, or NULL if not simple... side effects:

• uses some static data bugs or features:

Definition at line 701 of file special_cases.c.

Referenced by check_simple(), and simple_statement().

subarray_shift_ok

bool subarray_shift_ok = true

static

some static variables used for the detection...

Definition at line 391 of file special_cases.c.

Referenced by call_filter(), cannot_be_a_shift(), loop_filter(), and subarray_shift_p().