compile_RT.c File Reference

#include <stdarg.h>
#include "defines-local.h"
#include "syntax.h"
#include "c_syntax.h"
#include "workspace-util.h"
#include "prettyprint.h"

Include dependency graph for compile_RT.c:

Go to the source code of this file.

Macros
#define	STEP_RT_INTEGER4   DEFAULT_INTEGER_TYPE_SIZE
#define	STEP_RT_INTEGER8   DEFAULT_LONG_LONG_INTEGER_TYPE_SIZE
#define	STEP_RT_SYMBOLIC_INTEGER   STEP_RT_INTEGER4
#define	STEP_RT_ARRAY_INDEX_INTEGER   STEP_RT_INTEGER4
#define	STEP_RT_LOOP_INDEX_INTEGER   STEP_RT_INTEGER4

Functions
expression	get_expression_addr (expression expr)
	compile_RT.c More...
static expression	cast_STEP_ARG (expression expr, bool ptr)
void	generate_call_construct_begin_construct_end (entity new_module, step_directive drt, statement mpi_begin_stmt, statement mpi_end_stmt)
void	generate_call_flush (statement *stepalltoall_stmt)
void	generate_loop_workchunk (entity mpi_module, statement *compute_regions_stmt)
void	generate_call_get_workchunk_loopbounds (entity mpi_module, loop loop_stmt, statement *compute_regions_stmt)
statement	generate_call_get_rank_loopbounds (entity new_module, loop loop_stmt)
statement	generate_call_get_rank (entity new_module)
statement	generate_call_compute_loopslices (entity new_module, loop loop_stmt)
statement	generate_call_get_commsize (entity new_module)
void	generate_call_init_regionArray (list referenced_entities, statement before, statement __attribute__((unused)) after)
void	set_RT_add_local (entity e)
void	step_RT_clean_local ()
static void	step_add_created_symbolic (entity e)
entity	step_parameter (string name_, entity module, expression expr)
entity	step_symbolic (string name, entity module)
expression	step_symbolic_expression (string name, entity module)
expression	step_function (string name, list args)
void	step_RT_set_local_declarations (entity module, statement body)
static entity	step_local_RT_Integer (int size_of_integer, entity mpi_module, string name_, list dims)
entity	step_local_regionArray (entity module, entity array, string region_array_name, expression expr_nb_region)
entity	step_local_slice_index (entity module)
entity	step_local_loopSlices (entity module, entity i)
entity	get_entity_step_rank (entity module)
entity	get_entity_step_commsize (entity module)
	Que signifie local? More...
entity	step_local_loop_index (entity module, string name)
entity	step_type (entity data)
statement	build_call_STEP_init_regionArray (entity array)
statement	build_call_STEP_AllToAll (entity module, entity array, bool is_partial, bool is_interlaced)
statement	build_call_STEP_WaitAll (list comm_stmt)
statement	build_call_STEP_set_sendregions (entity user_array, expression expr_nb_workchunk, entity regions_array, bool is_interlaced, bool is_reduction)
statement	build_call_STEP_set_recvregions (entity user_array, expression expr_nb_workchunk, entity regions_array)
statement	build_call_STEP_flush ()
statement	call_STEP_subroutine3 (string name,...)
statement	call_STEP_subroutine2 (string name,...)
void	check_entity_step_type (entity data)
statement	call_STEP_subroutine (string name, list args, entity data)

Variables
set	step_created_entity = set_undefined
set	step_created_symbolic = set_undefined
static list	local_declaration = NIL

Macro Definition Documentation

STEP_RT_ARRAY_INDEX_INTEGER

#define STEP_RT_ARRAY_INDEX_INTEGER   STEP_RT_INTEGER4

Definition at line 22 of file compile_RT.c.

STEP_RT_INTEGER4

#define STEP_RT_INTEGER4   DEFAULT_INTEGER_TYPE_SIZE

Definition at line 18 of file compile_RT.c.

STEP_RT_INTEGER8

#define STEP_RT_INTEGER8   DEFAULT_LONG_LONG_INTEGER_TYPE_SIZE

Definition at line 19 of file compile_RT.c.

STEP_RT_LOOP_INDEX_INTEGER

#define STEP_RT_LOOP_INDEX_INTEGER   STEP_RT_INTEGER4

Definition at line 23 of file compile_RT.c.

STEP_RT_SYMBOLIC_INTEGER

#define STEP_RT_SYMBOLIC_INTEGER   STEP_RT_INTEGER4

Definition at line 21 of file compile_RT.c.

Function Documentation

build_call_STEP_AllToAll()

statement build_call_STEP_AllToAll	(	entity	module,
		entity	array,
		bool	is_partial,
		bool	is_interlaced
	)

Pourquoi register ?

Full communications

Parameters

module	odule
array	rray
is_partial	s_partial
is_interlaced	s_interlaced

Definition at line 640 of file compile_RT.c.

{
  statement statmt;
  string subroutine;
 
  if (is_partial)
    {
      /* Pourquoi register ? */
 
      if(is_interlaced)
        subroutine=strdup(RT_STEP_alltoall_partial_interlaced);
      else
        subroutine=strdup(RT_STEP_register_alltoall_partial);
    }
  else
    {
      /* Full communications */
      if(is_interlaced)
        subroutine=strdup(RT_STEP_alltoall_full_interlaced);
      else
        subroutine=strdup(RT_STEP_alltoall_full);
    }
 
  expression expr_array = entity_to_expression(array);
  expression expr_algorithm = step_symbolic_expression(STEP_NBLOCKING_ALG_NAME, module);
  expression expr_tag = step_symbolic_expression(STEP_TAG_DEFAULT_NAME, module);
 
 
  /*
    list args = CONS(EXPRESSION, expr_array,
    CONS(EXPRESSION, expr_algorithm,
    CONS(EXPRESSION, expr_tag, NIL)));
    statmt = make_call_statement(subroutine, args, entity_undefined, string_undefined);
  */
  statmt = call_STEP_subroutine2(subroutine, expr_array, expr_algorithm, expr_tag, NULL);
  
  free(subroutine);
 
  return statmt;
}

References array, call_STEP_subroutine2(), entity_to_expression(), free(), module, RT_STEP_alltoall_full, RT_STEP_alltoall_full_interlaced, RT_STEP_alltoall_partial_interlaced, RT_STEP_register_alltoall_partial, STEP_NBLOCKING_ALG_NAME, step_symbolic_expression(), STEP_TAG_DEFAULT_NAME, and strdup().

Referenced by generate_call_stepalltoall().

Here is the call graph for this function:

Here is the caller graph for this function:

build_call_STEP_flush()

statement build_call_STEP_flush

(

void

)

Definition at line 758 of file compile_RT.c.

{
  return call_STEP_subroutine2(RT_STEP_flush, NULL);
}

References call_STEP_subroutine2(), and RT_STEP_flush.

Referenced by generate_call_flush().

Here is the call graph for this function:

Here is the caller graph for this function:

build_call_STEP_init_regionArray()

statement build_call_STEP_init_regionArray

(

entity

array

)

Parameters

array

rray

Definition at line 600 of file compile_RT.c.

{
  pips_debug(1, "begin\n");
 
  type t = entity_type(array);
  list dims = variable_dimensions(type_variable(t));
 
  expression expr_array = entity_to_expression(array);
  expression expr_type = entity_to_expression(step_type(array));
 
  expression expr_dims = int_to_expression(gen_length(dims));
 
  list args = CONS(EXPRESSION, expr_dims,
                   CONS(EXPRESSION, expr_type,
                        CONS(EXPRESSION, expr_array, NIL)));
 
  FOREACH(DIMENSION, bounds_d, dims)
    {
      if(unbounded_dimension_p(bounds_d))
        {
          pips_debug(0, "Unbounded dimension for array : %s\n", entity_name(array));
          pips_assert("bounded dimension", 0);
        }
      expression bounds_lower = copy_expression(dimension_lower(bounds_d));
      expression bounds_upper = copy_expression(dimension_upper(bounds_d));
      args = CONS(EXPRESSION, bounds_upper,
                  CONS(EXPRESSION, bounds_lower, args));
    }
 
  statement statmt = make_call_statement(RT_STEP_init_arrayregions, gen_nreverse(args), entity_undefined, string_undefined);
  pips_debug(1, "end\n");
  return statmt;
}

References array, CONS, copy_expression(), DIMENSION, dimension_lower, dimension_upper, entity_name, entity_to_expression(), entity_type, entity_undefined, EXPRESSION, FOREACH, gen_length(), gen_nreverse(), int_to_expression(), make_call_statement(), NIL, pips_assert, pips_debug, RT_STEP_init_arrayregions, step_type(), string_undefined, type_variable, unbounded_dimension_p(), and variable_dimensions.

Referenced by generate_call_init_regionArray().

Here is the call graph for this function:

Here is the caller graph for this function:

build_call_STEP_set_recvregions()

statement build_call_STEP_set_recvregions	(	entity	user_array,
		expression	expr_nb_workchunk,
		entity	regions_array
	)

Parameters

user_array	ser_array
expr_nb_workchunk	xpr_nb_workchunk
regions_array	egions_array

Definition at line 736 of file compile_RT.c.

{
  statement statmt;
 
  pips_debug(1, "begin\n");
 
  expression expr_user_array = entity_to_expression(user_array);
  expression expr_regions_array = cast_STEP_ARG(entity_to_expression(regions_array), true);
 
  statmt = call_STEP_subroutine2(RT_STEP_set_recvregions, expr_user_array, expr_nb_workchunk, expr_regions_array, NULL);
 
  /*
  list args = CONS(EXPRESSION, expr_user_array,
                   CONS(EXPRESSION, expr_nb_workchunk,
                        CONS(EXPRESSION, expr_regions_array, NIL)));
  statmt = make_call_statement(RT_STEP_set_recvregions, args, entity_undefined, string_undefined);
  */
 
  pips_debug(1, "end\n");
  return statmt;
}

References call_STEP_subroutine2(), cast_STEP_ARG(), entity_to_expression(), pips_debug, and RT_STEP_set_recvregions.

Referenced by generate_call_set_regionarray().

Here is the call graph for this function:

Here is the caller graph for this function:

build_call_STEP_set_sendregions()

statement build_call_STEP_set_sendregions	(	entity	user_array,
		expression	expr_nb_workchunk,
		entity	regions_array,
		bool	is_interlaced,
		bool	is_reduction
	)

Parameters

user_array	ser_array
expr_nb_workchunk	xpr_nb_workchunk
regions_array	egions_array
is_interlaced	s_interlaced
is_reduction	s_reduction

Definition at line 701 of file compile_RT.c.

{
  statement statmt;
  string subroutine;
 
  pips_debug(1, "begin\n");
  expression expr_user_array = entity_to_expression(user_array);
  expression expr_regions_array = cast_STEP_ARG(entity_to_expression(regions_array), true);
 
  if (is_reduction)
    subroutine = strdup(RT_STEP_set_reduction_sendregions);
  else  if(is_interlaced)
    subroutine = strdup(RT_STEP_set_interlaced_sendregions);
  else
    subroutine = strdup(RT_STEP_set_sendregions);
 
  /*
  list args = CONS(EXPRESSION, expr_user_array,
                   CONS(EXPRESSION, expr_nb_workchunk,
                        CONS(EXPRESSION, expr_regions,NIL)));
 
  statmt = make_call_statement(subroutine, args, entity_undefined, string_undefined);
  */
 
  statmt = call_STEP_subroutine2(subroutine, expr_user_array, expr_nb_workchunk, expr_regions_array, NULL);
 
  free(subroutine);
  pips_debug(1, "end\n");
  return statmt;
}

References call_STEP_subroutine2(), cast_STEP_ARG(), entity_to_expression(), free(), pips_debug, RT_STEP_set_interlaced_sendregions, RT_STEP_set_reduction_sendregions, RT_STEP_set_sendregions, and strdup().

Referenced by generate_call_set_regionarray().

Here is the call graph for this function:

Here is the caller graph for this function:

build_call_STEP_WaitAll()

statement build_call_STEP_WaitAll

(

list

comm_stmt

)

Parameters

comm_stmt

omm_stmt

Definition at line 681 of file compile_RT.c.

{
  if(ENDP(comm_stmt))
    return make_continue_statement(entity_undefined);
  else
    {
      statement block = make_block_statement(gen_nconc(comm_stmt,
                                                       CONS(STATEMENT, call_STEP_subroutine2(RT_STEP_flush, NULL), NIL)));
      string comment = strdup(concatenate("\nC     Communicating data to other nodes",
                                          "\nC     3 communication shemes for all-to-all personalized broadcast :",
                                          "\nC     STEP_NONBLOCKING, STEP_BLOCKING1 and STEP_BLOCKING2.\n",NULL));
      put_a_comment_on_a_statement(block, comment);
      return block;
    }
}

References call_STEP_subroutine2(), comment(), concatenate(), CONS, ENDP, entity_undefined, gen_nconc(), make_block_statement(), make_continue_statement(), NIL, put_a_comment_on_a_statement(), RT_STEP_flush, STATEMENT, and strdup().

Here is the call graph for this function:

call_STEP_subroutine()

statement call_STEP_subroutine	(	string	name,
		list	args,
		entity	data
	)

Parameters

name	ame
args	rgs

Definition at line 857 of file compile_RT.c.

{
  statement statmt;
 
  pips_debug(1, "name = %s, arg = %p\n", name, args);
  if(!entity_undefined_p(data))
    {
      entity step_symbolic_type = step_type(data);
      pips_assert("defined symbolic type", !entity_undefined_p(step_symbolic_type));
      args = gen_nconc(args, CONS(EXPRESSION,entity_to_expression(step_symbolic_type), NIL));
    }
 
  statmt = make_call_statement(name, args, entity_undefined, string_undefined);
 
 
  STEP_DEBUG_STATEMENT(3, "call STEP_subroutine", statmt);
 
  pips_debug(1, "statmt = %p\n", statmt);
  return statmt;
}

References CONS, entity_to_expression(), entity_undefined, entity_undefined_p, EXPRESSION, gen_nconc(), make_call_statement(), NIL, pips_assert, pips_debug, STEP_DEBUG_STATEMENT, step_type(), and string_undefined.

Here is the call graph for this function:

call_STEP_subroutine2()

statement call_STEP_subroutine2	(	string	name,
			...
	)

Parameters

name

ame

Definition at line 819 of file compile_RT.c.

{
  statement statmt;
  va_list va_args;
  list args_l = NIL;
  expression expr;
 
  pips_debug(1, "name = %s\n", name);
 
 
  va_start (va_args, name);
  expr = va_arg(va_args, expression);
  while (expr != NULL) {
    args_l = CONS (EXPRESSION, expr, args_l);
    expr = va_arg(va_args, expression);
  }
  va_end (va_args);
 
  statmt = make_call_statement(name, gen_nreverse(args_l), entity_undefined, string_undefined);
 
  STEP_DEBUG_STATEMENT(3, "call_STEP_subroutine2", statmt);
 
  pips_debug(1, "statmt = %p\n", statmt);
  return statmt;
}

References CONS, entity_undefined, EXPRESSION, gen_nreverse(), make_call_statement(), NIL, pips_debug, STEP_DEBUG_STATEMENT, and string_undefined.

Referenced by build_call_STEP_AllToAll(), build_call_STEP_flush(), build_call_STEP_set_recvregions(), build_call_STEP_set_sendregions(), build_call_STEP_WaitAll(), compile_barrier(), compile_master(), compile_reduction(), generate_call_compute_loopslices(), generate_call_construct_begin_construct_end(), generate_call_get_commsize(), generate_call_get_rank(), generate_call_get_rank_loopbounds(), generate_call_get_workchunk_loopbounds(), and step_compile_analysed_module().

Here is the call graph for this function:

Here is the caller graph for this function:

call_STEP_subroutine3()

statement call_STEP_subroutine3	(	string	name,
			...
	)

Parameters

name

ame

Definition at line 781 of file compile_RT.c.

{
  statement statmt;
  va_list va_args;
  list args_l = NIL;
  entity e;
 
  pips_debug(1, "name = %s\n", name);
 
 
  va_start (va_args, name);
  e = va_arg(va_args, entity);
  while (e != NULL) {
    expression expr;
 
    expr = entity_to_expression(e);
    
    if (type_variable_p(entity_type(e)) && entity_scalar_p(e))
      if (!fortran_module_p(get_current_module_entity()))
        expr = MakeUnaryCall(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME), expr);
 
    args_l = CONS (EXPRESSION, expr, args_l);
    e = va_arg(va_args, entity);
  }
  va_end (va_args);
 
  statmt = make_call_statement(name, gen_nreverse(args_l), entity_undefined, string_undefined);
 
  STEP_DEBUG_STATEMENT(3, "call_STEP_subroutine2", statmt);
 
  pips_debug(1, "statmt = %p\n", statmt);
  return statmt;
}

References ADDRESS_OF_OPERATOR_NAME, CONS, entity_intrinsic(), entity_scalar_p(), entity_to_expression(), entity_type, entity_undefined, EXPRESSION, fortran_module_p(), gen_nreverse(), get_current_module_entity(), make_call_statement(), MakeUnaryCall(), NIL, pips_debug, STEP_DEBUG_STATEMENT, string_undefined, and type_variable_p.

Here is the call graph for this function:

cast_STEP_ARG()

static expression cast_STEP_ARG ( expression  expr, bool  ptr  )

static

Definition at line 40 of file compile_RT.c.

{
  if (fortran_module_p(get_current_module_entity()))
    return expr;
 
  string cu = compilation_unit_of_module(get_current_module_name());
  entity step_arg_e = FindOrCreateEntity(cu, TYPEDEF_PREFIX "STEP_ARG");
 
  if(storage_undefined_p(entity_storage(step_arg_e)))
    {
      entity_storage(step_arg_e) = make_storage_rom();
      put_new_typedef("STEP_ARG");
    }
 
  type step_arg_t = MakeTypeVariable(make_basic_typedef(step_arg_e), NIL);
  if(ptr)
    step_arg_t = MakeTypeVariable(make_basic_pointer(step_arg_t), NIL);
  return MakeCastExpression(step_arg_t, expr);
}

References compilation_unit_of_module(), entity_storage, FindOrCreateEntity(), fortran_module_p(), get_current_module_entity(), get_current_module_name(), make_basic_pointer(), make_basic_typedef(), make_storage_rom(), MakeCastExpression(), MakeTypeVariable(), NIL, put_new_typedef(), storage_undefined_p, and TYPEDEF_PREFIX.

Referenced by build_call_STEP_set_recvregions(), and build_call_STEP_set_sendregions().

Here is the call graph for this function:

Here is the caller graph for this function:

check_entity_step_type()

void check_entity_step_type

(

entity

data

)

Definition at line 845 of file compile_RT.c.

{
  entity step_symbolic_type;
  pips_debug(1, "begin\n");
 
  pips_assert("undefined entity", !entity_undefined_p(data));
  step_symbolic_type = step_type(data);
  pips_assert("defined symbolic type", !entity_undefined_p(step_symbolic_type));
 
  pips_debug(1, "end\n");
}

References entity_undefined_p, pips_assert, pips_debug, and step_type().

Referenced by compile_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_compute_loopslices()

statement generate_call_compute_loopslices	(	entity	new_module,
		loop	loop_stmt
	)

Parameters

new_module	ew_module
loop_stmt	oop_stmt

Definition at line 176 of file compile_RT.c.

{
  pips_debug(1, "begin new_module = %p, loop_stmt = %p\n", new_module, loop_stmt);
  statement stmt;
  /*
    Generation of:
    STEP_COMPUTE_LOOPSLICES(0, 99999, 1, STEP_COMM_SIZE);
  */
  entity commsize = get_entity_step_commsize(new_module);
  expression commsize_expr = entity_to_expression(commsize);
  range r = loop_range(loop_stmt);
 
  stmt = call_STEP_subroutine2(RT_STEP_compute_loopslices, range_lower(r), range_upper(r), range_increment(r), commsize_expr, NULL);
  pips_debug(1, "end\n");
  return stmt;
}

References call_STEP_subroutine2(), entity_to_expression(), get_entity_step_commsize(), loop_range, pips_debug, range_increment, range_lower, range_upper, and RT_STEP_compute_loopslices.

Referenced by compile_loopslices().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_construct_begin_construct_end()

void generate_call_construct_begin_construct_end	(	entity	new_module,
		step_directive	drt,
		statement	mpi_begin_stmt,
		statement	mpi_end_stmt
	)

Parameters

new_module	ew_module
drt	rt
mpi_begin_stmt	pi_begin_stmt
mpi_end_stmt	pi_end_stmt

Definition at line 60 of file compile_RT.c.

{
/*
    Generation of:
    STEP_CONSTRUCT_BEGIN(STEP_DO);
    ...
    STEP_CONSTRUCT_END(STEP_DO);
   */
 
  string directive_txt;
  get_step_directive_name(drt, &directive_txt);
  if(!string_undefined_p(directive_txt))
    {
      statement construct_begin_stmt;
      statement construct_end_stmt;
 
      construct_begin_stmt = call_STEP_subroutine2(RT_STEP_construct_begin, step_symbolic_expression(directive_txt, new_module), NULL);
      insert_statement(mpi_begin_stmt, construct_begin_stmt, true);
 
      construct_end_stmt = call_STEP_subroutine2(RT_STEP_construct_end, step_symbolic_expression(directive_txt, new_module), NULL);
      insert_statement(mpi_end_stmt, construct_end_stmt, false);
      free(directive_txt);
    }
}

References call_STEP_subroutine2(), directive_txt, free(), get_step_directive_name(), insert_statement(), RT_STEP_construct_begin, RT_STEP_construct_end, step_symbolic_expression(), and string_undefined_p.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_flush()

void generate_call_flush

(

statement *

stepalltoall_stmt

)

Parameters

stepalltoall_stmt

tepalltoall_stmt

Definition at line 85 of file compile_RT.c.

{
  pips_debug(1, "begin\n");
  /*
    Generation of
    STEP_FLUSH();
  */
  if(!ENDP(statement_block(*stepalltoall_stmt)))
    {
      statement flush_stmt = build_call_STEP_flush();
      insert_statement(*stepalltoall_stmt, flush_stmt, false);
    }
  pips_debug(1, "end\n");
}

References build_call_STEP_flush(), ENDP, insert_statement(), pips_debug, and statement_block().

Referenced by compile_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_get_commsize()

statement generate_call_get_commsize

(

entity

new_module

)

Parameters

new_module

ew_module

Definition at line 193 of file compile_RT.c.

{
  pips_debug(1, "begin\n");
  statement stmt;
  /*
    Generation of:
    STEP_GET_COMMSIZE(&STEP_COMM_SIZE);
  */
 
  entity commsize = get_entity_step_commsize(new_module);
  expression commsize_expr = entity_to_expression(commsize);
 
  stmt = call_STEP_subroutine2(RT_STEP_get_commsize, get_expression_addr(commsize_expr), NULL);
  pips_debug(1, "end\n");
  return stmt;
}

References call_STEP_subroutine2(), entity_to_expression(), get_entity_step_commsize(), get_expression_addr(), pips_debug, and RT_STEP_get_commsize.

Referenced by compile_loopslices().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_get_rank()

statement generate_call_get_rank

(

entity

new_module

)

Parameters

new_module

ew_module

Definition at line 161 of file compile_RT.c.

{
  statement stmt;
  /*
    Generation of:
    CALL STEP_GET_RANK(&STEP_COMM_RANK)
  */
  entity rank = get_entity_step_rank(new_module);
  expression expr_rank = entity_to_expression(rank);
 
 
  stmt = call_STEP_subroutine2(RT_STEP_get_rank, get_expression_addr(expr_rank), NULL);
  return stmt;
}

References call_STEP_subroutine2(), entity_to_expression(), get_entity_step_rank(), get_expression_addr(), rank, and RT_STEP_get_rank.

Referenced by compile_loopbounds().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_get_rank_loopbounds()

statement generate_call_get_rank_loopbounds	(	entity	new_module,
		loop	loop_stmt
	)

Parameters

new_module	ew_module
loop_stmt	oop_stmt

Definition at line 138 of file compile_RT.c.

{
  pips_debug(1, "begin\n");
  
  /*
    Generation of:
    CALL STEP_GETLOOPBOUNDS(STEP_Rank, &I_SLICE_LOW, &I_SLICE_UP)
  */
  entity index = loop_index(loop_stmt);
  entity index_low = step_local_loop_index(new_module, STEP_BOUNDS_LOW(index));
  expression expr_index_low = entity_to_expression(index_low);
  entity index_up = step_local_loop_index(new_module, STEP_BOUNDS_UP(index));
  expression expr_index_up = entity_to_expression(index_up);
  entity id_workchunk = get_entity_step_rank(new_module);
  expression expr_id_workchunk = entity_to_expression(id_workchunk);
 
  statement get_bounds_stmt = call_STEP_subroutine2(RT_STEP_get_loopbounds, expr_id_workchunk, get_expression_addr(expr_index_low), get_expression_addr(expr_index_up), NULL); 
 
  pips_debug(1, "end\n");
  
  return get_bounds_stmt;
}

References call_STEP_subroutine2(), entity_to_expression(), get_entity_step_rank(), get_expression_addr(), loop_index, pips_debug, RT_STEP_get_loopbounds, STEP_BOUNDS_LOW, STEP_BOUNDS_UP, and step_local_loop_index().

Referenced by compile_loopbounds().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_get_workchunk_loopbounds()

void generate_call_get_workchunk_loopbounds	(	entity	mpi_module,
		loop	loop_stmt,
		statement *	compute_regions_stmt
	)

Parameters

mpi_module	pi_module
loop_stmt	oop_stmt
compute_regions_stmt	ompute_regions_stmt

Definition at line 119 of file compile_RT.c.

{
  pips_debug(1, "begin\n");
  /*
    Generation of:
    STEP_GET_LOOPBOUNDS(IDX-1, &STEP_i_LOW, &STEP_i_UP);
  */
  entity index = loop_index(loop_stmt);
  entity workchunk_id = step_local_slice_index(mpi_module);
  expression expr_id_workchunk = make_op_exp(PLUS_OPERATOR_NAME, int_to_expression(-1), entity_to_expression(workchunk_id));
  expression expr_index_low = entity_to_expression(step_local_loop_index(mpi_module, STEP_BOUNDS_LOW(index)));
  expression expr_index_up = entity_to_expression(step_local_loop_index(mpi_module, STEP_BOUNDS_UP(index)));
 
  statement get_bounds_stmt = call_STEP_subroutine2(RT_STEP_get_loopbounds, expr_id_workchunk, get_expression_addr(expr_index_low), get_expression_addr(expr_index_up), NULL);
  insert_statement(*compute_regions_stmt, get_bounds_stmt, true);
 
  pips_debug(1, "end\n");
}

References call_STEP_subroutine2(), entity_to_expression(), get_expression_addr(), insert_statement(), int_to_expression(), loop_index, make_op_exp(), pips_debug, PLUS_OPERATOR_NAME, RT_STEP_get_loopbounds, STEP_BOUNDS_LOW, STEP_BOUNDS_UP, step_local_loop_index(), and step_local_slice_index().

Referenced by add_workchunk_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_call_init_regionArray()

void generate_call_init_regionArray	(	list	referenced_entities,
		statement	before,
		statement __attribute__((unused))	after
	)

Definition at line 210 of file compile_RT.c.

{
  list init_block = NIL;
 
  /*
    Generation of
 
    STEP_INIT_ARRAYREGIONS(a, STEP_INTEGER4, 1, 0, 100000-1);
  */
 
  pips_debug(1, "begin\n");
 
  FOREACH(ENTITY, e, referenced_entities)
    {
      if (type_variable_p(entity_type(e)) && !entity_scalar_p(e))
        {
          pips_debug(2,"build_call_STEP_init_regionArray entity %s\n", entity_name(e));
          init_block = CONS(STATEMENT, build_call_STEP_init_regionArray(e), init_block);
        }
    }
  insert_statement(before, make_block_statement(gen_nreverse(init_block)), false);
 
  pips_debug(1, "end\n");
}

References build_call_STEP_init_regionArray(), CONS, ENTITY, entity_name, entity_scalar_p(), entity_type, FOREACH, gen_nreverse(), insert_statement(), make_block_statement(), NIL, pips_debug, STATEMENT, and type_variable_p.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_loop_workchunk()

void generate_loop_workchunk	(	entity	mpi_module,
		statement *	compute_regions_stmt
	)

ATTENTION recrée alors qu'avant réutilisé

Parameters

mpi_module	pi_module
compute_regions_stmt	ompute_regions_stmt

Definition at line 101 of file compile_RT.c.

{
  statement loop_stmt;
  /* ATTENTION recrée alors qu'avant réutilisé */
  entity workchunk_id = step_local_slice_index(mpi_module);
  /*
    Generation of
    for(IDX = 1; IDX <= STEP_COMM_SIZE; IDX += 1) {}
  */
  range rng = make_range(int_to_expression(1), entity_to_expression(get_entity_step_commsize(mpi_module)), int_to_expression(1));
 
  loop_stmt = instruction_to_statement(make_instruction_loop(make_loop(workchunk_id, rng, *compute_regions_stmt, entity_empty_label(), make_execution_sequential(), NIL)));
 
  *compute_regions_stmt = make_empty_block_statement();
  insert_statement(*compute_regions_stmt, loop_stmt, true);
 
}

References entity_empty_label(), entity_to_expression(), get_entity_step_commsize(), insert_statement(), instruction_to_statement(), int_to_expression(), make_empty_block_statement(), make_execution_sequential(), make_instruction_loop(), make_loop(), make_range(), NIL, and step_local_slice_index().

Referenced by add_workchunk_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

get_entity_step_commsize()

entity get_entity_step_commsize

(

entity

module

)

Que signifie local?

Parameters

module

odule

Definition at line 519 of file compile_RT.c.

{
  entity e;
 
  pips_debug(3, "begin\n");
 
  e = step_local_RT_Integer(STEP_RT_ARRAY_INDEX_INTEGER, module, STEP_COMM_SIZE_NAME, NIL);
 
  pips_assert("type_variable_p", type_variable_p(entity_type(e)));
  pips_assert("entity_scalar_p", entity_scalar_p(e));
 
  pips_debug(3, "end entity name = %s (%p)\n", entity_name(e), e);
  return e;
}

References entity_name, entity_scalar_p(), entity_type, module, NIL, pips_assert, pips_debug, STEP_COMM_SIZE_NAME, step_local_RT_Integer(), STEP_RT_ARRAY_INDEX_INTEGER, and type_variable_p.

Referenced by generate_call_compute_loopslices(), generate_call_get_commsize(), generate_call_set_regionarray(), and generate_loop_workchunk().

Here is the call graph for this function:

Here is the caller graph for this function:

get_entity_step_rank()

entity get_entity_step_rank

(

entity

module

)

Parameters

module

odule

Definition at line 513 of file compile_RT.c.

{
  return step_local_RT_Integer(STEP_RT_ARRAY_INDEX_INTEGER, module, STEP_COMM_RANK_NAME, NIL);
}

References module, NIL, STEP_COMM_RANK_NAME, step_local_RT_Integer(), and STEP_RT_ARRAY_INDEX_INTEGER.

Referenced by compile_master(), generate_call_get_rank(), and generate_call_get_rank_loopbounds().

Here is the call graph for this function:

Here is the caller graph for this function:

get_expression_addr()

expression get_expression_addr

(

expression

expr

)

compile_RT.c

Used to add & in front of variable name for C modules: var —> &var

Parameters

expr

xpr

Definition at line 27 of file compile_RT.c.

{
  expression expr2;
 
  /* Used to add & in front of variable name for C modules: var ---> &var */
 
  expr2 = expr;
  if (!fortran_module_p(get_current_module_entity()))
    expr2 = MakeUnaryCall(entity_intrinsic(ADDRESS_OF_OPERATOR_NAME), expr);
 
  return expr2;
}

References ADDRESS_OF_OPERATOR_NAME, entity_intrinsic(), fortran_module_p(), get_current_module_entity(), and MakeUnaryCall().

Referenced by compile_master(), compile_reduction(), generate_call_get_commsize(), generate_call_get_rank(), generate_call_get_rank_loopbounds(), and generate_call_get_workchunk_loopbounds().

Here is the call graph for this function:

Here is the caller graph for this function:

set_RT_add_local()

void set_RT_add_local

(

entity

e

)

Definition at line 247 of file compile_RT.c.

{
  if(set_undefined_p(step_created_entity))
      step_created_entity = set_make(set_pointer);
 
  set_add_element(step_created_entity, step_created_entity, e);
}

References set_add_element(), set_make(), set_pointer, set_undefined_p, and step_created_entity.

Referenced by step_local_RT_Integer(), and step_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

step_add_created_symbolic()

static void step_add_created_symbolic ( entity  e )

static

Definition at line 277 of file compile_RT.c.

{
  if(set_undefined_p(step_created_symbolic))
    step_created_symbolic = set_make(set_pointer);
 
  set_add_element(step_created_symbolic, step_created_symbolic, e);
}

References set_add_element(), set_make(), set_pointer, set_undefined_p, and step_created_symbolic.

Referenced by step_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

step_function()

expression step_function	(	string	name,
		list	args
	)

Parameters

name	ame
args	rgs

Definition at line 359 of file compile_RT.c.

{
  entity e = gen_find_tabulated(concatenate(TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING, name, NULL), entity_domain);
  pips_assert("boostrap defined", !entity_undefined_p(e));
  pips_assert("functional", type_functional_p(entity_type(e)));
  return make_call_expression(e, args);
}

References concatenate(), entity_domain, entity_type, entity_undefined_p, gen_find_tabulated(), make_call_expression(), MODULE_SEP_STRING, pips_assert, TOP_LEVEL_MODULE_NAME, and type_functional_p.

Here is the call graph for this function:

step_local_loop_index()

entity step_local_loop_index	(	entity	module,
		string	name
	)

Parameters

module	odule
name	ame

Definition at line 534 of file compile_RT.c.

{
  return step_local_RT_Integer(STEP_RT_LOOP_INDEX_INTEGER, module, name, NIL);
}

References module, NIL, step_local_RT_Integer(), and STEP_RT_LOOP_INDEX_INTEGER.

Referenced by generate_call_get_rank_loopbounds(), generate_call_get_workchunk_loopbounds(), loop_basic_workchunk_to_workchunk(), and loopbounds_substitution().

Here is the call graph for this function:

Here is the caller graph for this function:

step_local_loopSlices()

entity step_local_loopSlices	(	entity	module,
		entity	i
	)

Parameters

module

odule

Definition at line 499 of file compile_RT.c.

{
  list dims =
    CONS(DIMENSION,
         make_dimension(step_symbolic_expression(STEP_INDEX_SLICE_LOW_NAME, module),
                        step_symbolic_expression(STEP_INDEX_SLICE_UP_NAME, module),
                        NIL),
         CONS(DIMENSION, make_dimension(int_to_expression(1),
                                        step_symbolic_expression(STEP_MAX_NB_LOOPSLICES_NAME, module),
                                        NIL),
              NIL));
  return step_local_RT_Integer(STEP_RT_LOOP_INDEX_INTEGER, module, STEP_LOOPSLICES_NAME(i), dims);
}

References CONS, DIMENSION, int_to_expression(), make_dimension(), module, NIL, STEP_INDEX_SLICE_LOW_NAME, STEP_INDEX_SLICE_UP_NAME, step_local_RT_Integer(), STEP_LOOPSLICES_NAME, STEP_MAX_NB_LOOPSLICES_NAME, STEP_RT_LOOP_INDEX_INTEGER, and step_symbolic_expression().

Here is the call graph for this function:

step_local_regionArray()

entity step_local_regionArray	(	entity	module,
		entity	array,
		string	region_array_name,
		expression	expr_nb_region
	)

Parameters

module	odule
array	rray
region_array_name	egion_array_name
expr_nb_region	xpr_nb_region

Definition at line 428 of file compile_RT.c.

{
  pips_debug(1, "begin module = %s, array = %s, region_array_name = %s, expr_nb_region = %p\n", entity_name(module), entity_name(array), region_array_name, expr_nb_region);
 
  bool is_fortran = fortran_module_p(get_current_module_entity());
  string name = strdup(region_array_name);
  list dims = NIL;
  if(is_fortran)
    {
      dimension dim_array = make_dimension(int_to_expression(1), int_to_expression(NumberOfDimension(array)), NIL);
      if(!expression_undefined_p(expr_nb_region))
        dims = CONS(DIMENSION,
                    make_dimension(int_to_expression(1),
                                   expr_nb_region, NIL),
                    dims);
      dimension bounds =
        make_dimension(step_symbolic_expression(STEP_INDEX_SLICE_LOW_NAME, module),
                       step_symbolic_expression(STEP_INDEX_SLICE_UP_NAME, module),
                       NIL);
      dims = CONS(DIMENSION, bounds, CONS(DIMENSION, dim_array, dims));
    }
  else
    {
      dimension bounds =
        make_dimension(int_to_expression(0),
                       MakeBinaryCall(CreateIntrinsic(MINUS_C_OPERATOR_NAME),
                                      step_symbolic_expression(STEP_INDEX_SLICE_UP_NAME, module),
                                      int_to_expression(1)),
                       NIL);
      dims = CONS(DIMENSION, bounds, dims);
 
      dimension dim_array =
        make_dimension(int_to_expression(0),
                       MakeBinaryCall(CreateIntrinsic(MINUS_C_OPERATOR_NAME),
                                      int_to_expression(NumberOfDimension(array)),
                                      int_to_expression(1)),
                       NIL);
      dims = CONS(DIMENSION, dim_array, dims);
 
      if(!expression_undefined_p(expr_nb_region))
        dims = CONS(DIMENSION,
                    make_dimension(int_to_expression(0),
                                   MakeBinaryCall(CreateIntrinsic(MINUS_C_OPERATOR_NAME),
                                                  expr_nb_region,
                                                  int_to_expression(1)),
                                   NIL),
                    dims);
    }
 
  entity e = step_local_RT_Integer(STEP_RT_ARRAY_INDEX_INTEGER, module, name, dims);
  free(name);
  pips_assert("variable", entity_variable_p(e));
 
  pips_debug(1, "end e = %p\n", e);
  return e;
}

References array, CONS, CreateIntrinsic(), DIMENSION, entity_name, entity_variable_p, expression_undefined_p, fortran_module_p(), free(), get_current_module_entity(), int_to_expression(), make_dimension(), MakeBinaryCall(), MINUS_C_OPERATOR_NAME, module, NIL, NumberOfDimension(), pips_assert, pips_debug, STEP_INDEX_SLICE_LOW_NAME, STEP_INDEX_SLICE_UP_NAME, step_local_RT_Integer(), STEP_RT_ARRAY_INDEX_INTEGER, step_symbolic_expression(), and strdup().

Referenced by region_to_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

step_local_RT_Integer()

static entity step_local_RT_Integer ( int  size_of_integer, entity  mpi_module, string  name_, list  dims  )

static

Definition at line 386 of file compile_RT.c.

{
  pips_debug(1, "begin mpi_module = %s, name_ = %s\n", entity_name(mpi_module), name_);
  string name = strdup(name_);
  entity e = FindOrCreateEntity(entity_user_name(mpi_module), name);
  pips_assert("not null", e != NULL);
  pips_assert("entity defined", !entity_undefined_p(e));
 
  if (type_undefined_p(entity_type(e)))
    {
      pips_debug(2, "create entity VERIFIER CE MESSAGE\n");
 
      entity area = FindOrCreateEntity(entity_user_name(mpi_module), DYNAMIC_AREA_LOCAL_NAME);
      entity_type(e) = MakeTypeVariable(make_basic_int(size_of_integer), dims);
      entity_storage(e) = make_storage_ram(make_ram(mpi_module, area, add_variable_to_area(area, e), NIL));
      entity_kind(e)=ABSTRACT_LOCATION;
      if(mpi_module != get_current_module_entity())
        local_declaration = gen_nconc(local_declaration, CONS(ENTITY, e, NIL));
    }
  else
    pips_debug(2, "entity already exists\n");
 
  pips_assert("variable", entity_variable_p(e));
  free(name);
 
  set_RT_add_local(e);
 
  pips_debug(1, "end\n");
  return e;
}

References ABSTRACT_LOCATION, add_variable_to_area(), CONS, DYNAMIC_AREA_LOCAL_NAME, ENTITY, entity_kind, entity_name, entity_storage, entity_type, entity_undefined_p, entity_user_name(), entity_variable_p, FindOrCreateEntity(), free(), gen_nconc(), get_current_module_entity(), local_declaration, make_basic_int(), make_ram(), make_storage_ram(), MakeTypeVariable(), NIL, pips_assert, pips_debug, set_RT_add_local(), strdup(), and type_undefined_p.

Referenced by get_entity_step_commsize(), get_entity_step_rank(), step_local_loop_index(), step_local_loopSlices(), step_local_regionArray(), and step_local_slice_index().

Here is the call graph for this function:

Here is the caller graph for this function:

step_local_slice_index()

entity step_local_slice_index

(

entity

module

)

Parameters

module

odule

Definition at line 486 of file compile_RT.c.

{
  return step_local_RT_Integer(STEP_RT_ARRAY_INDEX_INTEGER, module, STEP_SLICE_INDEX_NAME, NIL);
}

References module, NIL, step_local_RT_Integer(), STEP_RT_ARRAY_INDEX_INTEGER, and STEP_SLICE_INDEX_NAME.

Referenced by compute_region(), generate_call_get_workchunk_loopbounds(), and generate_loop_workchunk().

Here is the call graph for this function:

Here is the caller graph for this function:

step_parameter()

entity step_parameter	(	string	name_,
		entity	module,
		expression	expr
	)

Fortran PARAMETER (TEST = expr)

C const int TEST=1

DT74 "TOP-LEVEL:TEST"T77 2 T80 T31 0 4 )()(T63 0 U))))T70 1 T64 R74 "TOP-LEVEL:TOP-LEVEL" R74 "TOP-LEVEL:*STATIC*" 0 ()))T79 5 T44 T73 2 T33 R74 "TOP-LEVEL:1"

T77: type T80: variable T31: basic 0: int T63: qualifier 0: const T70: storage 1: ram T64: ram T79: value 5: expression T44:Expression T73: syntax 2: call T33:call R74: entity"TOP-LEVEL:1"

Parameters

name_	ame_
module	odule
expr	xpr

Definition at line 285 of file compile_RT.c.

{
  entity e;
  string name = strdup(name_);
 
  if (fortran_module_p(get_current_module_entity()))
    {
      /* Fortran
         PARAMETER (TEST = expr)
       */
      e = FindOrCreateEntity(entity_user_name(module), name);
      pips_assert("not null", e != NULL);
      pips_assert("entity defined", !entity_undefined_p(e));
 
      if (type_undefined_p(entity_type(e)))
        {
          entity_type(e)=MakeTypeVariable(make_basic_int(STEP_RT_SYMBOLIC_INTEGER), NIL);
          if(expression_undefined_p(expr))
            e = MakeParameter(e, int_to_expression(0)); // a default value
          else
            e = MakeParameter(e, expr);
        }
      pips_assert("symbolic", entity_symbolic_p(e));
      set_RT_add_local(e);
    }
  else
    {
      /* C
     const int TEST=1
 
     DT74 "TOP-LEVEL:TEST"T77 2 T80 T31 0 4 )()(T63 0 U))))T70 1 T64 R74 "TOP-LEVEL:TOP-LEVEL" R74 "TOP-LEVEL:*STATIC*" 0 ()))T79 5 T44 T73 2 T33 R74 "TOP-LEVEL:1"
 
     T77: type T80: variable
                    T31: basic 0: int
                    T63: qualifier 0: const
     T70: storage 1: ram T64: ram
     T79: value 5: expression T44:Expression T73: syntax 2: call T33:call R74: entity"TOP-LEVEL:1"
      */
 
      string cu = compilation_unit_of_module(get_current_module_name());
      e = FindOrCreateEntity(cu, name);
      pips_assert("not null", e != NULL);
      pips_assert("entity defined", !entity_undefined_p(e));
 
      if (type_undefined_p(entity_type(e)))
        {
          entity area = FindOrCreateEntity(TOP_LEVEL_MODULE_NAME, STATIC_AREA_LOCAL_NAME);
          entity_type(e) = make_type(is_type_variable, make_variable(make_basic_int(STEP_RT_SYMBOLIC_INTEGER),
                                                                     NIL, CONS(QUALIFIER, make_qualifier_const(), NIL)));
          entity_storage(e) = make_storage_ram(make_ram(get_top_level_entity(), area, add_C_variable_to_area(area, e), NIL));
          if(expression_undefined_p(expr))
            entity_initial(e) = make_value_expression(int_to_expression(0)); // a default value
          else
            entity_initial(e) = make_value_expression(expr);
          entity_kind(e)=ABSTRACT_LOCATION;
          AddEntityToModuleCompilationUnit(e, get_current_module_entity());
        }
      step_add_created_symbolic(e);
    }
  free(name);
  return e;
}

References ABSTRACT_LOCATION, add_C_variable_to_area(), AddEntityToModuleCompilationUnit(), compilation_unit_of_module(), CONS, entity_initial, entity_kind, entity_storage, entity_symbolic_p, entity_type, entity_undefined_p, entity_user_name(), expression_undefined_p, FindOrCreateEntity(), fortran_module_p(), free(), get_current_module_entity(), get_current_module_name(), get_top_level_entity(), int_to_expression(), is_type_variable, make_basic_int(), make_qualifier_const(), make_ram(), make_storage_ram(), make_type(), make_value_expression(), make_variable(), MakeParameter(), MakeTypeVariable(), module, NIL, pips_assert, QUALIFIER, set_RT_add_local(), STATIC_AREA_LOCAL_NAME, step_add_created_symbolic(), STEP_RT_SYMBOLIC_INTEGER, strdup(), TOP_LEVEL_MODULE_NAME, and type_undefined_p.

Referenced by step_symbolic().

Here is the call graph for this function:

Here is the caller graph for this function:

step_RT_clean_local()

void step_RT_clean_local

(

void

)

reinitialisation du type sinon, la recompilation echoue

Definition at line 255 of file compile_RT.c.

{
  if(set_undefined_p(step_created_entity))
    return;
 
  /* reinitialisation du type sinon, la recompilation echoue */
  SET_FOREACH(entity, e, step_created_entity)
    {
      if(!type_undefined_p(entity_type(e)))
        {
          free_type(entity_type(e));
          entity_type(e) = type_undefined;
          free_storage(entity_storage(e));
          entity_storage(e) = storage_undefined;
          free_value(entity_initial(e));
          entity_initial(e) = value_undefined;
        }
    }
  set_clear(step_created_entity);
}

References entity_initial, entity_storage, entity_type, free_storage(), free_type(), free_value(), set_clear(), SET_FOREACH, set_undefined_p, step_created_entity, storage_undefined, type_undefined, type_undefined_p, and value_undefined.

Referenced by compile_mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

step_RT_set_local_declarations()

void step_RT_set_local_declarations	(	entity	module,
		statement	body
	)

Parameters

module	odule
body	ody

Definition at line 376 of file compile_RT.c.

{
  FOREACH(ENTITY, e, local_declaration)
    {
      AddLocalEntityToDeclarations(e, module, body);
    }
 
  local_declaration = NIL;
}

References AddLocalEntityToDeclarations(), ENTITY, FOREACH, local_declaration, module, and NIL.

Referenced by compile_mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

step_symbolic()

entity step_symbolic	(	string	name,
		entity	module
	)

Parameters

name	ame
module	odule

Definition at line 348 of file compile_RT.c.

{
  return step_parameter(name, module, expression_undefined);
}

References expression_undefined, module, and step_parameter().

Referenced by step_symbolic_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

step_symbolic_expression()

expression step_symbolic_expression	(	string	name,
		entity	module
	)

Parameters

name	ame
module	odule

Definition at line 353 of file compile_RT.c.

{
  return entity_to_expression(step_symbolic(name, module));
}

References entity_to_expression(), module, and step_symbolic().

Referenced by bound_to_statement(), build_call_STEP_AllToAll(), generate_call_construct_begin_construct_end(), region_to_statement(), step_local_loopSlices(), and step_local_regionArray().

Here is the call graph for this function:

Here is the caller graph for this function:

step_type()

entity step_type

(

entity

data

)

Definition at line 542 of file compile_RT.c.

{
  type t;
  basic b;
 
  pips_assert("data", !entity_undefined_p(data));
  t = entity_type(data);
  pips_assert("check step_type", type_variable_p(t));
  b = variable_basic(type_variable(t));
 
  switch (basic_tag(b))
    {
    case is_basic_int:
      switch (basic_int(b))
        {
        case 1: return MakeConstant(STEP_INTEGER1_NAME, is_basic_string);
        case 2: return MakeConstant(STEP_INTEGER2_NAME, is_basic_string);
        case 4: return MakeConstant(STEP_INTEGER4_NAME, is_basic_string);
        case 8: return MakeConstant(STEP_INTEGER8_NAME, is_basic_string);
        default:
          pips_debug(0, "unexpected basic int for entity %s\n", entity_name(data));
          pips_user_error("unexpected basic int : %i\n", basic_int(b));
        }
      break;
    case is_basic_float:
      switch (basic_float(b))
        {
        case 4: return MakeConstant(STEP_REAL4_NAME, is_basic_string);
        case 8: return MakeConstant(STEP_REAL8_NAME, is_basic_string);
        default:
          pips_debug(0, "unexpected basic float for entity %s\n", entity_name(data));
          pips_user_error("unexpected basic float : %i\n", basic_float(b));
        }
      break;
    case is_basic_complex:
      switch (basic_complex(b))
        {
        case 8: return MakeConstant(STEP_COMPLEX8_NAME, is_basic_string);
        case 16: return MakeConstant(STEP_COMPLEX16_NAME, is_basic_string);
        default:
          pips_debug(0, "unexpected basic complex for entity %s\n", entity_name(data));
          pips_user_error("unexpected basic complex : %i\n", basic_complex(b));
        }
      break;
    default:
      pips_debug(0, "unexpected type for entity %s\n", entity_name(data));
      pips_user_error("unexpected basic type : %i\n", basic_tag(b));
      break;
    }
  return entity_undefined;
}

References basic_complex, basic_float, basic_int, basic_tag, entity_name, entity_type, entity_undefined, entity_undefined_p, is_basic_complex, is_basic_float, is_basic_int, is_basic_string, MakeConstant(), pips_assert, pips_debug, pips_user_error, STEP_COMPLEX16_NAME, STEP_COMPLEX8_NAME, STEP_INTEGER1_NAME, STEP_INTEGER2_NAME, STEP_INTEGER4_NAME, STEP_INTEGER8_NAME, STEP_REAL4_NAME, STEP_REAL8_NAME, type_variable, type_variable_p, and variable_basic.

Referenced by build_call_STEP_init_regionArray(), call_STEP_subroutine(), check_entity_step_type(), and compile_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

local_declaration

list local_declaration = NIL

static

Definition at line 374 of file compile_RT.c.

Referenced by step_local_RT_Integer(), and step_RT_set_local_declarations().

step_created_entity

set step_created_entity = set_undefined

Definition at line 245 of file compile_RT.c.

Referenced by loop_basic_workchunk_to_workchunk(), set_RT_add_local(), step_RT_clean_local(), and update_referenced_entities().

step_created_symbolic

set step_created_symbolic = set_undefined

Definition at line 276 of file compile_RT.c.

Referenced by step_add_created_symbolic(), and update_referenced_entities().