step.h File Reference

#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "step_private.h"
#include "effects.h"

Include dependency graph for step.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	get_step_directive_name (step_directive, string *)
	Warning! Do not modify this file that is automatically generated! More...
void	step_directive_type_print (step_directive)
void	step_directives_print (void)
void	step_directives_init (bool)
void	step_directives_reset (void)
void	step_directives_save (void)
step_directive	step_directives_load (statement)
bool	step_directives_bound_p (statement)
void	step_directives_store (statement, step_directive)
bool	step_directive_to_strings (step_directive, bool, string *, string *)
statement	step_directive_basic_workchunk (step_directive)
list	step_directive_basic_workchunk_index (step_directive)
void	step_directive_print (step_directive)
bool	step_private_p (statement, entity)
bool	step_interlaced_p (effect)
	analyse.c More...
bool	step_partial_p (effect)
bool	step_analysed_module_p (const char *)
void	load_step_comm (void)
void	reset_step_comm (void)
void	store_step_comm (void)
void	debug_print_effects_list (list, string)
bool	step_analyse_init (const string)
effect	rectangularization_region (effect)
bool	step_analyse (const char *)
expression	get_expression_addr (expression)
	compile_RT.c More...
void	generate_call_construct_begin_construct_end (entity, step_directive, statement, statement)
void	generate_call_flush (statement *)
void	generate_loop_workchunk (entity, statement *)
void	generate_call_get_workchunk_loopbounds (entity, loop, statement *)
statement	generate_call_get_rank_loopbounds (entity, loop)
statement	generate_call_get_rank (entity)
statement	generate_call_compute_loopslices (entity, loop)
statement	generate_call_get_commsize (entity)
void	generate_call_init_regionArray (list, statement, statement)
void	set_RT_add_local (entity)
void	step_RT_clean_local (void)
entity	step_parameter (string, entity, expression)
entity	step_symbolic (string, entity)
expression	step_symbolic_expression (string, entity)
expression	step_function (string, list)
void	step_RT_set_local_declarations (entity, statement)
entity	step_local_regionArray (entity, entity, string, expression)
entity	step_local_slice_index (entity)
entity	step_local_loopSlices (entity, entity)
entity	get_entity_step_rank (entity)
entity	get_entity_step_commsize (entity)
	Que signifie local? More...
entity	step_local_loop_index (entity, string)
entity	step_type (entity data)
statement	build_call_STEP_init_regionArray (entity)
statement	build_call_STEP_AllToAll (entity, entity, bool, bool)
statement	build_call_STEP_WaitAll (list)
statement	build_call_STEP_set_sendregions (entity, expression, entity, bool, bool)
statement	build_call_STEP_set_recvregions (entity, expression, entity)
statement	build_call_STEP_flush (void)
statement	call_STEP_subroutine3 (string,...)
statement	call_STEP_subroutine2 (string,...)
void	check_entity_step_type (entity data)
statement	call_STEP_subroutine (string, list, entity data)
statement	compile_mpi (statement, string, step_directive, int)
	compile_mpi.c More...
void	compile_regions (entity, list, bool, loop, list, set[4], statement, statement)
	compile_regions.c More...
statement	compile_omp (statement, step_directive)
	compile.c More...
void	add_omp_guard (statement *)
void	step_compile_analysed_module (const char *, string)
void	step_compile_generated_module (const char *, string)
	generated source: no analyse and no compilation necessary. More...
bool	step_compile (const char *)
void	set_current_transform (int)
	parser.c More...
void	insert_optional_pragma (int type)
entity	entity_from_user_name (string)
void	remove_old_pragma (void)
step_directive	begin_omp_construct (int type, string)
step_directive	end_omp_construct (int type)
bool	step_parser (const char *)
bool	step_install (const string)
	install.c More...
int	comment2pragmalex (void)
void	comment2pragmarestart (FILE *)
void	comment2pragmapop_buffer_state (void)
int	comment2pragmaget_lineno (void)
FILE *	comment2pragmaget_in (void)
FILE *	comment2pragmaget_out (void)
int	comment2pragmaget_leng (void)
char *	comment2pragmaget_text (void)
void	comment2pragmaset_lineno (int)
void	comment2pragmaset_in (FILE *)
void	comment2pragmaset_out (FILE *)
int	comment2pragmaget_debug (void)
void	comment2pragmaset_debug (int)
int	comment2pragmalex_destroy (void)
void *	comment2pragmaalloc (yy_size_t)
void *	comment2pragmarealloc (void *, yy_size_t)
void	comment2pragmafree (void *)
void	step_comment2pragma_handle (statement)
int	step_lexerlex (void)
void	step_lexerrestart (FILE *)
void	step_lexerpop_buffer_state (void)
int	step_lexerget_lineno (void)
FILE *	step_lexerget_in (void)
FILE *	step_lexerget_out (void)
int	step_lexerget_leng (void)
char *	step_lexerget_text (void)
void	step_lexerset_lineno (int)
void	step_lexerset_in (FILE *)
void	step_lexerset_out (FILE *)
int	step_lexerget_debug (void)
void	step_lexerset_debug (int)
int	step_lexerlex_destroy (void)
void *	step_lexeralloc (yy_size_t)
void *	step_lexerrealloc (void *, yy_size_t)
void	step_lexerfree (void *)
void	step_lexererror (const char *)
	step_bison_parser.c More...
int	step_lexerparse (void)
void	step_bison_parse (pragma, statement)

Variables
set	step_created_entity
set	step_created_symbolic
int	comment2pragmaleng
	comment2pragma.c More...
FILE *	comment2pragmain
FILE *	comment2pragmaout
int	comment2pragmalineno
int	comment2pragma_flex_debug
char *	comment2pragmatext
int	step_lexerleng
	step_lexer.c More...
FILE *	step_lexerin
FILE *	step_lexerout
int	step_lexerlineno
int	step_lexer_flex_debug
char *	step_lexertext
int	step_lexerdebug
int	step_lexerchar
int	step_lexernerrs

Function Documentation

add_omp_guard()

void add_omp_guard

(

statement *

block

)

Parameters

block

lock

Definition at line 62 of file compile.c.

{
  pips_assert("block", block && !statement_undefined_p(*block) && statement_block_p(*block));
  pips_debug(1, "begin\n");
 
  if (!empty_statement_or_continue_p(*block))
    {
      statement barrier_stmt = make_empty_block_statement();
      step_directive barrier_guard = make_step_directive(STEP_BARRIER, statement_undefined, NIL);
      step_directive master_guard = make_step_directive(STEP_MASTER, statement_undefined, NIL);
      compile_omp(barrier_stmt, barrier_guard);
      compile_omp(*block, master_guard);
      free_step_directive(barrier_guard);
      free_step_directive(master_guard);
 
      *block = make_block_statement(CONS(STATEMENT, *block, CONS(STATEMENT, barrier_stmt, NIL)));
    }
 
  pips_debug(1, "end\n");
}

References compile_omp(), CONS, empty_statement_or_continue_p(), free_step_directive(), make_block_statement(), make_empty_block_statement(), make_step_directive(), NIL, pips_assert, pips_debug, STATEMENT, statement_block_p, statement_undefined, statement_undefined_p, STEP_BARRIER, and STEP_MASTER.

Referenced by compile_body().

Here is the call graph for this function:

Here is the caller graph for this function:

begin_omp_construct()

step_directive begin_omp_construct	(	int	type,
		string	s
	)

In C, these OpenMP pragmas are already supported by blocks: no block conversion needed

Definition at line 159 of file parser.c.

{
  statement directive_stmt;
 
  pips_debug(1,"begin type = %d, str = %s\n", type, s);
 
  directive_stmt = current_statement;
 
  if(fortran_module_p(get_current_module_entity()))
    {
      switch(type)
        {
        case STEP_DO:
        case STEP_PARALLEL_DO:
          pips_assert("loop statement", statement_loop_p(directive_stmt)||statement_forloop_p(directive_stmt));
          insert_optional_pragma(type);
          _FALLTHROUGH_; // is that so?
        case STEP_PARALLEL:
        case STEP_MASTER:
        case STEP_SINGLE:
        case STEP_BARRIER:
          directive_stmt = make_empty_block_statement();
          break;
        case STEP_THREADPRIVATE:
          directive_stmt = make_empty_block_statement();
          break;
        default:
          pips_user_error("unknown directive type %d\n", type);
          break;
        }
    }
  else if (c_module_p(get_current_module_entity()))
    {
      switch(type)
        {
        case STEP_DO:
        case STEP_PARALLEL_DO:
          {
            statement new_stmt;
            pips_assert("loop statement", statement_loop_p(directive_stmt)||statement_forloop_p(directive_stmt));
            pips_debug(2,"Block conversion (C)\n");
 
            new_stmt = instruction_to_statement(statement_instruction(directive_stmt));
 
            move_statement_attributes(directive_stmt, new_stmt);
            statement_label(directive_stmt) = entity_empty_label();
            statement_comments(directive_stmt) = empty_comments;
            statement_declarations(directive_stmt) = NIL;
            statement_decls_text(directive_stmt) = NULL;
            statement_extensions(directive_stmt) = empty_extensions();
            statement_instruction(directive_stmt) = make_instruction_block(CONS(STATEMENT, new_stmt, NIL));
          }
        case STEP_PARALLEL:
        case STEP_MASTER:
        case STEP_SINGLE:
          /* In C, these OpenMP pragmas are already supported by blocks: no block conversion needed */
          break;
        case STEP_BARRIER:
          directive_stmt = make_empty_block_statement();
          break;
        case STEP_THREADPRIVATE:
          directive_stmt = make_empty_block_statement();
          break;
        default:
          pips_user_error("unknown directive type %d\n", type);
          break;
        }
    }
  else
    pips_user_error("language not supported");
 
  step_directive drt = new_step_directive(directive_stmt, type, s);
 
  if(fortran_module_p(get_current_module_entity()))
    {
      step_blocks_push(statement_sequence(directive_stmt));
    }
 
  pips_debug(1,"end drt = %p\n", drt);
  return drt;
}

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:

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:

comment2pragmaalloc()

void* comment2pragmaalloc

(

yy_size_t

)

comment2pragmafree()

void comment2pragmafree

(

void *

)

comment2pragmaget_debug()

int comment2pragmaget_debug

(

void

)

comment2pragmaget_in()

FILE* comment2pragmaget_in

(

void

)

comment2pragmaget_leng()

int comment2pragmaget_leng

(

void

)

comment2pragmaget_lineno()

int comment2pragmaget_lineno

(

void

)

comment2pragmaget_out()

FILE* comment2pragmaget_out

(

void

)

comment2pragmaget_text()

char* comment2pragmaget_text

(

void

)

comment2pragmalex()

int comment2pragmalex

(

void

)

comment2pragmalex_destroy()

int comment2pragmalex_destroy

(

void

)

comment2pragmapop_buffer_state()

void comment2pragmapop_buffer_state

(

void

)

comment2pragmarealloc()

void* comment2pragmarealloc	(	void *	,
		yy_size_t
	)

comment2pragmarestart()

void comment2pragmarestart

(

FILE *

)

comment2pragmaset_debug()

void comment2pragmaset_debug

(

int

)

comment2pragmaset_in()

void comment2pragmaset_in

(

FILE *

)

comment2pragmaset_lineno()

void comment2pragmaset_lineno

(

int

)

comment2pragmaset_out()

void comment2pragmaset_out

(

FILE *

)

compile_mpi()

statement compile_mpi	(	statement	directive_stmt,
		string	new_module_name,
		step_directive	drt,
		int	transformation
	)

compile_mpi.c

Parameters

directive_stmt	irective_stmt
new_module_name	ew_module_name
drt	rt
transformation	ransformation

Definition at line 517 of file compile_mpi.c.

{
  pips_debug(1, "begin current module %p : %s\n", get_current_module_entity(), get_current_module_name());
 
  list statements_to_outline = make_statement_list(directive_stmt);
  entity new_module = gen_find_tabulated(concatenate(TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING, new_module_name, NULL), entity_domain);
  pips_assert("new_module", !entity_undefined_p(new_module));
 
  // Init hash table
  hash_table entity_to_effective_parameter = outliner_init(new_module, statements_to_outline);
 
  // Find referenced entities in statements_to_outline
  statement new_body = make_empty_block_statement();
  list referenced_entities = outliner_scan(new_module, statements_to_outline, new_body);
 
  // Generate the body of the new module
  statement work_stmt = make_block_statement(gen_copy_seq(statements_to_outline));
  statement mpi_begin_stmt = make_empty_block_statement();
  statement mpi_end_stmt = make_empty_block_statement();
  compile_body(directive_stmt, new_module, drt, transformation, referenced_entities, new_body, mpi_begin_stmt, work_stmt, mpi_end_stmt);
 
  // Some entities may be added by region_to_statement. Ensure they will be passed as parameters
  update_referenced_entities(new_body, &referenced_entities);
 
  // Update hash table and build parameters
  list effective_parameters = NIL, formal_parameters = NIL;
  outliner_parameters(new_module, new_body, referenced_entities, entity_to_effective_parameter, &effective_parameters, &formal_parameters);
 
  // Patch parameters for side effects
  if(c_module_p(get_current_module_entity()))
    outliner_patch_parameters(statements_to_outline, referenced_entities, effective_parameters, formal_parameters, new_body, mpi_begin_stmt, mpi_end_stmt);
 
  step_RT_set_local_declarations(new_module, new_body);
 
  // Source file generation
  set_prettyprinter_head_hook(step_head_hook);
  outliner_file(new_module, formal_parameters, &new_body);
  reset_prettyprinter_head_hook();
 
  step_RT_clean_local();
 
  statement call_stmt = outliner_call(new_module, statements_to_outline, effective_parameters);
 
  pips_debug(1, "end\n");
  return call_stmt;
}

compile_omp()

statement compile_omp	(	statement	stmt,
		step_directive	d
	)

compile.c

Parameters

stmt

tmt

Definition at line 32 of file compile.c.

{
  pips_debug(1, "begin\n");
 
  string begin_txt, end_txt;
  bool is_fortran = fortran_module_p(get_current_module_entity());
  bool is_block_construct = step_directive_to_strings(d, is_fortran, &begin_txt, &end_txt);
 
  if(!string_undefined_p(begin_txt))
    {
      if(!is_block_construct)
        {
          if(ENDP(statement_block(stmt)))
            insert_statement(stmt, make_plain_continue_statement(), false);
          stmt = STATEMENT(CAR(statement_block(stmt)));
        }
      add_pragma_str_to_statement(stmt, begin_txt, false);
    }
 
  if(!string_undefined_p(end_txt))
    {
      insert_statement(stmt, make_plain_continue_statement(), false);
      stmt = last_statement(stmt);
      add_pragma_str_to_statement(stmt, end_txt, false);
    }
 
  pips_debug(1, "end\n");
  return stmt;
}

References add_pragma_str_to_statement(), CAR, ENDP, fortran_module_p(), get_current_module_entity(), insert_statement(), last_statement(), make_plain_continue_statement(), pips_debug, STATEMENT, statement_block(), step_directive_to_strings(), and string_undefined_p.

Referenced by add_omp_guard(), compile_body(), and compile_rewrite().

Here is the call graph for this function:

Here is the caller graph for this function:

compile_regions()

void compile_regions	(	entity	,
		list	,
		bool	,
		loop	,
		list	,
		set	[4],
		statement	,
		statement
	)

compile_regions.c

debug_print_effects_list()

void debug_print_effects_list	(	list	l,
		string	txt
	)

Parameters

txt

xt

Definition at line 334 of file analyse.c.

{
  if(ENDP(l))
    pips_debug(1, "%s empty\n", txt);
  else
    {
      bool property_prettyprint_scalar_regions = get_bool_property("PRETTYPRINT_SCALAR_REGIONS");
      set_bool_property("PRETTYPRINT_SCALAR_REGIONS", true);
 
      FOREACH(EFFECT, eff, l)
        {
          string str_reg = text_to_string(text_rw_array_regions(CONS(EFFECT, eff, NIL)));
          pips_debug(1, "%s %p : %s\n", txt, eff, str_reg); free(str_reg);
        }
      set_bool_property("PRETTYPRINT_SCALAR_REGIONS", property_prettyprint_scalar_regions);
    }
}

References CONS, EFFECT, ENDP, FOREACH, free(), get_bool_property(), NIL, pips_debug, set_bool_property(), text_rw_array_regions(), and text_to_string().

Referenced by compute_recv_regions(), compute_send_regions(), step_analyse_CHAINS_DG(), step_print_directives_regions(), step_print_effect_path(), step_translate_and_map_step_regions(), step_update_comm(), and step_update_SUMMARY_SENDRECV_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

end_omp_construct()

step_directive end_omp_construct

(

int

type

)

suppression du CONTINUE portant le pragma optionnel dans le futur block

Definition at line 248 of file parser.c.

{
  step_directive drt;
 
  pips_debug(1,"begin type = %d\n", type);
 
  drt = step_directive_undefined;
  if(fortran_module_p(get_current_module_entity()))
    {
      switch(type)
        {
        case STEP_DO:
        case STEP_PARALLEL_DO:
          {
            sequence current_block;
            statement last_stmt;
 
 
            current_block = step_blocks_head();
            last_stmt = STATEMENT(CAR(sequence_statements(current_block)));
            /* suppression du CONTINUE portant le pragma optionnel dans le futur block */
            while (empty_statement_or_labelless_continue_p(last_stmt))
              {
                pips_debug(2,"POP current_block");
                POP(sequence_statements(current_block));
                last_stmt = STATEMENT(CAR(sequence_statements(current_block)));
              }
            if(step_directives_bound_p(last_stmt))
              {
                drt = step_directives_load(last_stmt);
                if (step_directive_type(drt) != type)
                  pips_user_error("\nDirective end-loop not well formed\n");
                else
                  pips_debug(2,"loop directive already closed\n");
              }
            else if (!statement_loop_p(last_stmt))
              pips_user_error("\nDirective end-loop after a no-loop statement\n");
          }
        default:
          break;
        }
 
      if(step_directive_undefined_p(drt))
        {
          drt = get_current_step_directive(true);
          
          if (step_directive_undefined_p(drt) || step_directive_type(drt) != type)
            pips_user_error("\nDirective not well formed\n");
          
          int size = step_blocks_size();
          sequence new_seq = step_blocks_pop();
          pips_debug(2,"pop block directive\n");
          pips_debug(2, "block_stack size :%d\t new_seq_length=%d\n", size, (int)gen_length(sequence_statements(new_seq)));
          
          statement directive_stmt = step_directive_block(drt);
          sequence_statements(statement_sequence(directive_stmt)) = gen_nreverse(statement_block(directive_stmt));
        }
    }
 
  pips_debug(1, "end drt = %p\n", drt);
  return drt;
}

entity_from_user_name()

entity entity_from_user_name

(

string

name

)

passage de name a NAME

determiner le nom avec le bon scope...

Parameters

name

ame

Definition at line 67 of file parser.c.

{
  entity e = entity_undefined;
  
  pips_debug(1, "begin\n");
 
  if(fortran_module_p(get_current_module_entity()))
    {
      /* passage de name a NAME */
      size_t i;
      for (i=0; i<strlen(name); i++)
        name[i]=toupper(name[i]);
 
      string full_name = strdup(concatenate(entity_user_name(get_current_module_entity()), MODULE_SEP_STRING, name, NULL));
      e = gen_find_tabulated(full_name, entity_domain);
      if (entity_undefined_p(e))
        pips_user_error("\nFortran entity \"%s\" not found\n", full_name);
      free(full_name);
    }
  else if (c_module_p(get_current_module_entity()))
    {
      /* determiner le nom avec le bon scope... */
      statement stmt_declaration = current_statement;
      pips_debug(4,"##### ENTITY DECL #####\n");
      while (entity_undefined_p(e) && stmt_declaration)
        {
          FOREACH(entity, ee, statement_declarations(stmt_declaration))
            {
              pips_debug(4, "entity decl : \"%s\"\n", entity_name(ee));
              if (strcmp(name, entity_user_name(ee)) == 0)
                {
                  e = ee;
                  break;
                }
            }
          stmt_declaration = (statement)gen_get_ancestor(statement_domain, stmt_declaration);
        }
 
      if (entity_undefined_p(e))
        {
          FOREACH(entity, ee, code_declarations(entity_code(get_current_module_entity())))
            {
              pips_debug(4, "entity decl : \"%s\"\n", entity_name(ee));
              if (strcmp(name, entity_user_name(ee)) == 0)
                {
                  e = ee;
                  break;
                }
            }
        }
      if (entity_undefined_p(e))
        {
          string cu = compilation_unit_of_module(get_current_module_name());
          string full_name = strdup(concatenate(cu, MODULE_SEP_STRING, name, NULL));
          e = gen_find_tabulated(full_name, entity_domain);
          free(full_name);
        }
     if (entity_undefined_p(e))
        {
          string full_name = strdup(concatenate(TOP_LEVEL_MODULE_NAME, MODULE_SEP_STRING, name, NULL));
          e = gen_find_tabulated(full_name, entity_domain);
          free(full_name);
        }
 
      if (entity_undefined_p(e))
        pips_user_error("\nC Entity \"%s\" not found\n", name);
    }
 
  pips_debug(1, "end\n");;
  return e;
}

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	,
		statement	,
		statement
	)

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:

get_step_directive_name()

void get_step_directive_name	(	step_directive	drt,
		string *	directive_txt
	)

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/step/step-local.h instead, to add your own modifications. header file built by cproto step-local.h cproto-generated files directives.c

Parameters

drt	rt
directive_txt	irective_txt

Definition at line 18 of file directives.c.

{
  pips_debug(2, "begin\n");
 
  switch(step_directive_type(drt))
    {
    case STEP_PARALLEL:
      *directive_txt = strdup(STEP_PARALLEL_NAME);
      break;
    case STEP_DO:
      *directive_txt = strdup(STEP_DO_NAME);
      break;
    case STEP_PARALLEL_DO:
      *directive_txt = strdup(STEP_PARALLEL_DO_NAME);
      break;
    case STEP_MASTER:
      *directive_txt = strdup(STEP_MASTER_NAME);
      break;
    case STEP_SINGLE:
      *directive_txt = strdup(STEP_SINGLE_NAME);
      break;
    case STEP_BARRIER:
      *directive_txt = string_undefined;
      break;
    case STEP_THREADPRIVATE:
      *directive_txt = string_undefined;
      break;
    default: assert(0);
    }
 
  pips_debug(2, "end\n");
}

References assert, directive_txt, pips_debug, STEP_BARRIER, step_directive_type, STEP_DO, STEP_DO_NAME, STEP_MASTER, STEP_MASTER_NAME, STEP_PARALLEL, STEP_PARALLEL_DO, STEP_PARALLEL_DO_NAME, STEP_PARALLEL_NAME, STEP_SINGLE, STEP_SINGLE_NAME, STEP_THREADPRIVATE, strdup(), and string_undefined.

Referenced by generate_call_construct_begin_construct_end().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_optional_pragma()

void insert_optional_pragma

(

int

type

)

Definition at line 46 of file parser.c.

{
  statement new_stmt = make_plain_continue_statement();
 
  switch (type)
    {
    case STEP_DO:
      add_pragma_str_to_statement(new_stmt, "ompenddo\n", true);
      break;
    case STEP_PARALLEL_DO:
      add_pragma_str_to_statement(new_stmt, "ompendparalleldo\n", true);
      break;
    default:
      pips_user_error("Unexpected pragma type %d\n", type);
    }
  statement parent_stmt = (statement)gen_get_ancestor(statement_domain, current_statement);
  pips_assert("parent", parent_stmt != NULL);
  pips_assert("block", statement_block_p(parent_stmt));
  gen_insert_after(new_stmt, current_statement, statement_block(parent_stmt));
}

References add_pragma_str_to_statement(), current_statement, gen_get_ancestor(), gen_insert_after(), make_plain_continue_statement(), pips_assert, pips_user_error, statement_block(), statement_block_p, statement_domain, STEP_DO, and STEP_PARALLEL_DO.

Referenced by begin_omp_construct().

Here is the call graph for this function:

Here is the caller graph for this function:

load_step_comm()

void load_step_comm

(

void

)

Definition at line 190 of file analyse.c.

{
  step_comm comms = (step_comm)db_get_memory_resource(DBR_STEP_COMM, "", true);
 
  set_step_effect_path(step_comm_path(comms));
  set_step_interlaced(step_comm_interlaced(comms));
  set_step_partial(step_comm_partial(comms));
}

References db_get_memory_resource(), step_comm_interlaced, step_comm_partial, and step_comm_path.

Referenced by step_analyse(), and step_compile_analysed_module().

Here is the call graph for this function:

Here is the caller graph for this function:

rectangularization_region()

effect rectangularization_region

(

effect

)

remove_old_pragma()

void remove_old_pragma

(

void

)

Definition at line 139 of file parser.c.

{
  pips_assert("statement defined", !statement_undefined_p(current_statement));
  pips_assert("pragma defined", !pragma_undefined_p(current_pragma));
 
  extensions es = statement_extensions(current_statement);
 
  list el = extensions_extension(es);
 
  extensions_extension(es) = NIL;
  FOREACH(EXTENSION, e, el)
    {
      pragma p=extension_pragma(e);
      if (p != current_pragma)
        extensions_extension(es) = gen_extension_cons(e, extensions_extension(es));
    }
 
  extensions_extension(es) = gen_nreverse(extensions_extension(es));
}

reset_step_comm()

void reset_step_comm

(

void

)

Definition at line 199 of file analyse.c.

{
  reset_step_effect_path();
  reset_step_interlaced();
  reset_step_partial();
}

Referenced by step_compile_analysed_module().

Here is the caller graph for this function:

set_current_transform()

void set_current_transform

(

int

transform

)

parser.c

parser.c

Parameters

transform

ransform

Definition at line 41 of file parser.c.

{
  current_transform = transform;
}

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_analyse()

bool step_analyse

(

const char *

module_name

)

remove_from_summary_send et remove_from_summary_recv contain only directive regions and translated regions. They do not contain summary regions.

Parameters

module_name

odule_name

Definition at line 1429 of file analyse.c.

{
  debug_on("STEP_ANALYSE_DEBUG_LEVEL");
  bool exist_regions_p;
  pips_debug(2, "begin %d module_name = %s\n", __LINE__, module_name);
 
  entity module = local_name_to_top_level_entity(module_name);
  set_current_module_entity(module);
 
  set_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
  set_out_effects((statement_effects) db_get_memory_resource(DBR_OUT_REGIONS, module_name, true));
  set_in_effects((statement_effects) db_get_memory_resource(DBR_IN_REGIONS, module_name, true));
 
  statement body = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  set_current_module_statement(body);
  set_ordering_to_statement(body);
 
  init_convex_rw_regions(module_name);
  set_methods_for_convex_effects();
 
  step_directives_init(0);
 
  load_step_comm();
 
  step_statement_path_init(body);
 
  init_step_send_regions();
  init_step_recv_regions();
 
  exist_regions_p = step_compute_SENDRECV_regions(module, body);
 
  pips_debug(2, "exist_regions_p = %d\n", exist_regions_p);
 
  if(exist_regions_p)
    {
      set remove_from_summary_send, remove_from_summary_recv;
      list full_send_l, partial_send_l;
 
      step_analyse_CHAINS_DG(module_name, &remove_from_summary_send, &remove_from_summary_recv);
 
      /* remove_from_summary_send et remove_from_summary_recv contain
         only directive regions and translated regions. They do not
         contain summary regions. */
 
      step_update_SUMMARY_SENDRECV_regions(remove_from_summary_send, remove_from_summary_recv, &full_send_l, &partial_send_l);
 
      /*
        full_send_l are TRANSLATED or DIRECTIVE regions.
        partial_send_l are SUMMARY regions.
      */
      step_update_comm(full_send_l, partial_send_l);
    }
 
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_SEND_REGIONS, module_name, get_step_send_regions());
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_RECV_REGIONS, module_name, get_step_recv_regions());
 
  reset_step_send_regions();
  reset_step_recv_regions();
 
  step_statement_path_finalize();
 
  store_step_comm();
 
  step_directives_reset();
 
  generic_effects_reset_all_methods();
  reset_convex_rw_regions(module_name);
 
  reset_ordering_to_statement();
  reset_current_module_statement();
 
  reset_in_effects();
  reset_out_effects();
  reset_rw_effects();
 
  reset_current_module_entity();
 
  pips_debug(2, "End step_analyse\n");
  debug_off();
  return true;
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, generic_effects_reset_all_methods(), init_convex_rw_regions(), load_step_comm(), local_name_to_top_level_entity(), module, module_name(), pips_debug, reset_convex_rw_regions(), reset_current_module_entity(), reset_current_module_statement(), reset_in_effects(), reset_ordering_to_statement(), reset_out_effects(), reset_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_in_effects(), set_methods_for_convex_effects(), set_ordering_to_statement(), set_out_effects(), set_rw_effects(), step_analyse_CHAINS_DG(), step_compute_SENDRECV_regions(), step_directives_init(), step_directives_reset(), step_statement_path_finalize(), step_statement_path_init(), step_update_comm(), step_update_SUMMARY_SENDRECV_regions(), and store_step_comm().

Here is the call graph for this function:

step_analyse_init()

bool step_analyse_init

(

const

string

)

init intrinsics

other intrinsics

Parameters

string

odule_name

Definition at line 361 of file analyse.c.

{
  pips_debug(2, "begin for module \"%s\".\n", module_name);
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_COMM, "", make_step_comm(make_map_effect_step_point(), make_map_effect_bool(), make_map_effect_bool()));
 
  string srcpath = strdup(PIPS_RUNTIME_DIR "/" STEP_DEFAULT_RT_H);
  string old_path = pips_srcpath_append(srcpath);
  free(old_path);
  free(srcpath);
 
  /* init intrinsics */
  static struct intrin {
    char * name;
    intrinsic_desc_t desc;
  } step_intrinsics [] = {
#include "STEP_RT_intrinsic.h"
    { NULL , {NULL, 0} }
  };
  for(struct intrin *p = step_intrinsics;p->name;++p)
    register_intrinsic_handler(p->name,&(p->desc));
 
  /* other intrinsics */
  static IntrinsicDescriptor IntrinsicTypeDescriptorTable[] =
    {
#include "STEP_RT_bootstrap.h"
      {NULL, 0, 0, 0, 0}
    };
  for(IntrinsicDescriptor *p=IntrinsicTypeDescriptorTable;p->name;p++)
    register_intrinsic_type_descriptor(p) ;
 
  pips_debug(2, "end\n");
  return true;
}

References DB_PUT_MEMORY_RESOURCE, free(), make_map_effect_bool(), make_map_effect_step_point(), make_step_comm(), module_name(), IntrinsicDescriptor::name, pips_debug, pips_srcpath_append(), register_intrinsic_handler(), register_intrinsic_type_descriptor(), STEP_DEFAULT_RT_H, and strdup().

Here is the call graph for this function:

step_analysed_module_p()

bool step_analysed_module_p

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 179 of file analyse.c.

{
  return db_resource_required_or_available_p(DBR_STEP_SEND_REGIONS,  module_name);
}

References db_resource_required_or_available_p(), and module_name().

Referenced by step_compile(), and step_compile_generated_module().

Here is the call graph for this function:

Here is the caller graph for this function:

step_bison_parse()

void step_bison_parse	(	pragma	pgm,
		statement	stmt
	)

Parameters

pgm	gm
stmt	tmt

Definition at line 1901 of file step_bison_parser.c.

{
  string pragma_str = pragma_string(pgm);
 
  if(pragma_str[strlen(pragma_str)-1]!= '\n')
    pragma_str = strdup(concatenate(pragma_string(pgm),"\n",NULL));
  else
    pragma_str = strdup(pragma_string(pgm));
 
  pips_debug(1, "############### PARSER BEGIN ################\nwith :\n%s\non stmt : %p\n", pragma_str, stmt);
  ifdebug(4)
    yydebug=1;
  pragma_str_original = strdup(pragma_str);
  step_lexer_scan_string(pragma_str);
  step_lexerparse();
  free(pragma_str_original);
  pips_debug(1, "############### PARSER END ################\n");
 
  free(pragma_str);
}

step_comment2pragma_handle()

void step_comment2pragma_handle

(

statement

)

step_compile()

bool step_compile

(

const char *

module_name

)

analysed source : let's do the transformations

generated module: nothing to do but copy the generated source

Parameters

module_name

odule_name

Definition at line 393 of file compile.c.

{
  debug_on("STEP_COMPILE_DEBUG_LEVEL");
  pips_debug(1, "Begin considering module_name = %s\n", module_name);
 
  entity module = local_name_to_top_level_entity(module_name);
 
  bool is_fortran = fortran_module_p(module);
  string init_name, finit_name;
  
  init_name = db_build_file_resource_name(DBR_STEP_FILE, module_name, is_fortran?  STEP_GENERATED_SUFFIX_F :  STEP_GENERATED_SUFFIX_C);
  assert(asprintf(&finit_name,"%s/%s" , db_get_current_workspace_directory(), init_name)>=0);
 
  if(step_analysed_module_p(module_name))
    {
      /* analysed source : let's do the transformations */
      step_compile_analysed_module(module_name, finit_name);
    }
  else
    {
      /* generated module: nothing to do but copy the generated source */
      step_compile_generated_module(module_name, finit_name);
    }
 
  DB_PUT_FILE_RESOURCE(DBR_STEP_FILE, module_name, finit_name);
 
  pips_debug(1, "End\n");
  debug_off();
  return true;
}

References asprintf, assert, db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, debug_off, debug_on, fortran_module_p(), local_name_to_top_level_entity(), module, module_name(), pips_debug, step_analysed_module_p(), step_compile_analysed_module(), step_compile_generated_module(), STEP_GENERATED_SUFFIX_C, and STEP_GENERATED_SUFFIX_F.

Here is the call graph for this function:

step_compile_analysed_module()

void step_compile_analysed_module	(	const char *	module_name,
		string	finit_name
	)

Code transformation

File generation

Parameters

module_name	odule_name
finit_name	init_name

Definition at line 288 of file compile.c.

{
  pips_debug(1, "begin\n");
 
  entity module = local_name_to_top_level_entity(module_name);
  statement stmt = (statement)db_get_memory_resource(DBR_CODE, module_name, false);
 
  set_current_module_entity(module);
  set_current_module_statement(stmt);
 
  step_directives_init(0);
  load_step_comm();
 
  statement_effects rw_effects = (statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, false);
  statement_effects cummulated_rw_effects = (statement_effects)db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, false);
  set_rw_effects(rw_effects);
  set_cumulated_rw_effects(cummulated_rw_effects);
 
  /* Code transformation */
  list last_module_name = CONS(STRING, (string)module_name, NIL);
 
  gen_context_recurse(stmt, &last_module_name, statement_domain, compile_filter, compile_rewrite);
 
  if (entity_main_module_p(module))
    {
      string init_subroutine_name;
      init_subroutine_name = fortran_module_p(get_current_module_entity())?
        RT_STEP_init_fortran_order:
        RT_STEP_init_c_order;
      statement init_stmt = call_STEP_subroutine2(init_subroutine_name, NULL);
      statement finalize_stmt = call_STEP_subroutine2(RT_STEP_finalize, NULL);
 
      insert_statement(stmt, init_stmt, true);
      insert_statement(last_statement(stmt), finalize_stmt, true);
    }
 
  reset_cumulated_rw_effects();
  reset_rw_effects();
  free_statement_effects(cummulated_rw_effects);
  free_statement_effects(rw_effects);
  
  reset_step_comm();
  step_directives_reset();
  reset_current_module_statement();
  reset_current_module_entity();
  
  /* File generation */
  text code_txt = text_named_module(module, module, stmt);
  bool saved_b1 = get_bool_property("PRETTYPRINT_ALL_DECLARATIONS");
  bool saved_b2 = get_bool_property("PRETTYPRINT_STATEMENT_NUMBER");
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", true);
  set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", false);
  
  FILE *f = safe_fopen(finit_name, "w");
  print_text(f, code_txt);
  safe_fclose(f, finit_name);
  
  set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", saved_b1);
  set_bool_property("PRETTYPRINT_STATEMENT_NUMBER", saved_b2);
  free_text(code_txt);
  free_statement(stmt);
  pips_debug(1, "end\n");
}

References call_STEP_subroutine2(), compile_filter(), compile_rewrite(), CONS, db_get_memory_resource(), entity_main_module_p(), f(), fortran_module_p(), free_statement(), free_statement_effects(), free_text(), gen_context_recurse, get_bool_property(), get_current_module_entity(), init_stmt, insert_statement(), last_statement(), load_step_comm(), local_name_to_top_level_entity(), module, module_name(), NIL, pips_debug, print_text(), reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_rw_effects(), reset_step_comm(), RT_STEP_finalize, RT_STEP_init_c_order, RT_STEP_init_fortran_order, safe_fclose(), safe_fopen(), set_bool_property(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_rw_effects(), statement_domain, step_directives_init(), step_directives_reset(), STRING, and text_named_module().

Referenced by step_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

step_compile_generated_module()

void step_compile_generated_module	(	const char *	module_name,
		string	finit_name
	)

generated source: no analyse and no compilation necessary.

Keep the source as it is.

Parameters

module_name	odule_name
finit_name	init_name

Definition at line 354 of file compile.c.

{
  pips_debug(1, "begin\n");
  
  string source_file, fsource_file;
  entity module = local_name_to_top_level_entity(module_name);
  bool is_fortran = fortran_module_p(module);
 
  source_file = db_get_memory_resource(is_fortran?DBR_INITIAL_FILE:DBR_C_SOURCE_FILE, module_name, true);
 
  assert(asprintf(&fsource_file,"%s/%s" , db_get_current_workspace_directory(), source_file)>=0);
  pips_debug(1, "Copie from: %s\n", fsource_file);
  safe_copy(fsource_file, finit_name);
  
  if(compilation_unit_p(module_name))
    {
      safe_system(concatenate("echo '#include \"step_api.h\"' >>",finit_name,  NULL));
      pips_debug(1, "\tAdd prototype for STEP generated modules\n");
      gen_array_t modules = db_get_module_list_initial_order();
      int n = gen_array_nitems(modules), i;
      FILE *out = safe_fopen(finit_name, "a");
      for (i=0; i<n; i++)
        {
          string name = gen_array_item(modules, i);
          if (same_string_p((const char*)module_name, (const char*)compilation_unit_of_module(name)) &&
              !same_string_p(module_name, name) &&
              !step_analysed_module_p(name))
            {
              statement stmt = make_plain_continue_statement();
              statement_declarations(stmt) = CONS(ENTITY, module_name_to_entity(name), NIL);
              fprint_statement(out, stmt);
              free_statement(stmt);
            }
        }
      safe_fclose(out, finit_name);
    }
  pips_debug(1, "end\n");
}

References asprintf, assert, compilation_unit_of_module(), compilation_unit_p(), concatenate(), CONS, db_get_current_workspace_directory(), db_get_memory_resource(), db_get_module_list_initial_order(), ENTITY, fortran_module_p(), fprint_statement(), free_statement(), gen_array_item(), gen_array_nitems(), local_name_to_top_level_entity(), make_plain_continue_statement(), module, module_name(), module_name_to_entity(), NIL, out, pips_debug, safe_copy(), safe_fclose(), safe_fopen(), safe_system(), same_string_p, statement_declarations, and step_analysed_module_p().

Referenced by step_compile().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_basic_workchunk()

statement step_directive_basic_workchunk

(

step_directive

d

)

Definition at line 286 of file directives.c.

{
  statement stmt = step_directive_block(d);
  pips_debug(3, "begin\n");
 
  switch(step_directive_type(d))
    {
    case STEP_DO:
    case STEP_PARALLEL_DO:
      {
        // on retourne le corps de boucle
        list block = statement_block(stmt);
        pips_assert("1 statement", gen_length(block) == 1);
 
        stmt = STATEMENT(CAR(block));
 
        if(statement_loop_p(stmt))
          stmt = loop_body(statement_loop(stmt));
        else if (statement_forloop_p(stmt))
          stmt = forloop_body(statement_forloop(stmt));
        else
          pips_assert("not a loop", false);
        break;
      }
    default:
      {
        // on retourne le block de la directive
      }
    }
 
  pips_debug(3, "end\n");
  return stmt;
}

References CAR, forloop_body, gen_length(), loop_body, pips_assert, pips_debug, STATEMENT, statement_block(), statement_forloop(), statement_forloop_p(), statement_loop(), statement_loop_p(), step_directive_block, step_directive_type, STEP_DO, and STEP_PARALLEL_DO.

Referenced by compute_directive_regions(), and step_print_directives_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_basic_workchunk_index()

list step_directive_basic_workchunk_index

(

step_directive

d

)

Definition at line 320 of file directives.c.

{
  list index_l = NIL;
  statement stmt = step_directive_block(d);
 
  pips_debug(4, "begin\n");
  switch(step_directive_type(d))
    {
    case STEP_DO:
    case STEP_PARALLEL_DO:
      {
        list block = statement_block(stmt);
        pips_assert("1 statement", gen_length(block) == 1);
 
        stmt = STATEMENT(CAR(block));
 
        if(statement_loop_p(stmt))
          index_l = CONS(ENTITY, loop_index(statement_loop(stmt)), index_l);
        else if (statement_forloop_p(stmt))
          {
            expression init = forloop_initialization(statement_forloop(stmt));
            pips_assert("an assignment", assignment_expression_p(init));
            list assign_params = call_arguments(syntax_call(expression_syntax(init)));
            expression lhs = EXPRESSION(CAR(assign_params));
            entity e = expression_to_entity(lhs);
            pips_assert("an entity", !entity_undefined_p(e));
            index_l = CONS(ENTITY, e, index_l);
          }
        else
          pips_assert("not a loop", false);
        break;
      }
    default:
      {
        // on retourne la liste vide
      }
    }
 
  pips_debug(4, "end\n");
  return gen_nreverse(index_l);
}

References assignment_expression_p(), call_arguments, CAR, CONS, ENTITY, entity_undefined_p, EXPRESSION, expression_syntax, expression_to_entity(), forloop_initialization, gen_length(), gen_nreverse(), init, loop_index, NIL, pips_assert, pips_debug, STATEMENT, statement_block(), statement_forloop(), statement_forloop_p(), statement_loop(), statement_loop_p(), step_directive_block, step_directive_type, STEP_DO, STEP_PARALLEL_DO, and syntax_call.

Referenced by step_compute_step_interlaced().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_print()

void step_directive_print

(

step_directive

d

)

Definition at line 362 of file directives.c.

{
  int type = step_directive_type(d);
  list clauses = step_directive_clauses(d);
  string begin_txt, end_txt;
  bool is_fortran = fortran_module_p(get_current_module_entity());
  bool is_block_construct = step_directive_to_strings(d, is_fortran, &begin_txt, &end_txt);
 
  pips_debug(1, "begin ====> TYPE %d : \nNB clauses : %d\n\tdirective begin : %s\n",
             type, (int)gen_length(clauses), begin_txt);
  if (is_block_construct && !empty_comments_p(end_txt)) pips_debug(1,"\tdirective end : %s\n", end_txt);
 
  ifdebug(1)
    {
      statement stmt = step_directive_block(d);
      assert(!statement_undefined_p(stmt));
      pips_debug(1, "----> on statement :\n");
      print_statement(stmt);
      pips_debug(1, "\n");
    }
  /*
  ifdebug(2)
    {
      statement stmt = step_directive_basic_workchunk(d);
      assert(!statement_undefined_p(stmt));
 
      string index_str=strdup("");
      FOREACH(ENTITY, e , step_directive_basic_workchunk_index(d))
        {
          string previous = index_str;
          index_str = strdup(concatenate(previous, entity_local_name(e), " ", NULL));
          free(previous);
        }
      pips_debug(2, "\n----> basic workchunk (index : [%s] )\n", index_str);
      print_statement(stmt);
      pips_debug(2, "\n");
      }
  */
  pips_debug(1, "end\n");
}

References assert, empty_comments_p(), fortran_module_p(), gen_length(), get_current_module_entity(), ifdebug, pips_debug, print_statement(), statement_undefined_p, step_directive_block, step_directive_clauses, step_directive_to_strings(), and step_directive_type.

Referenced by compile_rewrite(), compute_directive_regions(), and step_directives_print().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_to_strings()

bool step_directive_to_strings	(	step_directive	d,
		bool	is_fortran,
		string *	begin_txt,
		string *	end_txt
	)

clause

transformation clause is not printed

Parameters

is_fortran	s_fortran
begin_txt	egin_txt
end_txt	nd_txt

Definition at line 147 of file directives.c.

{
  bool block_directive = true;
  bool end_directive = is_fortran;
 
  string directive_txt = string_undefined;
  switch(step_directive_type(d))
    {
    case STEP_PARALLEL:
      directive_txt = strdup("parallel");
      break;
    case STEP_DO:
      directive_txt = strdup(is_fortran?"do":"for");
      block_directive = is_fortran;
      break;
    case STEP_PARALLEL_DO:
      directive_txt = strdup(is_fortran?"parallel do":"parallel for");
      block_directive = is_fortran;
      break;
    case STEP_MASTER:
      directive_txt = strdup("master");
      break;
    case STEP_SINGLE:
      directive_txt = strdup("single");
      break;
    case STEP_BARRIER:
      directive_txt = strdup("barrier");
      block_directive = false;
      end_directive = false;
      break;
    case STEP_THREADPRIVATE:
      directive_txt = strdup("threadprivate");
      block_directive = false;
      end_directive = false;
      break;
    default:
      pips_internal_error("unpexpected step directive type");
    }
 
  /*  clause */
  set copyin_l = set_make(set_pointer);
  set private_l = set_make(set_pointer);
  set shared_l = set_make(set_pointer);
  set threadprivate_l = set_make(set_pointer);
  set firstprivate_l = set_make(set_pointer);
  list schedule_l = list_undefined;
  bool nowait = false;
 
  int op;
  set reductions_l[STEP_UNDEF_REDUCE];
  for(op=0; op<STEP_UNDEF_REDUCE; op++)
    reductions_l[op] = set_make(set_pointer);
 
  FOREACH(STEP_CLAUSE, c, step_directive_clauses(d))
    {
      switch (step_clause_tag(c))
        {
        case is_step_clause_copyin:
          set_append_list(copyin_l, step_clause_copyin(c));
          break;
        case is_step_clause_private:
          set_append_list(private_l, step_clause_private(c));
          break;
        case is_step_clause_shared:
          set_append_list(shared_l, step_clause_shared(c));
          break;
        case is_step_clause_threadprivate:
          set_append_list(threadprivate_l, step_clause_threadprivate(c));
          break;
        case is_step_clause_firstprivate:
          set_append_list(firstprivate_l, step_clause_firstprivate(c));
          break;
        case is_step_clause_nowait:
          nowait = true;
          break;
        case is_step_clause_reduction:
          MAP_ENTITY_INT_MAP(variable, op, {
              set_add_element(reductions_l[op], reductions_l[op], variable);
            }, step_clause_reduction(c));
          break;
        case is_step_clause_schedule:
          schedule_l = step_clause_schedule(c);
          break;
        case is_step_clause_transformation:
          /* transformation clause is not printed */
          break;
        default: assert(0);
        }
    }
 
 
  if(end_directive)
    *end_txt = strdup(concatenate("omp end ",directive_txt, nowait?" nowait":"", NULL));
  else
    *end_txt = string_undefined;
 
  string_buffer sb = string_buffer_make(false);
  string_buffer_cat(sb, strdup("omp "), strdup(directive_txt), NULL);
 
  SB_LIST_VARIABLE(sb, copyin_l, " copyin(");
  SB_LIST_VARIABLE(sb, private_l, " private(");
  SB_LIST_VARIABLE(sb, shared_l, " shared(");
  SB_LIST_VARIABLE(sb, threadprivate_l, "(");
  SB_LIST_VARIABLE(sb, firstprivate_l, " firstprivate(");
 
  if(!list_undefined_p(schedule_l))
    {
      string s = string_undefined;
      FOREACH(STRING, str, schedule_l)
        {
          if(s == string_undefined)
            s=strdup(concatenate(" schedule(", str, NULL));
          else
            s=strdup(concatenate(", ", str, NULL));
          string_buffer_append(sb, s);
        }
      string_buffer_append(sb, strdup(")"));
    }
 
  string op_txt[STEP_UNDEF_REDUCE]={" reduction(*: "," reduction(max: "," reduction(min: "," reduction(+: "};
  for(op=0; op<STEP_UNDEF_REDUCE; op++)
    SB_LIST_VARIABLE(sb, reductions_l[op], op_txt[op]);
 
  if(nowait && !end_directive)
    string_buffer_append(sb, strdup(" nowait"));
 
  *begin_txt = string_buffer_to_string(sb);
  string_buffer_free_all(&sb);
 
  ifdebug(4)
    {
      printf("ÞÞÞÞÞÞÞÞÞ directive begin : %s\n", *begin_txt);
      printf("ÞÞÞÞÞÞÞÞÞ directive end : %s\n", end_directive?*end_txt:"");
    }
 
  return block_directive;
}

References assert, concatenate(), directive_txt, end_directive(), FOREACH, ifdebug, is_step_clause_copyin, is_step_clause_firstprivate, is_step_clause_nowait, is_step_clause_private, is_step_clause_reduction, is_step_clause_schedule, is_step_clause_shared, is_step_clause_threadprivate, is_step_clause_transformation, list_undefined, list_undefined_p, MAP_ENTITY_INT_MAP, pips_internal_error, printf(), SB_LIST_VARIABLE, set_add_element(), set_append_list(), set_make(), set_pointer, STEP_BARRIER, STEP_CLAUSE, step_clause_copyin, step_clause_firstprivate, step_clause_private, step_clause_reduction, step_clause_schedule, step_clause_shared, step_clause_tag, step_clause_threadprivate, step_directive_clauses, step_directive_type, STEP_DO, STEP_MASTER, STEP_PARALLEL, STEP_PARALLEL_DO, STEP_SINGLE, STEP_THREADPRIVATE, STEP_UNDEF_REDUCE, strdup(), STRING, string_buffer_append(), string_buffer_cat(), string_buffer_free_all(), string_buffer_make(), string_buffer_to_string(), and string_undefined.

Referenced by compile_omp(), and step_directive_print().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directive_type_print()

void step_directive_type_print

(

step_directive

drt

)

Parameters

drt

rt

Definition at line 51 of file directives.c.

{
  switch(step_directive_type(drt))
    {
    case STEP_PARALLEL:
      pips_debug(1, "step_directive_type = STEP_PARALLEL\n");
      break;
    case STEP_PARALLEL_DO:
      pips_debug(1, "step_directive_type = STEP_PARALLEL_DO\n");
      break;
    case STEP_DO:
      pips_debug(1, "step_directive_type = STEP_DO\n");
      break;
    case STEP_MASTER:
      pips_debug(1, "step_directive_type = STEP_MASTER\n");
      break;
    case STEP_BARRIER:
      pips_debug(1, "step_directive_type = STEP_BARRIER\n");
      break;
    case STEP_THREADPRIVATE:
      pips_debug(1, "step_directive_type = STEP_THREADPRIVATE\n");
      break;
    default:
      pips_debug(1, "step_directive_type = UNKNOWN\n");
      break;
    }
}

References pips_debug, STEP_BARRIER, step_directive_type, STEP_DO, STEP_MASTER, STEP_PARALLEL, STEP_PARALLEL_DO, and STEP_THREADPRIVATE.

Referenced by compile_body().

Here is the caller graph for this function:

step_directives_bound_p()

bool step_directives_bound_p

(

statement

stmt

)

Parameters

stmt

tmt

Definition at line 121 of file directives.c.

{
  return bound_directives_p(stmt);
}

Referenced by compile_filter(), compile_rewrite(), compute_SENDRECV_regions(), end_omp_construct(), get_current_step_directive(), sequence_rewrite(), statement_filter(), step_compute_CHAINS_DG_SENDRECV_regions(), and step_statement_path_first_directive_statement().

Here is the caller graph for this function:

step_directives_init()

void step_directives_init

(

bool

first_p

)

Parameters

first_p

irst_p

Definition at line 88 of file directives.c.

{
  pips_debug(4, "begin first_p = %d\n", first_p);
 
  if (first_p)
    init_directives();
  else
    {
      const char *module_name = entity_user_name(get_current_module_entity());
      set_directives((step_directives)db_get_memory_resource(DBR_STEP_DIRECTIVES, module_name, true));
    }
 
  pips_debug(4, "end\n");
}

References db_get_memory_resource(), entity_user_name(), get_current_module_entity(), module_name(), and pips_debug.

Referenced by step_analyse(), step_compile_analysed_module(), and step_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directives_load()

step_directive step_directives_load

(

statement

stmt

)

Parameters

stmt

tmt

Definition at line 116 of file directives.c.

{
  return load_directives(stmt);
}

Referenced by compile_filter(), compile_rewrite(), compute_SENDRECV_regions(), end_omp_construct(), get_current_step_directive(), and step_private_p().

Here is the caller graph for this function:

step_directives_print()

void step_directives_print

(

void

)

Definition at line 79 of file directives.c.

{
  STEP_DIRECTIVES_MAP(block_stmt, d,
                      {
                        assert(!statement_undefined_p(block_stmt));
                        step_directive_print(d);
                      }, get_directives()); 
}

References assert, statement_undefined_p, step_directive_print(), and STEP_DIRECTIVES_MAP.

Referenced by step_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directives_reset()

void step_directives_reset

(

void

)

Definition at line 103 of file directives.c.

{
  reset_directives();
}

Referenced by step_analyse(), and step_compile_analysed_module().

Here is the caller graph for this function:

step_directives_save()

void step_directives_save

(

void

)

Definition at line 108 of file directives.c.

{
  const char *module_name = entity_user_name(get_current_module_entity());
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_DIRECTIVES, module_name, get_directives());
  reset_directives();
}

References DB_PUT_MEMORY_RESOURCE, entity_user_name(), get_current_module_entity(), and module_name().

Referenced by step_parser().

Here is the call graph for this function:

Here is the caller graph for this function:

step_directives_store()

void step_directives_store	(	statement	stmt,
		step_directive	d
	)

Parameters

stmt

tmt

Definition at line 126 of file directives.c.

{
  assert(statement_block_p(stmt));
  store_directives(stmt, d);
}

References assert, and statement_block_p.

Referenced by new_step_directive().

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_install()

bool step_install

(

const string

program_name

)

install.c

install.c

This file is part of STEP.

The program is distributed under the terms of the GNU General Public License.

Generation des fichiers sources dans workspace.database/Src/

Instalation des fichiers generes

Parameters

program_name

rogram_name

Definition at line 15 of file install.c.

{
  debug_on("STEP_INSTALL_DEBUG_LEVEL");
  pips_debug(1, "Starting for program \"%s\".\n", program_name);
 
  /* Generation des fichiers sources dans workspace.database/Src/ */
  string dest_dir = db_get_directory_name_for_module(WORKSPACE_SRC_SPACE);
  gen_array_t modules = db_get_module_list_initial_order();
  int n = gen_array_nitems(modules), i;
  hash_table user_files = hash_table_make(hash_string, 2*n);
 
  for (i=0; i<n; i++)
    {
      string module_name = gen_array_item(modules, i);
      string user_file = db_get_memory_resource(DBR_USER_FILE, module_name, true);
      string new_file = hash_get(user_files, user_file);
      if (new_file == HASH_UNDEFINED_VALUE)
        {
          string base_name = pips_basename(user_file, NULL);
          new_file = strdup(concatenate(dest_dir, "/", base_name, NULL));
          hash_put(user_files, user_file, new_file);
        }
 
      string step_file = db_get_memory_resource(DBR_STEP_FILE, module_name, true);
 
 
 
      pips_debug(1, "Module: \"%s\"\n\tuser_file: \"%s\"\n\tinstall file : \"%s\"\n", module_name, user_file, new_file);
      FILE *out = safe_fopen(new_file, "a");
      FILE *in = safe_fopen(step_file, "r");
 
      safe_cat(out, in);
 
      safe_fclose(out, new_file);
      safe_fclose(in, step_file);
    }
 
  hash_table_free(user_files);
  free(dest_dir);
 
  /* Instalation des fichiers generes */
  dest_dir = strdup(get_string_property("STEP_INSTALL_PATH"));
  string src_dir = db_get_directory_name_for_module(WORKSPACE_SRC_SPACE);
  if (empty_string_p(dest_dir))
    {
      free(dest_dir);
      dest_dir = db_get_directory_name_for_module(WORKSPACE_SRC_SPACE);
    }
 
  safe_system(concatenate("step_install ", dest_dir, " ", src_dir,  NULL));
 
  free(src_dir);
  free(dest_dir);
 
  debug_off();
  return true;
}

References concatenate(), db_get_directory_name_for_module(), db_get_memory_resource(), db_get_module_list_initial_order(), debug_off, debug_on, empty_string_p(), free(), gen_array_item(), gen_array_nitems(), get_string_property(), hash_get(), hash_put(), hash_string, hash_table_free(), hash_table_make(), HASH_UNDEFINED_VALUE, module_name(), out, pips_basename(), pips_debug, safe_cat(), safe_fclose(), safe_fopen(), safe_system(), strdup(), user_file, user_files, and WORKSPACE_SRC_SPACE.

Here is the call graph for this function:

step_interlaced_p()

bool step_interlaced_p

(

effect

)

analyse.c

step_lexeralloc()

void* step_lexeralloc

(

yy_size_t

)

step_lexererror()

void step_lexererror

(

const char *

s

)

step_bison_parser.c

Definition at line 105 of file step_bison_parser.c.

{
  pips_user_error("\nParsing :\n%s\n%s at '%s'\n", pragma_str_original, s, step_lexertext);
}

References pips_user_error, pragma_str_original, and step_lexertext.

step_lexerfree()

void step_lexerfree

(

void *

)

step_lexerget_debug()

int step_lexerget_debug

(

void

)

step_lexerget_in()

FILE* step_lexerget_in

(

void

)

step_lexerget_leng()

int step_lexerget_leng

(

void

)

step_lexerget_lineno()

int step_lexerget_lineno

(

void

)

step_lexerget_out()

FILE* step_lexerget_out

(

void

)

step_lexerget_text()

char* step_lexerget_text

(

void

)

step_lexerlex()

int step_lexerlex

(

void

)

step_lexerlex_destroy()

int step_lexerlex_destroy

(

void

)

step_lexerparse()

int step_lexerparse

(

void

)

Referenced by step_bison_parse().

Here is the caller graph for this function:

step_lexerpop_buffer_state()

void step_lexerpop_buffer_state

(

void

)

step_lexerrealloc()

void* step_lexerrealloc	(	void *	,
		yy_size_t
	)

step_lexerrestart()

void step_lexerrestart

(

FILE *

)

step_lexerset_debug()

void step_lexerset_debug

(

int

)

step_lexerset_in()

void step_lexerset_in

(

FILE *

)

step_lexerset_lineno()

void step_lexerset_lineno

(

int

)

step_lexerset_out()

void step_lexerset_out

(

FILE *

)

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_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_parser()

bool step_parser

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 594 of file parser.c.

{
  debug_on("STEP_PARSER_DEBUG_LEVEL");
  pips_debug(1, "%d module_name = %s\n", __LINE__, module_name);
 
  statement stmt = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
  stmt = make_block_statement(CONS(STATEMENT, stmt, NIL));
 
  set_current_module_entity(local_name_to_top_level_entity(module_name));
 
  step_directives_init(1);
 
  step_directive_parser(stmt);
 
  ifdebug(1)
    {
      step_directives_print();
    }
 
  step_directives_save();
  reset_current_module_entity();
 
 
  module_reorder(stmt);
  if(ordering_to_statement_initialized_p())
    reset_ordering_to_statement();
 
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, stmt);
 
  pips_debug(1, "End step_parser\n");
  debug_off();
 
  return true;
}

References CONS, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, ifdebug, local_name_to_top_level_entity(), make_block_statement(), module_name(), module_reorder(), NIL, ordering_to_statement_initialized_p(), pips_debug, reset_current_module_entity(), reset_ordering_to_statement(), set_current_module_entity(), STATEMENT, step_directive_parser(), step_directives_init(), step_directives_print(), and step_directives_save().

Here is the call graph for this function:

step_partial_p()

bool step_partial_p

(

effect

)

step_private_p()

bool step_private_p	(	statement	stmt,
		entity	e
	)

Parameters

stmt

tmt

Definition at line 424 of file directives.c.

{
  pips_debug(4, "begin\n");
  step_directive d = step_directives_load(stmt);
  list private_l;
  private_l = step_directive_omp_get_private_entities(d);
  pips_debug(4, "end\n");
  return gen_in_list_p(e, private_l);
}

References gen_in_list_p(), pips_debug, step_directive_omp_get_private_entities(), and step_directives_load().

Referenced by create_step_regions().

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:

store_step_comm()

void store_step_comm

(

void

)

Definition at line 206 of file analyse.c.

{
  step_comm comms = (step_comm)db_get_memory_resource(DBR_STEP_COMM, "", true);
 
  step_comm_path(comms) = get_step_effect_path();
  step_comm_interlaced(comms) = get_step_interlaced();
  step_comm_partial(comms) = get_step_partial();
 
  DB_PUT_MEMORY_RESOURCE(DBR_STEP_COMM, "", comms);
 
  reset_step_effect_path();
  reset_step_interlaced();
  reset_step_partial();
}

References db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, step_comm_interlaced, step_comm_partial, and step_comm_path.

Referenced by step_analyse().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

comment2pragma_flex_debug

int comment2pragma_flex_debug

extern

comment2pragmain

FILE* comment2pragmain

extern

comment2pragmaleng

int comment2pragmaleng

extern

comment2pragma.c

comment2pragmalineno

int comment2pragmalineno

extern

comment2pragmaout

FILE* comment2pragmaout

extern

comment2pragmatext

char* comment2pragmatext

extern

step_created_entity

set step_created_entity

extern

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

extern

Definition at line 276 of file compile_RT.c.

Referenced by step_add_created_symbolic(), and update_referenced_entities().

step_lexer_flex_debug

int step_lexer_flex_debug

extern

step_lexerchar

int step_lexerchar

extern

step_lexerdebug

int step_lexerdebug

extern

step_lexerin

FILE* step_lexerin

extern

step_lexerleng

int step_lexerleng

extern

step_lexer.c

step_lexerlineno

int step_lexerlineno

extern

step_lexernerrs

int step_lexernerrs

extern

step_lexerout

FILE* step_lexerout

extern

step_lexertext

char* step_lexertext

extern

Referenced by step_lexererror().