compiler-util.c File Reference

#include "defines-local.h"

Include dependency graph for compiler-util.c:

Go to the source code of this file.

Macros
#define	call_assign_p(c)    (strcmp(entity_local_name(call_function(c)), ASSIGN_OPERATOR_NAME)==0)

Functions
void	update_control_lists (control c, control_mapping map)
	Compiler Utilities. More...
list	updated_control_list (list lc, control_mapping map)
static bool	FindRefToDistArrayInStatement_call_filter (call c)
static bool	FindRefToDistArrayInStatement_expression_filter (expression e)
void	FindRefToDistArrayInStatement (statement obj, list *lwp, list *lrp)
list	lIndicesOfRef (list lsyn)
	computes the list of indices of the list of ref that are variables... More...
list	IndicesOfRef (syntax syn)
list	AddOnceToIndicesList (list l, list lsyn)
bool	is_in_syntax_list (entity e, list l)
static void	FindDefinitionsOf_rewrite (statement s)
list	FindDefinitionsOf (statement stat, list lsyn)
bool	atomic_accesses_only_p (_UNUSED_ statement stat)
	atomic_accesses_only_p More...
bool	indirections_inside_statement_p (_UNUSED_ statement stat)
	indirections_inside_statement_p More...
static bool	loop_filter (loop l)
static void	sequence_rewrite (sequence s)
static void	loop_rewrite (loop l)
statement	parallel_loop_nest_to_body (statement loop_nest, list *pblocks, list *ploops)
static void	set_current_loops_rewrite (loop l)
void	set_current_loops (statement obj)
void	reset_current_loops ()
bool	entity_loop_index_p (entity e)
range	loop_index_to_range (entity index)

Variables
static list	found_written = NIL
	FindRefToDistArrayInStatement. More...
static list	found_read = NIL
static list	syntax_list =NIL
	??? False! The definition looked for must be an assignment call... More...
static list	found_definitions =NIL
static list	loops
static list	blocks
	lisp of loops More...
static int	n_loops
	list of lists, may be NIL if none More...
static int	n_levels
static statement	inner_body
static list	current_loop_list =NIL
	management of a list of current loops. More...

Macro Definition Documentation

call_assign_p

#define call_assign_p

(

c

)

(strcmp(entity_local_name(call_function(c)), ASSIGN_OPERATOR_NAME)==0)

Definition at line 87 of file compiler-util.c.

Function Documentation

AddOnceToIndicesList()

list AddOnceToIndicesList	(	list	l,
		list	lsyn
	)

Parameters

lsyn

syn

Definition at line 188 of file compiler-util.c.

{
    MAP(SYNTAX, s,
        if (!is_in_syntax_list(reference_variable(syntax_reference(s)), lsyn))
             lsyn = CONS(SYNTAX, s, lsyn),
        l);
 
    gen_free_list(l);
    return(lsyn);
}

References CONS, gen_free_list(), is_in_syntax_list(), MAP, reference_variable, SYNTAX, and syntax_reference.

Referenced by hpf_compile_parallel_body(), and lIndicesOfRef().

Here is the call graph for this function:

Here is the caller graph for this function:

atomic_accesses_only_p()

bool atomic_accesses_only_p

(

_UNUSED_ statement

stat

)

atomic_accesses_only_p

checks that only atomic accesses to distributed variables are made inside a parallel loop nest, for every iterations.

??? partially implemented, and the conclusions may be false...

Definition at line 268 of file compiler-util.c.

{
  ifdebug(1)
    hpfc_warning("not  implemented, returning TRUE\n");
  return true;
}

References hpfc_warning, and ifdebug.

Referenced by hpf_compile_loop().

Here is the caller graph for this function:

entity_loop_index_p()

bool entity_loop_index_p

(

entity

e

)

Definition at line 383 of file compiler-util.c.

{
    MAP(LOOP, l, if (e == loop_index(l)) return true, current_loop_list);
    return false;
}

References current_loop_list, LOOP, loop_index, and MAP.

Referenced by affine_expression_of_loop_index_p(), shift_expression_of_loop_index_p(), and simple_indices_p().

Here is the caller graph for this function:

FindDefinitionsOf()

list FindDefinitionsOf	(	statement	stat,
		list	lsyn
	)

Parameters

stat	tat
lsyn	syn

Definition at line 239 of file compiler-util.c.

{
    list result = NIL;
 
    pips_assert("empty lists", ENDP(syntax_list) && ENDP(found_definitions));
 
    syntax_list = lsyn;
 
    gen_recurse(stat,
                statement_domain,
                gen_true,
                FindDefinitionsOf_rewrite);
 
    result = found_definitions,
    syntax_list = NIL,
    found_definitions = NIL;
 
    return(result);
}

References ENDP, FindDefinitionsOf_rewrite(), found_definitions, gen_recurse, gen_true(), NIL, pips_assert, statement_domain, and syntax_list.

Referenced by hpf_compile_parallel_body().

Here is the call graph for this function:

Here is the caller graph for this function:

FindDefinitionsOf_rewrite()

static void FindDefinitionsOf_rewrite ( statement  s )

static

??? False! nothing is checked about the statement movement...

Definition at line 218 of file compiler-util.c.

{
    instruction i = statement_instruction(s);
 
    /* ??? False! nothing is checked about the statement movement...
     */
    if (instruction_assign_p(i))
        if (is_in_syntax_list
            (reference_variable
             (expression_reference
              (EXPRESSION(CAR(call_arguments(instruction_call(i)))))),
                 syntax_list))
        {
            found_definitions = 
                CONS(STATEMENT, instruction_to_statement(i), found_definitions);
            statement_instruction(s) = 
                make_continue_instruction();
        }
}

References call_arguments, CAR, CONS, EXPRESSION, expression_reference(), found_definitions, instruction_assign_p(), instruction_call, instruction_to_statement(), is_in_syntax_list(), make_continue_instruction(), reference_variable, STATEMENT, statement_instruction, and syntax_list.

Referenced by FindDefinitionsOf().

Here is the call graph for this function:

Here is the caller graph for this function:

FindRefToDistArrayInStatement()

void FindRefToDistArrayInStatement	(	statement	obj,
		list *	lwp,
		list *	lrp
	)

Parameters

obj	bj
lwp	wp
lrp	rp

Definition at line 121 of file compiler-util.c.

{
    list
        saved_r = found_read,
        saved_w = found_written;
 
    found_read = NIL, found_written = NIL;
 
    gen_multi_recurse(obj,
                      call_domain,
                      FindRefToDistArrayInStatement_call_filter,
                      gen_null,
                      expression_domain,
                      FindRefToDistArrayInStatement_expression_filter,
                      gen_null,
                      NULL);
 
    *lwp = found_written, *lrp = found_read,
    found_read = saved_r, found_written = saved_w;
}

References call_domain, expression_domain, FindRefToDistArrayInStatement_call_filter(), FindRefToDistArrayInStatement_expression_filter(), found_read, found_written, gen_multi_recurse(), gen_null(), and NIL.

Referenced by hpf_compile_parallel_body(), hpf_compile_parallel_loop(), and Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

FindRefToDistArrayInStatement_call_filter()

static bool FindRefToDistArrayInStatement_call_filter ( call  c )

static

else ASSIGN case

Definition at line 90 of file compiler-util.c.

{
    list l;
    syntax s;
 
    if (!call_assign_p(c)) return(true);
 
    /*   else ASSIGN case
     */
 
    l = call_arguments(c);
    s = expression_syntax(EXPRESSION(CAR(l)));
    
    if (array_distributed_p(reference_variable(syntax_reference(s))))
        found_written = CONS(SYNTAX, s, found_written);
    
    found_read = 
        gen_nconc(FindRefToDistArray(EXPRESSION(CAR(CDR(l)))),
                  found_read);
    
    return(false);
}

References array_distributed_p(), call_arguments, call_assign_p, CAR, CDR, CONS, EXPRESSION, expression_syntax, FindRefToDistArray(), found_read, found_written, gen_nconc(), reference_variable, SYNTAX, and syntax_reference.

Referenced by FindRefToDistArrayInStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

FindRefToDistArrayInStatement_expression_filter()

static bool FindRefToDistArrayInStatement_expression_filter ( expression  e )

static

Definition at line 114 of file compiler-util.c.

{
    found_read = gen_nconc(FindRefToDistArray(e), found_read);
    return(false);
}

References FindRefToDistArray(), found_read, and gen_nconc().

Referenced by FindRefToDistArrayInStatement().

Here is the call graph for this function:

Here is the caller graph for this function:

IndicesOfRef()

list IndicesOfRef

(

syntax

syn

)

??? could check that the given call is a constant.

Parameters

syn

yn

Definition at line 156 of file compiler-util.c.

{
    list l = NIL;
 
    pips_assert("reference", syntax_reference_p(syn));
 
    MAP(EXPRESSION, e,
     {
         syntax s = expression_syntax(e);
 
         switch (syntax_tag(s))
         {
         case is_syntax_reference:
             l = CONS(SYNTAX, s, l);
             break;
         case is_syntax_range:
             pips_internal_error("don't konw what to do with a range");
             break;
         case is_syntax_call:
             /*     ??? could check that the given call is a constant.
              */
             break;
         default:
             pips_internal_error("unexpected syntax tag");
         }       
     },
         reference_indices(syntax_reference(syn)));
 
    return(l);   
}

References CONS, EXPRESSION, expression_syntax, is_syntax_call, is_syntax_range, is_syntax_reference, MAP, NIL, pips_assert, pips_internal_error, reference_indices, SYNTAX, syntax_reference, syntax_reference_p, and syntax_tag.

Referenced by lIndicesOfRef().

Here is the caller graph for this function:

indirections_inside_statement_p()

bool indirections_inside_statement_p

(

_UNUSED_ statement

stat

)

indirections_inside_statement_p

??? this may be checked using the dependences graph, looking for edges linking two distributed variables inside the loop...

Definition at line 280 of file compiler-util.c.

{
  ifdebug(1)
    hpfc_warning("not implemented yet, returning FALSE\n");
  return false;
}

References hpfc_warning, and ifdebug.

Referenced by hpf_compile_loop().

Here is the caller graph for this function:

is_in_syntax_list()

bool is_in_syntax_list	(	entity	e,
		list	l
	)

Definition at line 200 of file compiler-util.c.

{
    MAP(SYNTAX, s,
        if (e==reference_variable(syntax_reference(s))) return(true),
        l);
 
    return(false);
}

References MAP, reference_variable, SYNTAX, and syntax_reference.

Referenced by AddOnceToIndicesList(), and FindDefinitionsOf_rewrite().

Here is the caller graph for this function:

lIndicesOfRef()

list lIndicesOfRef

(

list

lsyn

)

computes the list of indices of the list of ref that are variables...

Parameters

lsyn

syn

Definition at line 147 of file compiler-util.c.

{
    return((ENDP(lsyn))?
           (NULL):
           (AddOnceToIndicesList(IndicesOfRef(SYNTAX(CAR(lsyn))),
                                 lIndicesOfRef(CDR(lsyn)))));
}

References AddOnceToIndicesList(), CAR, CDR, ENDP, IndicesOfRef(), and SYNTAX.

Referenced by hpf_compile_parallel_body().

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 310 of file compiler-util.c.

{
    return execution_parallel_p(loop_execution(l));
}

References execution_parallel_p, and loop_execution.

Referenced by parallel_loop_nest_to_body().

Here is the caller graph for this function:

loop_index_to_range()

range loop_index_to_range

(

entity

index

)

Parameters

index

ndex

Definition at line 390 of file compiler-util.c.

{
    MAP(LOOP, l, if (loop_index(l)==index) return(loop_range(l)),
        current_loop_list);
    return range_undefined;
}

References current_loop_list, LOOP, loop_index, loop_range, MAP, and range_undefined.

Referenced by array_access_to_array_ranges(), and generate_one_message().

Here is the caller graph for this function:

loop_rewrite()

static void loop_rewrite ( loop  l )

static

a loop was found directly as a body

Definition at line 326 of file compiler-util.c.

{
    if (n_loops!=n_levels) /* a loop was found directly as a body */
        n_levels++, blocks = CONS(LIST, NIL, blocks);
 
    if (n_loops==0) inner_body=loop_body(l);
    loops = CONS(LOOP, l, loops);
    n_loops++;
}

References blocks, CONS, inner_body, LIST, LOOP, loop_body, loops, n_levels, n_loops, and NIL.

Referenced by parallel_loop_nest_to_body().

Here is the caller graph for this function:

parallel_loop_nest_to_body()

statement parallel_loop_nest_to_body	(	statement	loop_nest,
		list *	pblocks,
		list *	ploops
	)

nothing was done for the first !

Parameters

loop_nest	oop_nest
pblocks	blocks
ploops	loops

Definition at line 336 of file compiler-util.c.

{
    loops=NIL, n_loops=0;
    blocks=NIL, n_levels=0;
    inner_body=statement_undefined;
 
    pips_assert("loop", instruction_loop_p(statement_instruction(loop_nest)));
 
    gen_multi_recurse(loop_nest,
                      sequence_domain, gen_true, sequence_rewrite,
                      loop_domain, loop_filter, loop_rewrite,
                      NULL);
 
    pips_assert("loops found", n_loops!=0 && (n_loops-n_levels==1));
 
    *pblocks = CONS(LIST, NIL, blocks); /* nothing was done for the first ! */
    *ploops=loops;
 
    return(inner_body);
}

References blocks, CONS, gen_multi_recurse(), gen_true(), inner_body, instruction_loop_p, LIST, loop_domain, loop_filter(), loop_rewrite(), loops, n_levels, n_loops, NIL, pips_assert, sequence_domain, sequence_rewrite(), statement_instruction, and statement_undefined.

Referenced by full_copy_p(), and Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_current_loops()

void reset_current_loops

(

void

)

Definition at line 377 of file compiler-util.c.

{
    gen_free_list(current_loop_list);
    current_loop_list=NIL;
}

References current_loop_list, gen_free_list(), and NIL.

Here is the call graph for this function:

sequence_rewrite()

static void sequence_rewrite ( sequence  s )

static

there was no doall inside

Definition at line 315 of file compiler-util.c.

{
    if (n_loops==0 && n_levels==0) /* there was no doall inside */
        return;
 
    if (n_loops-n_levels!=1)
        pips_internal_error("block within a block encountered");
 
    n_levels++, blocks = CONS(LIST, sequence_statements(s), blocks);
}

References blocks, CONS, LIST, n_levels, n_loops, pips_internal_error, and sequence_statements.

Referenced by parallel_loop_nest_to_body().

Here is the caller graph for this function:

set_current_loops()

void set_current_loops

(

statement

obj

)

Parameters

obj

bj

Definition at line 371 of file compiler-util.c.

{
    pips_assert("no current loop", current_loop_list==NIL);
    gen_recurse(obj, loop_domain, gen_true, set_current_loops_rewrite);
}

References current_loop_list, gen_recurse, gen_true(), loop_domain, NIL, pips_assert, and set_current_loops_rewrite().

Referenced by Overlap_Analysis().

Here is the call graph for this function:

Here is the caller graph for this function:

set_current_loops_rewrite()

static void set_current_loops_rewrite ( loop  l )

static

Definition at line 366 of file compiler-util.c.

{
    current_loop_list = CONS(LOOP, l, current_loop_list);
}

References CONS, current_loop_list, and LOOP.

Referenced by set_current_loops().

Here is the caller graph for this function:

update_control_lists()

void update_control_lists	(	control	c,
		control_mapping	map
	)

Compiler Utilities.

compiler-util.c

Fabien Coelho, May 1993

Parameters

map

ap

Definition at line 36 of file compiler-util.c.

{
    control cprime = (control) GET_CONTROL_MAPPING(map, c);
 
    pips_assert("empty lists for cprime",
                control_predecessors(cprime)==NIL &&
                control_successors(cprime)==NIL);
 
    control_predecessors(cprime) = 
        updated_control_list(control_predecessors(c), map);
    control_successors(cprime) = 
        updated_control_list(control_successors(c), map);
}

References control_predecessors, control_successors, GET_CONTROL_MAPPING, NIL, pips_assert, and updated_control_list().

Referenced by hpf_compile_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

updated_control_list()

list updated_control_list	(	list	lc,
		control_mapping	map
	)

Parameters

lc	c
map	ap

Definition at line 52 of file compiler-util.c.

{
    list lc_result = NIL;
    control new_c = control_undefined;
 
    MAP(CONTROL, current,
     {
         new_c = (control) GET_CONTROL_MAPPING(map, current);
 
         pips_assert("defined",
                     !control_undefined_p(current) ||
                     !control_undefined_p(new_c));
 
         lc_result = CONS(CONTROL, new_c, lc_result);
     },
         lc);
 
    return(gen_nreverse(lc_result));
}

References CONS, CONTROL, control_undefined, control_undefined_p, current, gen_nreverse(), GET_CONTROL_MAPPING, MAP, NIL, and pips_assert.

Referenced by update_control_lists().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

blocks

list blocks

static

lisp of loops

Definition at line 306 of file compiler-util.c.

Referenced by do_split_block_statements(), hpf_compile_unstructured(), iteration_domain_from_statement(), loop_rewrite(), only_io_unstructured(), parallel_loop_nest_to_body(), postcondition_filter(), sequence_rewrite(), statement_arrows(), text_unstructured(), uns_rwt(), and unstructured_to_direct_declarations().

current_loop_list

list current_loop_list =NIL

static

management of a list of current loops.

very burk ???

Definition at line 364 of file compiler-util.c.

Referenced by entity_loop_index_p(), loop_index_to_range(), reset_current_loops(), set_current_loops(), and set_current_loops_rewrite().

found_definitions

list found_definitions =NIL

static

Definition at line 216 of file compiler-util.c.

Referenced by FindDefinitionsOf(), and FindDefinitionsOf_rewrite().

found_read

list found_read = NIL

static

Definition at line 85 of file compiler-util.c.

Referenced by FindRefToDistArrayInStatement(), FindRefToDistArrayInStatement_call_filter(), and FindRefToDistArrayInStatement_expression_filter().

found_written

list found_written = NIL

static

FindRefToDistArrayInStatement.

everything may be quite false regarding to the real effects of the functions called, but it seems to me that the pips effect analysis doesn't match my needs... and I have not much time to think about that...

??? these stupid functions assume no indirections on distributed arrays ??? also that they are not written by a function other than assign

Definition at line 84 of file compiler-util.c.

Referenced by FindRefToDistArrayInStatement(), and FindRefToDistArrayInStatement_call_filter().

inner_body

statement inner_body

static

Definition at line 308 of file compiler-util.c.

Referenced by initialize_variable_used_map_for_current_loop_nest(), loop_rewrite(), and parallel_loop_nest_to_body().

loops

list loops

static

---

statement parallel_loop_nest_to_body(loop_nest, pblocks, ploops) statement loop_nest; list *pblocks, *ploops;

What I want is to extract the parallel loops from loop_nest, while keeping track of the structure if the loop nest is not perfectly nested. Only a very simple structure is recognized.

it returns the inner statement of the loop nest, a list of pointers to the loops, and a list of pointers to the blocks containing these loops if any.

we may discuss the implementation based on static global variables... but I cannot see how to do it otherwise with a gen_recurse.

Definition at line 305 of file compiler-util.c.

Referenced by add_conflicts(), adg_get_predicate_of_loops(), CodeGenerate(), find_level_l_loop_statement(), index_of_a_loop_p(), IsolatedStatement(), loop_rewrite(), loops_mapping_of_statement(), MakeNestOfParallelLoops(), MakeNestOfStatementList(), module_loops(), parallel_loop_nest_to_body(), print_loops(), process_reduced_loops(), quick_privatize_statement_pair(), rloops_mapping_of_statement(), rloops_mapping_of_unstructured(), simdizer_auto_tile(), statement_imbrication_level(), and variable_private_to_loop_p().

n_levels

int n_levels

static

Definition at line 307 of file compiler-util.c.

Referenced by loop_rewrite(), parallel_loop_nest_to_body(), and sequence_rewrite().

n_loops

int n_loops

static

list of lists, may be NIL if none

Definition at line 307 of file compiler-util.c.

Referenced by loop_rewrite(), parallel_loop_nest_to_body(), and sequence_rewrite().

syntax_list

list syntax_list =NIL

static

??? False! The definition looked for must be an assignment call...

Definition at line 215 of file compiler-util.c.

Referenced by FindDefinitionsOf(), and FindDefinitionsOf_rewrite().