compile.c File Reference

#include "defines-local.h"
#include "pipsdbm.h"
#include "workspace-util.h"
#include "prettyprint.h"
#include "resources.h"
#include "effects-generic.h"
#include "effects-simple.h"
#include "effects-convex.h"
#include "expressions.h"

Include dependency graph for compile.c:

Go to the source code of this file.

Macros
#define	src(name, suf)    strdup(concatenate(WORKSPACE_SRC_SPACE "/", name, suf, NULL))
	HPFC by Fabien Coelho, May 1993 and later... More...
#define	full_name(dir, name)   concatenate(dir, "/", name, NULL)

Functions
void	make_host_and_node_modules (entity module)
	compile.c More...
static void	drop_distributed_arguments (entity module)
	kind of a quick hack to remove distributed arguments for the host More...
static entity	create_bound_entity (entity module, entity array, bool upper, int dim, int number)
static list	add_one_bound_argument (list lp, entity module, entity array, bool upper, int dim, int formal_number)
static void	add_bound_arguments (entity module)
	for the node More...
void	init_host_and_node_entities ()
	both host and node modules are initialized with the same declarations than the compiled module, but the distributed arrays declarations... More...
FILE *	hpfc_fopen (string name)
void	hpfc_fclose (FILE *f, string name)
static const char *	old_name (entity module, entity obj)
	old name of obj while in module now. More...
static string	hpfc_head_hook (entity m)
	to be used by the prettyprinter at the head of a file. More...
static string	hpfc_common_hook (entity module, entity common)
	to be used by the prettyprinter when dealing with a common. More...
void	hpfc_print_code (FILE *file, entity module, statement stat)
void	put_generated_resources_for_common (entity common)
void	compile_a_special_io_function (entity module)
	just copied for the host More...
void	compile_a_pure_function (entity module)
	simply copied for both host and node... More...
void	put_generated_resources_for_module (_UNUSED_ statement stat, statement host_stat, statement node_stat)
void	put_generated_resources_for_program (_UNUSED_ string program_name)
void	hpfcompile (const char *module_name)
	Compiler call, obsole. More...
static bool	expression_simple_nondist_p (expression e)
	drivers for atomize_as_required in transformations More...
static bool	hpfc_decision (reference r, expression e)
	break expression e in reference r if ... More...
entity	hpfc_new_variable (entity module, basic b)
void	hpfc_compile_error_handler ()
static bool	invariant_expression_p (expression e, list loe, list le)
	true if no written effect on any variables of e in loe More...
static bool	vect_in_p (Pvecteur vin, Pvecteur vref)
	returns if vin is in vref More...
static bool	expression_flt (expression e)
static void	substitute_and_create (statement s, entity v, expression e)
static bool	loop_flt (loop l)
static void	extract_distributed_non_constant_terms (statement s)
	transformation: DOALL I,J ... More...
static bool	test_atomization (test t, _UNUSED_ expression e)
void	NormalizeCodeForHpfc (statement s)
static void	update_common_rewrite (reference r)
	To manage the common entities, I decided arbitrarilly that all commons will have to be declared exactly the same way (name and so), so I can safely unify the entities among the modules. More...
static void	update_loop_rewrite (loop l)
static void	debug_ref_rwt (reference r)
void	debug_print_referenced_entities (void *obj)
void	update_common_references_in_obj (void *obj)
void	update_common_references_in_regions ()
void	NormalizeCommonVariables (entity module, statement stat)

Variables
static entity	subs_v
	substitute all occurences of expression e in statement s by variable v More...
static expression	subs_e
static Pvecteur	subs_pv

Macro Definition Documentation

full_name

#define full_name	(		dir,
			name
	)		concatenate(dir, "/", name, NULL)

Definition at line 414 of file compile.c.

src

#define src	(		name,
			suf
	)		strdup(concatenate(WORKSPACE_SRC_SPACE "/", name, suf, NULL))

HPFC by Fabien Coelho, May 1993 and later...

Definition at line 41 of file compile.c.

Function Documentation

add_bound_arguments()

static void add_bound_arguments ( entity  module )

static

for the node

of parameter

Definition at line 196 of file compile.c.

{
    type t = entity_type(module);
    functional f;
    list /* of parameter */ le = NIL, lp;
    int len, i, next;
 
    message_assert("functional", type_functional_p(t));
    f = type_functional(t);
    lp = functional_parameters(f);
    len = gen_length(lp);
    next = len+1;
 
    for(i=1; i<=len; i++)
    {
        entity arg = find_ith_parameter(module, i),
               old = load_old_node(arg);
        pips_debug(8, "array %s\n", entity_name(old));
 
        if (array_distributed_p(old))
        {
            int dim, ndim;
            ndim = NumberOfDimension(arg);
 
            for(dim=1; dim<=ndim; dim++)
            {       
                if (ith_dim_overlapable_p(old, dim))
                {
                    le = add_one_bound_argument
                        (le, module, arg, false, dim, next++);
                    le = add_one_bound_argument
                        (le, module, arg, true, dim, next++);
                }
            }
        }
    }
 
    if (le)
    {
        functional_parameters(f) = gen_nconc(lp, le);
    }
}

References add_one_bound_argument(), array_distributed_p(), entity_name, entity_type, f(), find_ith_parameter(), functional_parameters, gen_length(), gen_nconc(), ith_dim_overlapable_p(), load_old_node(), message_assert, module, NIL, NumberOfDimension(), pips_debug, type_functional, and type_functional_p.

Referenced by init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

add_one_bound_argument()

static list add_one_bound_argument ( list  lp, entity  module, entity  array, bool  upper, int  dim, int  formal_number  )

static

Parameters

lp	of parameter

Definition at line 177 of file compile.c.

{
    (void) create_bound_entity(module, array, upper, dim, formal_number);
    lp = CONS(PARAMETER, 
              make_parameter(make_type_variable(
                                                make_variable(MakeBasic(is_basic_int), NIL,NIL)),
                             make_mode_reference(), // FI: Used to be value...
                             make_dummy_unknown()),
              lp);
    return lp;
}

References array, CONS, create_bound_entity(), is_basic_int, make_dummy_unknown(), make_mode_reference(), make_parameter(), make_type_variable(), make_variable(), MakeBasic(), module, NIL, and PARAMETER.

Referenced by add_bound_arguments().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_a_pure_function()

void compile_a_pure_function

(

entity

module

)

simply copied for both host and node...

Parameters

module

odule

Definition at line 493 of file compile.c.

{
    string file_name, hn_name, dir_name, fs, ft;
 
    pips_debug(1, "compiling pure a function (%s)\n", entity_name(module));
 
    const char* prefix = module_local_name(module);
    dir_name = db_get_current_workspace_directory();
    file_name = db_get_file_resource(DBR_SOURCE_FILE, prefix, true);
    hn_name = src(prefix, BOTH_SUFFIX);
 
    fs = strdup(concatenate(dir_name, "/", file_name, NULL));
    ft = strdup(concatenate(dir_name, "/", hn_name, NULL));
    safe_copy(fs, ft);
    free(fs), free(ft);
 
    DB_PUT_FILE_RESOURCE(DBR_HPFC_HOST, prefix, hn_name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_NODE, prefix, strdup(hn_name));
    DB_PUT_FILE_RESOURCE(DBR_HPFC_RTINIT, prefix, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_PARAMETERS, prefix, NO_FILE);
}

References BOTH_SUFFIX, concatenate(), db_get_current_workspace_directory(), db_get_file_resource, DB_PUT_FILE_RESOURCE, entity_name, file_name, free(), module, module_local_name(), NO_FILE, pips_debug, prefix, safe_copy(), src, and strdup().

Referenced by hpfc_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_a_special_io_function()

void compile_a_special_io_function

(

entity

module

)

just copied for the host

Parameters

module

odule

Definition at line 469 of file compile.c.

{
    string  file_name, h_name, dir_name, fs, ft;
 
    const char *prefix = module_local_name(module);
    file_name = db_get_file_resource(DBR_SOURCE_FILE, prefix, true);
    dir_name = db_get_current_workspace_directory();
    h_name = src(prefix, HOST_SUFFIX);
 
    fs = strdup(concatenate(dir_name, "/", file_name, NULL));
    ft = strdup(concatenate(dir_name, "/", h_name, NULL));
    safe_copy(fs, ft);
    free(fs);
    free(ft);
 
    DB_PUT_FILE_RESOURCE(DBR_HPFC_HOST, prefix, h_name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_NODE, prefix, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_RTINIT, prefix, NO_FILE);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_PARAMETERS, prefix, NO_FILE);
}

References concatenate(), db_get_current_workspace_directory(), db_get_file_resource, DB_PUT_FILE_RESOURCE, file_name, free(), HOST_SUFFIX, module, module_local_name(), NO_FILE, prefix, safe_copy(), src, and strdup().

Referenced by hpfc_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

create_bound_entity()

static entity create_bound_entity ( entity  module, entity  array, bool  upper, int  dim, int  number  )

static

Definition at line 153 of file compile.c.

{
    entity result = argument_bound_entity(module, array, upper, dim);
 
    free_storage(entity_storage(result));
    entity_storage(result) = 
        make_storage(is_storage_formal, make_formal(module, number));
 
    pips_assert("formal variable", type_variable_p(entity_type(result)));
 
    AddEntityToDeclarations(result, module);
 
    pips_debug(9, "creating %s in %s (arg %d)\n", 
               entity_name(result), entity_name(module), number);
 
    return result;
}

References AddEntityToDeclarations(), argument_bound_entity(), array, entity_name, entity_storage, entity_type, free_storage(), is_storage_formal, make_formal(), make_storage(), module, pips_assert, pips_debug, and type_variable_p.

Referenced by add_one_bound_argument().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_print_referenced_entities()

void debug_print_referenced_entities

(

void *

obj

)

Parameters

obj

bj

Definition at line 906 of file compile.c.

{
    gen_multi_recurse(obj, reference_domain, gen_true, debug_ref_rwt, NULL);
}

References debug_ref_rwt(), gen_multi_recurse(), gen_true(), and reference_domain.

Referenced by update_common_references_in_obj().

Here is the call graph for this function:

Here is the caller graph for this function:

debug_ref_rwt()

static void debug_ref_rwt ( reference  r )

static

Definition at line 897 of file compile.c.

{
    entity var = reference_variable(r);
 
    if (entity_in_common_p(var))
        fprintf(stderr, "[debug_ref_rwt] reference to %s\n", 
                entity_name(var));
}

References entity_in_common_p(), entity_name, fprintf(), and reference_variable.

Referenced by debug_print_referenced_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

drop_distributed_arguments()

static void drop_distributed_arguments ( entity  module )

static

kind of a quick hack to remove distributed arguments for the host

of the host

of parameter

number of next kept parameter

Definition at line 111 of file compile.c.

{
    type t = entity_type(module);
    functional f;
    list /* of parameter */ le = NIL, lp;
    int len, i, n /* number of next kept parameter */;
 
    message_assert("functional", type_functional_p(t));
    f = type_functional(t);
    lp = functional_parameters(f);
    len = gen_length(lp);
 
    pips_debug(8, "considering %d arg(s) of %s\n", len, entity_name(module));
 
    for (i=1, n=1; i<=len; i++, POP(lp))
    {
        entity ent = find_ith_parameter(module, i);
        
        if (!entity_undefined_p(ent) && !array_distributed_p(ent))
        {
            le = CONS(PARAMETER, PARAMETER(CAR(lp)), le);
            pips_debug(8, "keeping %d argument %s\n", i, entity_name(ent));
 
            formal_offset(storage_formal(entity_storage(ent))) = n;
            n++;
        }
        else
        {
            if (!entity_undefined_p(ent))
                formal_offset(storage_formal(entity_storage(ent))) = INT_MAX;
 
            pips_debug(8, "dropping %d argument %s\n", i, 
                       entity_undefined_p(ent)? "undefined": entity_name(ent));
        }
    }
 
    lp = functional_parameters(f);
    functional_parameters(f) = gen_nreverse(le);
    gen_free_list(lp);
}

References array_distributed_p(), CAR, CONS, entity_name, entity_storage, entity_type, entity_undefined_p, f(), find_ith_parameter(), formal_offset, functional_parameters, gen_free_list(), gen_length(), gen_nreverse(), message_assert, module, NIL, PARAMETER, pips_debug, POP, storage_formal, type_functional, and type_functional_p.

Referenced by init_host_and_node_entities().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_flt()

static bool expression_flt ( expression  e )

static

does sg about the linearization of the expression

??? memory leak, but how to deal with effect references?

Definition at line 709 of file compile.c.

{
    /* does sg about the linearization of the expression 
     */
    if (subs_pv && expression_linear_p(e))
    {
        normalized n = expression_normalized(e);
        Pvecteur v = normalized_linear(n);
        if (vect_in_p(subs_pv, v))
        {
            Pvecteur vn = vect_substract(v,subs_pv);
            vect_add_elem(&vn, (Variable)subs_v, VALUE_ONE);
            vect_rm(v);
            normalized_linear_(n) = newgen_Pvecteur(vn);
        }
    }
 
    if (expression_equal_p(e, subs_e))
    {
        /* ??? memory leak, but how to deal with effect references? */
        expression_syntax(e) = 
            make_syntax(is_syntax_reference, make_reference(subs_v, NIL));
        free_normalized(expression_normalized(e));
        expression_normalized(e) = 
            make_normalized(is_normalized_linear,
                            vect_new((Variable)subs_v, VALUE_ONE));
        return false;
    }
    return true;
}

References expression_equal_p(), expression_linear_p(), expression_normalized, expression_syntax, free_normalized(), is_normalized_linear, is_syntax_reference, make_normalized(), make_reference(), make_syntax(), newgen_Pvecteur, NIL, normalized_linear, normalized_linear_, subs_e, subs_pv, subs_v, VALUE_ONE, vect_add_elem(), vect_in_p(), vect_new(), vect_rm(), and vect_substract().

Referenced by substitute_and_create().

Here is the call graph for this function:

Here is the caller graph for this function:

expression_simple_nondist_p()

static bool expression_simple_nondist_p ( expression  e )

static

drivers for atomize_as_required in transformations

Definition at line 614 of file compile.c.

{
    reference r;
    if (!expression_reference_p(e)) return(false);
    r = syntax_reference(expression_syntax(e));
    return !array_distributed_p(reference_variable(r)) &&
            ENDP(reference_indices(r));
}

References array_distributed_p(), ENDP, expression_reference_p(), expression_syntax, reference_indices, reference_variable, and syntax_reference.

Referenced by hpfc_decision().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_distributed_non_constant_terms()

static void extract_distributed_non_constant_terms ( statement  s )

static

transformation: DOALL I,J ...

A(I,J,e) -> DOALL E=e,e,1 ,I,J A(I,J,E)

Definition at line 826 of file compile.c.

{
    DEBUG_STAT(2, "in", s);
 
    make_c_stmt_stack();
    gen_multi_recurse(s, 
                      statement_domain, c_stmt_filter, c_stmt_rewrite, 
                      loop_domain, loop_flt, gen_null,
                      NULL);
    free_c_stmt_stack();        
 
    DEBUG_STAT(2, "out", s);
}

References DEBUG_STAT, gen_multi_recurse(), gen_null(), loop_domain, loop_flt(), and statement_domain.

Referenced by NormalizeCodeForHpfc().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_common_hook()

static string hpfc_common_hook ( entity  module, entity  common  )

static

to be used by the prettyprinter when dealing with a common.

inclusion of the parameters and commons...

old_name(module, common);

Definition at line 381 of file compile.c.

{
    const char* name = module_local_name(common);/* old_name(module, common); */
    return strdup(concatenate
        ("      include \"", name, PARM_SUFFIX "\"\n"
         "      include \"", name,  
         module==host_module ? HINC_SUFFIX "\"\n" : NINC_SUFFIX "\"\n", NULL));
}

References concatenate(), HINC_SUFFIX, host_module, module, module_local_name(), NINC_SUFFIX, PARM_SUFFIX, and strdup().

Referenced by hpfc_print_code().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_compile_error_handler()

void hpfc_compile_error_handler

(

void

)

Definition at line 644 of file compile.c.

{
    error_reset_c_stmt_stack();
}

Referenced by hpfc_error_handler().

Here is the caller graph for this function:

hpfc_decision()

static bool hpfc_decision ( reference  r, expression  e  )

static

break expression e in reference r if ...

Definition at line 625 of file compile.c.

{
    return array_distributed_p(reference_variable(r)) &&
           !expression_integer_constant_p(e) && 
           !expression_simple_nondist_p(e);
}

References array_distributed_p(), expression_integer_constant_p(), expression_simple_nondist_p(), and reference_variable.

Referenced by NormalizeCodeForHpfc().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_fclose()

void hpfc_fclose	(	FILE *	f,
		string	name
	)

Parameters

name

ame

Definition at line 341 of file compile.c.

{
    string base = pips_basename(name, NULL);
    fprintf(f, "!\n! That is all for %s\n!\n", base);
    free(base);
    safe_fclose(f, name);
}

References base, f(), fprintf(), free(), pips_basename(), and safe_fclose().

Referenced by generate_hpf_remapping_file(), put_generated_resources_for_common(), put_generated_resources_for_module(), and put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_fopen()

FILE* hpfc_fopen

(

string

name

)

Parameters

name

ame

Definition at line 329 of file compile.c.

{
    string base = pips_basename(name, NULL);
    FILE *f = (FILE *) safe_fopen(name, "w");
    fprintf(f, "!\n! File %s\n! This file has been automatically generated " 
            "by the HPF compiler\n!\n", base);
    free(base);
    return f;
}

References base, f(), fprintf(), free(), pips_basename(), and safe_fopen().

Referenced by generate_hpf_remapping_file(), put_generated_resources_for_common(), put_generated_resources_for_module(), and put_generated_resources_for_program().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_head_hook()

static string hpfc_head_hook ( entity  m )

static

to be used by the prettyprinter at the head of a file.

inclusion of needed runtime headers. module

Definition at line 366 of file compile.c.

{
    return strdup(concatenate
        ("      implicit none\n"
         "      include \"" GLOBAL_PARAMETERS_H "\"\n"
         "      include \"hpfc_commons.h\"\n"
         "      include \"hpfc_includes.h\"\n"
         "      include \"", old_name(m, m), PARM_SUFFIX "\"\n", NULL));
}

References concatenate(), GLOBAL_PARAMETERS_H, old_name(), PARM_SUFFIX, and strdup().

Referenced by hpfc_print_code().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_new_variable()

entity hpfc_new_variable	(	entity	module,
		basic	b
	)

Parameters

module

odule

Definition at line 632 of file compile.c.

{
    entity new_ent =  make_new_scalar_variable(module, copy_basic(b));
    AddEntityToCurrentModule(new_ent);
    return new_ent;
}

References AddEntityToCurrentModule(), copy_basic(), make_new_scalar_variable(), and module.

Referenced by extract_lattice(), generate_copy_loop_nest(), loop_flt(), and NormalizeCodeForHpfc().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfc_print_code()

void hpfc_print_code	(	FILE *	file,
		entity	module,
		statement	stat
	)

Parameters

file	ile
module	odule
stat	tat

Definition at line 393 of file compile.c.

{
    text t;
    debug_on("PRETTYPRINT_DEBUG_LEVEL");
 
    set_prettyprinter_head_hook(hpfc_head_hook);
    set_prettyprinter_common_hook(hpfc_common_hook);
 
    t = text_module(module, stat);
    print_text(file, t);
    free_text(t);
    
    reset_prettyprinter_common_hook();
    reset_prettyprinter_head_hook();
 
    debug_off();
}

References debug_off, debug_on, free_text(), hpfc_common_hook(), hpfc_head_hook(), module, print_text(), reset_prettyprinter_common_hook(), reset_prettyprinter_head_hook(), set_prettyprinter_common_hook(), set_prettyprinter_head_hook(), and text_module().

Referenced by put_generated_resources_for_module().

Here is the call graph for this function:

Here is the caller graph for this function:

hpfcompile()

void hpfcompile

(

const char *

module_name

)

Compiler call, obsole.

left here for allowing linking

Parameters

module_name

odule_name

Definition at line 601 of file compile.c.

{
    debug_on("HPFC_DEBUG_LEVEL");
    pips_debug(1, "module: %s\n", module_name);
    pips_internal_error("obsolete");
    debug_off();
}

References debug_off, debug_on, module_name(), pips_debug, and pips_internal_error.

Here is the call graph for this function:

init_host_and_node_entities()

void init_host_and_node_entities

(

void

)

both host and node modules are initialized with the same declarations than the compiled module, but the distributed arrays declarations...

which are not declared in the case of the host_module, and the declarations of which are modified in the node_module (call to NewDeclarationsOfDistributedArrays)...

First, the commons are updated

COMMONS

Then, the other entities

parameters are selected. I think they may be either functional of variable (if declared...) FC 15/09/93

VARIABLES

PARAMETERS

Definition at line 246 of file compile.c.

{
    entity current_module = get_current_module_entity();
 
    ifdebug(3)
    {
        text t;
        debug_on("PRETTYPRINT_DEBUG_LEVEL");
        pips_debug(3, "old declarations:\n");
        t = text_declaration(current_module);
        print_text(stderr, t);
        free_text(t);
        debug_off();
    }
 
    host_module = load_new_host(current_module);
    node_module = load_new_node(current_module);
 
    /*  First, the commons are updated
     */
    MAP(ENTITY, e,
     {
         type t = entity_type(e);
 
         if (type_area_p(t) && !entity_special_area_p(e))
         {
             debug(3, "init_host_and_node_entities",    /* COMMONS */
                   "considering common %s\n", entity_name(e));
 
             AddCommonToHostAndNodeModules(e); 
             add_a_common(e);
         }
     },
         entity_declarations(current_module)); 
 
    /*   Then, the other entities
     */
    MAP(ENTITY, e,
     {
         type t = entity_type(e);
 
         /* parameters are selected. I think they may be either
          * functional of variable (if declared...) FC 15/09/93
          */
 
         if ((type_variable_p(t)) ||                    /* VARIABLES */
             ((storage_rom_p(entity_storage(e))) &&
              (value_symbolic_p(entity_initial(e)))))
             AddEntityToHostAndNodeModules(e);
         else
         if (type_functional_p(t))                      /* PARAMETERS */
         {
             AddEntityToDeclarations(e, host_module);   
             AddEntityToDeclarations(e, node_module);
         }
     },
         entity_declarations(current_module));
    
    NewDeclarationsOfDistributedArrays();    
 
    drop_distributed_arguments(host_module);
    add_bound_arguments(node_module);
 
    ifdebug(3)
    {
        text t;
        debug_on("PRETTYPRINT_DEBUG_LEVEL");
        pips_debug(3,"new declarations - node_module:\n");
        (void) entity_consistent_p(node_module);
        t = text_declaration(node_module);
        print_text(stderr, t);
        free_text(t);
 
        pips_debug(3, "new declarations - host_module:\n");
        (void) entity_consistent_p(host_module);
        t = text_declaration(host_module);
        print_text(stderr, t);
        free_text(t);
        debug_off();
    }
}

References add_a_common(), add_bound_arguments(), AddCommonToHostAndNodeModules(), AddEntityToDeclarations(), AddEntityToHostAndNodeModules(), current_module, debug(), debug_off, debug_on, drop_distributed_arguments(), ENTITY, entity_consistent_p(), entity_declarations, entity_initial, entity_name, entity_special_area_p(), entity_storage, entity_type, free_text(), get_current_module_entity(), host_module, ifdebug, load_new_host(), load_new_node(), MAP, NewDeclarationsOfDistributedArrays(), node_module, pips_debug, print_text(), storage_rom_p, text_declaration(), type_area_p, type_functional_p, type_variable_p, and value_symbolic_p.

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

invariant_expression_p()

static bool invariant_expression_p ( expression  e, list  loe, list  le  )

static

true if no written effect on any variables of e in loe

of effect

Parameters

loe	of effect
le	of entity

Definition at line 651 of file compile.c.

{
    list /* of effect */ l = proper_effects_of_expression(e);
 
    ifdebug(3) {
        pips_debug(3, "considering expression:");
        print_expression(e);
    }
 
    FOREACH(EFFECT, ef1, l) {
      FOREACH(EFFECT, ef2, loe) {
        if(store_effect_p(ef1) && store_effect_p(ef2)) {
            entity v = effect_variable(ef1);
            if ((v==effect_variable(ef2) && effect_write_p(ef2)) ||
                gen_in_list_p(v, le))
            {
                gen_free_list(l);
                pips_debug(3, "variant\n");
                return false;
            }
        }
      }
    }
 
    gen_free_list(l);
    pips_debug(3, "invariant\n");
    return true;
}

References EFFECT, effect_variable, effect_write_p, FOREACH, gen_free_list(), gen_in_list_p(), ifdebug, pips_debug, print_expression(), proper_effects_of_expression(), and store_effect_p().

Referenced by loop_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_flt()

static bool loop_flt ( loop  l )

static

of effect

of entity

Definition at line 772 of file compile.c.

{
    statement s;
    list /* of effect */ loce;
    list /* of entity */ lsubs = NIL;
 
    if (execution_sequential_p(loop_execution(l)))
        return true;
 
    s = c_stmt_head();
    loce = effects_effects(load_cumulated_references(s)); 
 
    FOREACH(EFFECT, e, loce)
    {
      if(store_effect_p(e)) {
        reference r = effect_any_reference(e);
        entity v = reference_variable(r);
 
        if (array_distributed_p(v) && effect_write_p(e))
        {
            int dim = 0;
            int p;
            entity n;
 
            pips_debug(3, "considering reference to %s[%zd]\n",
                       entity_name(v), gen_length(reference_indices(r)));
 
            FOREACH(EXPRESSION, x,reference_indices(r))
            {
                dim++;
                ifdebug(3) {
                    pips_debug(3, "considering on dim. %d:\n", dim);
                    print_expression(x);
                }
                if (ith_dim_distributed_p(v, dim, &p) &&
                    invariant_expression_p(x, loce, lsubs) &&
                    !expression_integer_constant_p(x))
                {
                    n = hpfc_new_variable(get_current_module_entity(),
                                          MakeBasic(is_basic_int));
                    substitute_and_create(s, n, x);
                    lsubs = CONS(ENTITY, n, lsubs);
                }
            }
        }
      }
    }
 
    return false;
}

References array_distributed_p(), CONS, EFFECT, effect_any_reference, effect_write_p, effects_effects, ENTITY, entity_name, execution_sequential_p, EXPRESSION, expression_integer_constant_p(), FOREACH, gen_length(), get_current_module_entity(), hpfc_new_variable(), ifdebug, invariant_expression_p(), is_basic_int, ith_dim_distributed_p(), load_cumulated_references(), loop_execution, MakeBasic(), NIL, pips_debug, print_expression(), reference_indices, reference_variable, store_effect_p(), substitute_and_create(), and x.

Referenced by extract_distributed_non_constant_terms().

Here is the call graph for this function:

Here is the caller graph for this function:

make_host_and_node_modules()

void make_host_and_node_modules

(

entity

module

)

compile.c

HOST and NODE empty routines...

Arity and result

then the variable corresponding to the function name must be created for those new functions. The overloaded basic is used to be sure that the variable will not be put in the declarations by the enforced coherency. ??? this issue could be managed by the coherency function ?

to allow the update of the call sites.

Parameters

module

odule

Definition at line 45 of file compile.c.

{
    const char* name = entity_local_name(module);
    entity host, node;
 
    if (bound_new_node_p(module))
        return;
 
    if (entity_main_module_p(module))
    {
        host = make_empty_subroutine(HOST_NAME,make_language_fortran());
        node = make_empty_subroutine(NODE_NAME,make_language_fortran());
    }
    else
    {
        string tmp;
 
        /* HOST and NODE empty routines...
         */
        tmp = strdup(concatenate(name, "_", HOST_NAME, NULL));
        host = make_empty_subroutine(tmp,make_language_fortran());
        free(tmp);
 
        tmp = strdup(concatenate(name, "_", NODE_NAME, NULL));
        node = make_empty_subroutine(tmp,make_language_fortran());
        free(tmp);
 
        /*  Arity and result
         */
        update_functional_as_model(host, module);
        update_functional_as_model(node, module);
 
        if (entity_function_p(module))
        {
            /* then the variable corresponding to the function name
             * must be created for those new functions. The overloaded
             * basic is used to be sure that the variable will not be put 
             * in the declarations by the enforced coherency. 
             * ??? this issue could be managed by the coherency function ?
             */
            string
                var_name = concatenate(name, MODULE_SEP_STRING, name, NULL);
            entity
                var = gen_find_tabulated(var_name, entity_domain), neh, nen;
 
            pips_assert("defined", !entity_undefined_p(var));
 
            const char* tmp_name = entity_local_name(host);
            neh = find_or_create_scalar_entity(tmp_name, tmp_name, 
                                               is_basic_overloaded);
            tmp_name = entity_local_name(node);
            nen = find_or_create_scalar_entity(tmp_name, tmp_name, 
                                               is_basic_overloaded);
            store_new_host_node_variable(neh, nen, var);
        }               
    }
 
    /*  to allow the update of the call sites.
     */
    store_new_host_variable(host, module);
    store_new_node_variable(node, module);
}

References bound_new_node_p(), concatenate(), entity_domain, entity_function_p(), entity_local_name(), entity_main_module_p(), entity_undefined_p, find_or_create_scalar_entity(), free(), gen_find_tabulated(), HOST_NAME, is_basic_overloaded, make_empty_subroutine(), make_language_fortran(), module, MODULE_SEP_STRING, node(), NODE_NAME, pips_assert, store_new_host_node_variable(), store_new_host_variable(), store_new_node_variable(), strdup(), and update_functional_as_model.

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeCodeForHpfc()

void NormalizeCodeForHpfc

(

statement

s

)

reference test

function call test

test condition test

range test

whileloop test

Definition at line 848 of file compile.c.

{
    extract_distributed_non_constant_terms(s);
    normalize_all_expressions_of(s);
    atomize_as_required(s, 
                        hpfc_decision,      /* reference test */
                        (bool(*)(call,expression)) gen_false2,          /* function call test */
                        (bool(*)(test,expression)) test_atomization,/* test condition test */
                        (bool(*)(range,expression)) gen_false2,          /* range test */
                        (bool(*)(whileloop,expression)) gen_false2,          /* whileloop test */
                        hpfc_new_variable);
}

References atomize_as_required(), extract_distributed_non_constant_terms(), gen_false2(), hpfc_decision(), hpfc_new_variable(), normalize_all_expressions_of(), and test_atomization().

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

NormalizeCommonVariables()

void NormalizeCommonVariables	(	entity	module,
		statement	stat
	)

the new entities for the common variables are created and inserted in the common. The declarations are updated.

the references within the program are updated with the new entities

Parameters

module	odule
stat	tat

Definition at line 940 of file compile.c.

{
    list ldecl = code_declarations(entity_code(module)), lnewdecl = NIL, ltmp;
    entity common, new_e;
 
    /* the new entities for the common variables are created and
     * inserted in the common. The declarations are updated.
     */
    MAP(ENTITY, e,
    {
        if (entity_in_common_p(e))
        {
            common = ram_section(storage_ram(entity_storage(e)));
            new_e = AddEntityToModule(e, common);
            ltmp = area_layout(type_area(entity_type(common)));
            
            if (gen_find_eq(new_e, ltmp)==entity_undefined)
                gen_insert_after(new_e, e, ltmp);
            
            lnewdecl = CONS(ENTITY, new_e, lnewdecl);
            store_entity_update_common(e, new_e);
            
            pips_debug(8, "module %s: %s -> %s\n",
                  entity_name(module), entity_name(e), entity_name(new_e));
        }
        else
            lnewdecl = CONS(ENTITY, e, lnewdecl);
    },
        ldecl);
 
    gen_free_list(ldecl);
    code_declarations(entity_code(module)) = lnewdecl;
 
    /* the references within the program are updated with the new entities
     */
    update_common_references_in_obj(stat);
}

References AddEntityToModule(), area_layout, code_declarations, CONS, ENTITY, entity_code(), entity_in_common_p(), entity_name, entity_storage, entity_type, entity_undefined, gen_find_eq(), gen_free_list(), gen_insert_after(), MAP, module, NIL, pips_debug, ram_section, storage_ram, store_entity_update_common(), type_area, and update_common_references_in_obj().

Referenced by hpfc_directives_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

old_name()

static const char* old_name ( entity  module, entity  obj  )

static

old name of obj while in module now.

obj

Parameters

obj	module in which obj appears

Definition at line 354 of file compile.c.

{
    return module_local_name
        (module==host_module ? load_old_host(obj) : load_old_node(obj));
}

References host_module, load_old_host(), load_old_node(), module, and module_local_name().

Referenced by hpfc_head_hook(), make_new_index_entity(), and make_tile_index_entity_n().

Here is the call graph for this function:

Here is the caller graph for this function:

put_generated_resources_for_common()

void put_generated_resources_for_common

(

entity

common

)

Parameters

common

ommon

Definition at line 417 of file compile.c.

{
    FILE *host_file, *node_file, *parm_file, *init_file;
    string host_name, node_name, parm_name, init_name, dir_name;
    entity node_common, host_common;
 
    node_common = load_new_node(common),
    host_common = load_new_host(common);
    const char *prefix = module_local_name(common);
    dir_name = db_get_current_workspace_directory();
    
    host_name = src(prefix, HINC_SUFFIX);
    node_name = src(prefix, NINC_SUFFIX);
    parm_name = src(prefix, PARM_SUFFIX);
    init_name = src(prefix, INIT_SUFFIX);
 
    host_file = hpfc_fopen(full_name(dir_name, host_name));
    hpfc_print_common(host_file, host_module, host_common);
    hpfc_fclose(host_file, host_name);
 
    node_file = hpfc_fopen(full_name(dir_name, node_name));
    hpfc_print_common(node_file, node_module, node_common);
    hpfc_fclose(node_file, node_name);
 
    parm_file = hpfc_fopen(full_name(dir_name, parm_name));
    create_parameters_h(parm_file, common);
    hpfc_fclose(parm_file, parm_name);
 
    init_file = hpfc_fopen(full_name(dir_name, init_name));
    create_init_common_param_for_arrays(init_file, common);
    hpfc_fclose(init_file, init_name);
 
    ifdebug(1)
    {
        fprintf(stderr, "Result of HPFC for common %s\n", entity_name(common));
        fprintf(stderr, "-----------------\n");
 
        hpfc_print_file(parm_name);
        hpfc_print_file(init_name);
        hpfc_print_file(host_name);
        hpfc_print_file(node_name);
    }
 
    free(parm_name),
    free(init_name),
    free(host_name),
    free(node_name);
}

References create_init_common_param_for_arrays(), create_parameters_h(), db_get_current_workspace_directory(), entity_name, fprintf(), free(), full_name, HINC_SUFFIX, host_module, hpfc_fclose(), hpfc_fopen(), hpfc_print_common(), hpfc_print_file(), ifdebug, INIT_SUFFIX, load_new_host(), load_new_node(), module_local_name(), NINC_SUFFIX, node_module, PARM_SUFFIX, prefix, and src.

Referenced by compile_common().

Here is the call graph for this function:

Here is the caller graph for this function:

put_generated_resources_for_module()

void put_generated_resources_for_module	(	_UNUSED_ statement	stat,
		statement	host_stat,
		statement	node_stat
	)

Definition at line 516 of file compile.c.

{
    FILE *host_file, *node_file, *parm_file, *init_file;
    entity module = get_current_module_entity();
    string host_name, node_name, parm_name, init_name, dir_name;
    
    const char *prefix = module_local_name(module);
    dir_name = db_get_current_workspace_directory();
 
    host_name = src(prefix, HOST_SUFFIX);
    host_file = hpfc_fopen(full_name(dir_name, host_name));
    hpfc_print_code(host_file, host_module, host_stat);
    hpfc_fclose(host_file, host_name);
 
    node_name = src(prefix, NODE_SUFFIX);
    node_file = hpfc_fopen(full_name(dir_name, node_name));
    hpfc_print_code(node_file, node_module, node_stat);
    hpfc_fclose(node_file, node_name);
 
    parm_name = src(prefix, PARM_SUFFIX);
    parm_file = hpfc_fopen(full_name(dir_name, parm_name));
    create_parameters_h(parm_file, module);
    hpfc_fclose(parm_file, parm_name);
 
    init_name = src(prefix, INIT_SUFFIX);
    init_file = hpfc_fopen(full_name(dir_name, init_name));
    create_init_common_param_for_arrays(init_file, module);
    hpfc_fclose(init_file, init_name);
 
    ifdebug(1)
    {
        fprintf(stderr, "Result of HPFC for module %s:\n", 
                module_local_name(module));
        fprintf(stderr, "-----------------\n");
 
        hpfc_print_file(parm_name);
        hpfc_print_file(init_name);
        hpfc_print_file(host_name);
        hpfc_print_file(node_name);
    }
 
    DB_PUT_FILE_RESOURCE(DBR_HPFC_PARAMETERS, prefix, parm_name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_HOST, prefix, host_name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_NODE, prefix, node_name);
    DB_PUT_FILE_RESOURCE(DBR_HPFC_RTINIT, prefix, init_name);
}

References create_init_common_param_for_arrays(), create_parameters_h(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, fprintf(), full_name, get_current_module_entity(), host_module, HOST_SUFFIX, hpfc_fclose(), hpfc_fopen(), hpfc_print_code(), hpfc_print_file(), ifdebug, INIT_SUFFIX, module, module_local_name(), node_module, NODE_SUFFIX, PARM_SUFFIX, prefix, and src.

Referenced by compile_module().

Here is the call graph for this function:

Here is the caller graph for this function:

put_generated_resources_for_program()

void put_generated_resources_for_program

(

_UNUSED_ string

program_name

)

Definition at line 567 of file compile.c.

{
    FILE *comm_file, *init_file;
    string comm, init, dir_name;
 
    dir_name = db_get_current_workspace_directory();
 
    comm = src(GLOBAL_PARAMETERS_H, "");
    init = src(GLOBAL_INIT_H, "");
 
    comm_file = hpfc_fopen(full_name(dir_name, comm));
    create_common_parameters_h(comm_file);
    hpfc_fclose(comm_file, comm);
 
    init_file = hpfc_fopen(full_name(dir_name, init));
    create_init_common_param(init_file);
    hpfc_fclose(init_file, init);
    
    ifdebug(1)
    {
        fprintf(stderr, "Results of HPFC for the program\n");
        fprintf(stderr, "-----------------\n");
 
        hpfc_print_file(comm);
        hpfc_print_file(init);
    }
 
    free(comm);
    free(init);
}

References create_common_parameters_h(), create_init_common_param(), db_get_current_workspace_directory(), fprintf(), free(), full_name, GLOBAL_INIT_H, GLOBAL_PARAMETERS_H, hpfc_fclose(), hpfc_fopen(), hpfc_print_file(), ifdebug, init, and src.

Referenced by hpfc_close().

Here is the call graph for this function:

Here is the caller graph for this function:

substitute_and_create()

static void substitute_and_create ( statement  s, entity  v, expression  e  )

static

the copy is reused!

Definition at line 739 of file compile.c.

{
    instruction i;
 
    ifdebug(3) {
        pips_debug(3, "variable %s substituted for\n", entity_name(v));
        print_expression(e);
    }
 
    subs_v = v;
    subs_e = copy_expression(e);
 
    subs_pv = expression_linear_p(e)?
        vect_dup(normalized_linear(expression_normalized(e))):
        (Pvecteur) NULL;
    
    gen_recurse(s, expression_domain, expression_flt, gen_null);
    
    vect_rm(subs_pv), subs_pv=(Pvecteur)NULL;
 
    i = loop_to_instruction
        (make_loop(v, 
                   make_range(copy_expression(subs_e),
                              subs_e, /* the copy is reused! */
                              int_to_expression(1)),
                   instruction_to_statement(statement_instruction(s)),
                   entity_empty_label(),
                   make_execution(is_execution_parallel, UU),
                   NIL));
 
    statement_instruction(s) = i;
}

References copy_expression(), entity_empty_label(), entity_name, expression_domain, expression_flt(), expression_linear_p(), expression_normalized, gen_null(), gen_recurse, ifdebug, instruction_to_statement(), int_to_expression(), is_execution_parallel, loop_to_instruction, make_execution(), make_loop(), make_range(), NIL, normalized_linear, pips_debug, print_expression(), statement_instruction, subs_e, subs_pv, subs_v, UU, vect_dup(), and vect_rm().

Referenced by loop_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

test_atomization()

static bool test_atomization ( test  t, _UNUSED_ expression  e  )

static

Definition at line 841 of file compile.c.

{
  return ref_to_dist_array_p(t);
}

References ref_to_dist_array_p().

Referenced by NormalizeCodeForHpfc().

Here is the call graph for this function:

Here is the caller graph for this function:

update_common_references_in_obj()

void update_common_references_in_obj

(

void *

obj

)

Parameters

obj

bj

Definition at line 911 of file compile.c.

{
    gen_multi_recurse(obj,
                      loop_domain, gen_true, update_loop_rewrite,
                      reference_domain, gen_true, update_common_rewrite,
                      NULL);
 
    ifdebug(8) debug_print_referenced_entities(obj);
}

References debug_print_referenced_entities(), gen_multi_recurse(), gen_true(), ifdebug, loop_domain, reference_domain, update_common_rewrite(), and update_loop_rewrite().

Referenced by NormalizeCommonVariables().

Here is the call graph for this function:

Here is the caller graph for this function:

update_common_references_in_regions()

void update_common_references_in_regions

(

void

)

Definition at line 921 of file compile.c.

{
 
    STATEMENT_EFFECTS_MAP(stat, effs,
         {
             list lef = effects_effects(effs);
 
             pips_debug(3, "statement %p (%zu effects)\n",
                        stat, gen_length((list) lef));
 
             // FI: Let's hope the rw effects do not have to be
             // filtered to keep only the store effects...
             MAP(EFFECT, e, update_common_rewrite(effect_any_reference(e)),
                 (list) lef);
         },
             get_rw_effects());
}

References EFFECT, effect_any_reference, effects_effects, gen_length(), get_rw_effects(), MAP, pips_debug, STATEMENT_EFFECTS_MAP, and update_common_rewrite().

Here is the call graph for this function:

update_common_rewrite()

static void update_common_rewrite ( reference  r )

static

To manage the common entities, I decided arbitrarilly that all commons will have to be declared exactly the same way (name and so), so I can safely unify the entities among the modules.

The rational for this stupid ugly transformation is that it is much easier to manage the common overlaps for instance if they are simply linked to the same entity.

??? very ugly, indeed.

Definition at line 875 of file compile.c.

{
    entity var = reference_variable(r),
        new_var = load_entity_update_common(var);
 
    pips_debug(7, "%s to %s\n", entity_name(var), 
          entity_undefined_p(new_var) ? "undefined" : entity_name(new_var));
 
    if (!entity_undefined_p(new_var))
        reference_variable(r) = new_var;    
}

References entity_name, entity_undefined_p, load_entity_update_common(), pips_debug, and reference_variable.

Referenced by update_common_references_in_obj(), and update_common_references_in_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

update_loop_rewrite()

static void update_loop_rewrite ( loop  l )

static

Definition at line 887 of file compile.c.

{
     entity var = loop_index(l),
        new_var = load_entity_update_common(var);
 
    if (!entity_undefined_p(new_var))
        loop_index(l) = new_var;       
}

References entity_undefined_p, load_entity_update_common(), and loop_index.

Referenced by update_common_references_in_obj().

Here is the call graph for this function:

Here is the caller graph for this function:

vect_in_p()

static bool vect_in_p ( Pvecteur  vin, Pvecteur  vref  )

static

returns if vin is in vref

Definition at line 691 of file compile.c.

{
    Pvecteur v;
 
    for (v=vin; v; v=v->succ)
    {
        Variable x = vecteur_var(v);
        if (x)
        {
            if (value_ne(vecteur_val(v),vect_coeff(x, vref)))
                return false;
        }
    }
 
    return true;
}

References Svecteur::succ, value_ne, vect_coeff(), vecteur_val, vecteur_var, and x.

Referenced by expression_flt().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

subs_e

expression subs_e

static

Definition at line 686 of file compile.c.

Referenced by expression_flt(), and substitute_and_create().

subs_pv

Pvecteur subs_pv

static

Definition at line 687 of file compile.c.

Referenced by expression_flt(), and substitute_and_create().

subs_v

entity subs_v

static

substitute all occurences of expression e in statement s by variable v

Definition at line 685 of file compile.c.

Referenced by expression_flt(), and substitute_and_create().