9 #include "pips_config.h"
18 #define STEP_RT_INTEGER4 DEFAULT_INTEGER_TYPE_SIZE
19 #define STEP_RT_INTEGER8 DEFAULT_LONG_LONG_INTEGER_TYPE_SIZE
21 #define STEP_RT_SYMBOLIC_INTEGER STEP_RT_INTEGER4
22 #define STEP_RT_ARRAY_INDEX_INTEGER STEP_RT_INTEGER4
23 #define STEP_RT_LOOP_INDEX_INTEGER STEP_RT_INTEGER4
158 return get_bounds_stmt;
178 pips_debug(1,
"begin new_module = %p, loop_stmt = %p\n", new_module, loop_stmt);
288 string name =
strdup(name_);
389 string name =
strdup(name_);
396 pips_debug(2,
"create entity VERIFIER CE MESSAGE\n");
433 string name =
strdup(region_array_name);
441 expr_nb_region,
NIL),
690 "\nC 3 communication shemes for all-to-all personalized broadcast :",
691 "\nC STEP_NONBLOCKING, STEP_BLOCKING1 and STEP_BLOCKING2.\n",NULL));
712 else if(is_interlaced)
725 statmt =
call_STEP_subroutine2(subroutine, expr_user_array, expr_nb_workchunk, expr_regions_array, NULL);
791 va_start (va_args, name);
792 e = va_arg(va_args,
entity);
803 e = va_arg(va_args,
entity);
829 va_start (va_args, name);
831 while (expr != NULL) {
847 entity step_symbolic_type;
861 pips_debug(1,
"name = %s, arg = %p\n", name, args);
float a2sf[2] __attribute__((aligned(16)))
USER generates a user error (i.e., non fatal) by printing the given MSG according to the FMT.
instruction make_instruction_loop(loop _field_)
basic make_basic_typedef(entity _field_)
value make_value_expression(expression _field_)
loop make_loop(entity a1, range a2, statement a3, entity a4, execution a5, list a6)
storage make_storage_rom(void)
basic make_basic_int(intptr_t _field_)
ram make_ram(entity a1, entity a2, intptr_t a3, list a4)
basic make_basic_pointer(type _field_)
expression copy_expression(expression p)
EXPRESSION.
dimension make_dimension(expression a1, expression a2, list a3)
execution make_execution_sequential(void)
variable make_variable(basic a1, list a2, list a3)
void free_storage(storage p)
storage make_storage_ram(ram _field_)
qualifier make_qualifier_const(void)
type make_type(enum type_utype tag, void *val)
range make_range(expression a1, expression a2, expression a3)
#define STEP_INTEGER2_NAME
#define RT_STEP_get_loopbounds
#define STEP_LOOPSLICES_NAME(index)
#define STEP_COMPLEX16_NAME
#define STEP_COMPLEX8_NAME
#define STEP_TAG_DEFAULT_NAME
#define STEP_MAX_NB_LOOPSLICES_NAME
#define STEP_INTEGER1_NAME
#define STEP_BOUNDS_UP(index)
#define STEP_SLICE_INDEX_NAME
#define RT_STEP_set_sendregions
#define STEP_COMM_RANK_NAME
#define RT_STEP_set_recvregions
#define RT_STEP_compute_loopslices
#define RT_STEP_set_interlaced_sendregions
#define RT_STEP_set_reduction_sendregions
#define RT_STEP_register_alltoall_partial
#define RT_STEP_alltoall_full_interlaced
Runtime MACRO (end)
#define STEP_NBLOCKING_ALG_NAME
#define RT_STEP_alltoall_partial_interlaced
#define STEP_INDEX_SLICE_LOW_NAME
#define STEP_INDEX_SLICE_UP_NAME
#define STEP_INTEGER8_NAME
#define STEP_INTEGER4_NAME
#define STEP_BOUNDS_LOW(index)
#define STEP_COMM_SIZE_NAME
In Runtime/step/STEP.h.
#define RT_STEP_init_arrayregions
#define RT_STEP_get_commsize
#define RT_STEP_alltoall_full
#define RT_STEP_construct_end
#define RT_STEP_construct_begin
entity get_top_level_entity(void)
void put_new_typedef(const char *)
This function is used by libraries "step"* and "task_parallelization".
statement build_call_STEP_set_recvregions(entity user_array, expression expr_nb_workchunk, entity regions_array)
statement generate_call_get_rank(entity new_module)
expression step_symbolic_expression(string name, entity module)
entity step_parameter(string name_, entity module, expression expr)
void generate_call_flush(statement *stepalltoall_stmt)
statement build_call_STEP_init_regionArray(entity array)
void step_RT_set_local_declarations(entity module, statement body)
entity step_local_regionArray(entity module, entity array, string region_array_name, expression expr_nb_region)
static void step_add_created_symbolic(entity e)
statement call_STEP_subroutine3(string name,...)
void check_entity_step_type(entity data)
void generate_call_construct_begin_construct_end(entity new_module, step_directive drt, statement mpi_begin_stmt, statement mpi_end_stmt)
entity get_entity_step_commsize(entity module)
Que signifie local?
static expression cast_STEP_ARG(expression expr, bool ptr)
statement build_call_STEP_WaitAll(list comm_stmt)
#define STEP_RT_LOOP_INDEX_INTEGER
expression get_expression_addr(expression expr)
compile_RT.c
statement generate_call_get_commsize(entity new_module)
#define STEP_RT_ARRAY_INDEX_INTEGER
void generate_call_get_workchunk_loopbounds(entity mpi_module, loop loop_stmt, statement *compute_regions_stmt)
static entity step_local_RT_Integer(int size_of_integer, entity mpi_module, string name_, list dims)
void set_RT_add_local(entity e)
statement build_call_STEP_set_sendregions(entity user_array, expression expr_nb_workchunk, entity regions_array, bool is_interlaced, bool is_reduction)
#define STEP_RT_SYMBOLIC_INTEGER
statement call_STEP_subroutine2(string name,...)
statement generate_call_get_rank_loopbounds(entity new_module, loop loop_stmt)
set step_created_symbolic
entity step_symbolic(string name, entity module)
statement build_call_STEP_flush()
statement call_STEP_subroutine(string name, list args, entity data)
void generate_call_init_regionArray(list referenced_entities, statement before, statement __attribute__((unused)) after)
entity step_local_slice_index(entity module)
entity step_local_loop_index(entity module, string name)
void step_RT_clean_local()
entity step_local_loopSlices(entity module, entity i)
entity get_entity_step_rank(entity module)
statement build_call_STEP_AllToAll(entity module, entity array, bool is_partial, bool is_interlaced)
void generate_loop_workchunk(entity mpi_module, statement *compute_regions_stmt)
expression step_function(string name, list args)
entity step_type(entity data)
static list local_declaration
statement generate_call_compute_loopslices(entity new_module, loop loop_stmt)
entity MakeConstant(string name, tag bt)
Make a Fortran constant.
string compilation_unit_of_module(const char *)
The output is undefined if the module is referenced but not defined in the workspace,...
static void comment(string_buffer code, spoc_hardware_type hw, dagvtx v, int stage, int side, bool flip)
statement make_block_statement(list)
Make a block statement from a list of statement.
statement instruction_to_statement(instruction)
Build a statement from a give instruction.
statement make_empty_block_statement(void)
Build an empty statement (block/sequence)
const char * get_current_module_name(void)
Get the name of the current module.
entity get_current_module_entity(void)
Get the entity of the current module.
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
#define NIL
The empty list (nil in Lisp)
size_t gen_length(const list l)
#define CONS(_t_, _i_, _l_)
List element cell constructor (insert an element at the beginning of a list)
list gen_nconc(list cp1, list cp2)
physically concatenates CP1 and CP2 but do not duplicates the elements
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
list statement_block(statement)
Get the list of block statements of a statement sequence.
void put_a_comment_on_a_statement(statement, string)
Similar to try_to_put_a_comment_on_a_statement() but insert a CONTINUE to put the comment on it if th...
statement make_call_statement(string, list, entity, string)
This function is limited to intrinsics calls...
void insert_statement(statement, statement, bool)
This is the normal entry point.
statement make_continue_statement(entity)
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define DYNAMIC_AREA_LOCAL_NAME
#define TOP_LEVEL_MODULE_NAME
Module containing the global variables in Fortran and C.
#define STATIC_AREA_LOCAL_NAME
#define MODULE_SEP_STRING
string concatenate(const char *,...)
Return the concatenation of the given strings.
void * gen_find_tabulated(const char *, int)
#define SET_FOREACH(type_name, the_item, the_set)
enumerate set elements in their internal order.
set set_clear(set)
Assign the empty set to s s := {}.
#define set_undefined_p(s)
set set_make(set_type)
Create an empty set of any type but hash_private.
set set_add_element(set, const set, const void *)
#define string_undefined_p(s)
#define PLUS_OPERATOR_NAME
#define entity_symbolic_p(e)
#define ADDRESS_OF_OPERATOR_NAME
#define entity_variable_p(e)
An entity_variable_p(e) may hide a typedef and hence a functional type.
#define MINUS_C_OPERATOR_NAME
const char * entity_user_name(entity e)
Since entity_local_name may contain PIPS special characters such as prefixes (label,...
entity FindOrCreateEntity(const char *package, const char *local_name)
Problem: A functional global entity may be referenced without parenthesis or CALL keyword in a functi...
entity entity_empty_label(void)
bool fortran_module_p(entity m)
Test if a module is in Fortran.
entity CreateIntrinsic(string name)
this function does not create an intrinsic function because they must all be created beforehand by th...
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
expression make_call_expression(entity e, list l)
Build an expression that call an function entity with an argument list.
expression entity_to_expression(entity e)
if v is a constant, returns a constant call.
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
expression make_op_exp(char *op_name, expression exp1, expression exp2)
================================================================
bool unbounded_dimension_p(dimension dim)
bool unbounded_dimension_p(dim) input : a dimension of an array entity.
expression MakeCastExpression(type t, expression e)
expression MakeUnaryCall(entity f, expression a)
Creates a call expression to a function with one argument.
void AddLocalEntityToDeclarations(entity, entity, statement)
Add the variable entity e to the list of variables of the function module.
bool entity_scalar_p(entity)
The concrete type of e is a scalar type.
int add_C_variable_to_area(entity, entity)
int NumberOfDimension(entity)
int add_variable_to_area(entity, entity)
type MakeTypeVariable(basic, cons *)
BEGIN_EOLE.
#define type_functional_p(x)
#define QUALIFIER(x)
QUALIFIER.
#define dimension_lower(x)
#define entity_storage(x)
#define range_increment(x)
#define EXPRESSION(x)
EXPRESSION.
#define type_undefined_p(x)
#define entity_undefined_p(x)
#define expression_undefined
#define dimension_upper(x)
#define expression_undefined_p(x)
#define variable_dimensions(x)
#define type_variable_p(x)
#define storage_undefined_p(x)
#define entity_domain
newgen_syntax_domain_defined
#define variable_basic(x)
#define STATEMENT(x)
STATEMENT.
#define storage_undefined
#define entity_initial(x)
#define STEP_DEBUG_STATEMENT(D, W, S)
void get_step_directive_name(step_directive drt, string *directive_txt)
Warning! Do not modify this file that is automatically generated!
FI: I do not understand why the type is duplicated at the set level.
The structure used to build lists in NewGen.
entity MakeParameter(entity e, expression x)
lint
void AddEntityToModuleCompilationUnit(entity e, entity module)