manage_pragma.c File Reference

This file holds transformations on OpenMP pragmas store in the RI as extension expression. More...

#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "pipsdbm.h"
#include "properties.h"
#include "ri.h"
#include "ri-util.h"
#include "text-util.h"
#include "prettyprint.h"
#include "control.h"
#include "accel-util.h"
#include "callgraph.h"
#include "effects-generic.h"
#include "semantics.h"
#include "effects-convex.h"

Include dependency graph for manage_pragma.c:

Go to the source code of this file.

Data Structures
struct	context

Macros
#define	statement_has_this_pragma_string_p(stmt, str)    (get_extension_from_statement_with_pragma(stmt,str)!=NULL)

Functions
bool	statement_has_omp_parallel_directive_p (statement s)
	manage_pragma.c More...
bool	pragma_omp_p (pragma p)
	Check that a pragma is an "omp" one. More...
static void	build_omp_pragma_list (extensions exts, list *l_pragma)
	Callback for gen_recurse that build a list of OpenMP pragma to be merged. More...
static bool	inner_filter (loop l, bool *inner_flag)
static void	inner_rewrite (loop l, bool *inner_flag)
static bool	build_outer (loop l, list *l_outer)
static void	merge_on_outer (list l_outer)
	merge the omp pragma on the most outer parallel loop More...
static void	build_iteration_list (range r, list *l_iters)
static void	add_loop_parallel_threshold (pragma pr)
	add a if condition to the omp pragma More...
bool	omp_merge_pragma (const char *module_name)
	merge the pragma on the outer loop More...
bool	omp_loop_parallel_threshold_set (const char *module_name)
void	clear_pragma_on_statement (statement s)
	Remove all pragma attached to a given statement. More...
bool	clear_pragma (const char *module_name)
	Clear all pragma This should be done on any input with unhandled pragma, we don't what semantic we might break... More...
bool	outline_stmts_between_pragmas_in_sequence (sequence s, void *_ctx)
bool	pragma_outliner (char *module_name)

Detailed Description

This file holds transformations on OpenMP pragmas store in the RI as extension expression.

Here is the list of transformations: 1- add an OpenMP if clause 2- Merge nested OpenMP clause

Definition in file manage_pragma.c.

Macro Definition Documentation

statement_has_this_pragma_string_p

#define statement_has_this_pragma_string_p	(		stmt,
			str
	)		(get_extension_from_statement_with_pragma(stmt,str)!=NULL)

Definition at line 439 of file manage_pragma.c.

Function Documentation

add_loop_parallel_threshold()

static void add_loop_parallel_threshold ( pragma  pr )

static

add a if condition to the omp pragma

Returns

void

Parameters

pr,the

pragma to process

Definition at line 249 of file manage_pragma.c.

                                                   {
 
  // FI: untested code
  //entity m = module_name_to_entity(db_get_current_module_name());
  //language pl = module_language(m);
  language pl = get_prettyprint_language();
 
  // only the pragma as expressions are managed
  if(pragma_expression_p (pr) == true) {
    // we need to get the loop index
    statement stmt = (statement) gen_get_ancestor(statement_domain, pr);
    instruction inst = statement_instruction (stmt);
    if(instruction_loop_p(inst)) {
      // The list of number of iteration (as expression) to be used in the if clause
      list l_iters = NIL;
      loop l = instruction_loop (inst);
      // evaluate the number of iteration according to the property value
      if(get_bool_property("OMP_IF_CLAUSE_RECURSIVE") == true) {
        // collect the number of iteration of current loop and inner loops
        gen_context_recurse(stmt, &l_iters,
          range_domain, gen_true2, build_iteration_list);
      } else {
        // get the number of iteration of the current loop only
        expression iter = range_to_expression(loop_range (l), range_to_nbiter);
        l_iters = gen_expression_cons(iter, l_iters);
      }
      // now we have a list of number of iteration we need to multiply them
      entity mul = CreateIntrinsic(MULTIPLY_OPERATOR_NAME);
      expression cond = expressions_to_operation(l_iters, mul);
      // compare the nb iteration to the threshold
      cond = pragma_build_if_condition(cond, pl);
      // encapsulate the condition into the if clause
      expression expr_if = pragma_if_as_expr(cond);
      // bind the clause to the pragma
      add_expr_to_pragma_expr_list(pr, expr_if);
      // free list
      gen_free_list(l_iters);
    }
  }
  return;
}

References add_expr_to_pragma_expr_list(), build_iteration_list(), CreateIntrinsic(), expressions_to_operation(), gen_context_recurse, gen_expression_cons(), gen_free_list(), gen_get_ancestor(), gen_true2(), get_bool_property(), get_prettyprint_language(), instruction_loop, instruction_loop_p, loop_range, MULTIPLY_OPERATOR_NAME, NIL, pl, pragma_build_if_condition(), pragma_expression_p, pragma_if_as_expr(), range_domain, range_to_expression(), range_to_nbiter, statement_domain, and statement_instruction.

Referenced by omp_loop_parallel_threshold_set().

Here is the call graph for this function:

Here is the caller graph for this function:

build_iteration_list()

static void build_iteration_list ( range  r, list *  l_iters  )

static

Definition at line 241 of file manage_pragma.c.

                                                         {
  expression iter = range_to_expression(r, range_to_nbiter);
  *l_iters = gen_expression_cons(iter, *l_iters);
}

References gen_expression_cons(), range_to_expression(), and range_to_nbiter.

Referenced by add_loop_parallel_threshold().

Here is the call graph for this function:

Here is the caller graph for this function:

build_omp_pragma_list()

static void build_omp_pragma_list ( extensions  exts, list *  l_pragma  )

static

Callback for gen_recurse that build a list of OpenMP pragma to be merged.

Also remove them from the list they currently belongs to. It'll ignore string pragma (at that time, all that aren't generated by PIPS). A pragma that begin with "omp" in the original code will lead to a warning It'll ignore all pragma that are not begining with "omp".

Definition at line 108 of file manage_pragma.c.

                                                                   {
  list tmp = NIL;
  list l_exts = extensions_extension (exts);
  FOREACH(EXTENSION, ext, l_exts) {
    // today extension is only pragma but can be something else in the future
    // a test will have to be done
    // if (extension_is_pragma_p ())
    pragma p = extension_pragma (ext);
    if(pragma_omp_p(p)) {
      if(!pragma_expression_p(p)) {
        pips_user_warning("We have an omp string pragma, we don't know yet to "
        "parse it and thus it'll be ignored.\n");
      } else {
        // We record it so that we'll remove it from current stmt list later
        tmp = gen_extension_cons(ext, tmp);
        // Record in global list
        *l_pragma = gen_pragma_cons(p, *l_pragma);
        pips_debug(5, "adding pragma : %s for merging\n", pragma_to_string (p));
      }
    } else {
      pips_debug(5,
                 "Ignore pragma : %s, it's not an openmp one !\n",
                 pragma_to_string (p));
    }
  }
  // remove the extensions that will be merger at outer level
  gen_list_and_not(&l_exts, tmp);
  // update the extensions field
  extensions_extension (exts) = l_exts;
}

References EXTENSION, extension_pragma, extensions_extension, FOREACH, gen_extension_cons(), gen_list_and_not(), gen_pragma_cons(), NIL, pips_debug, pips_user_warning, pragma_expression_p, pragma_omp_p(), and pragma_to_string().

Referenced by merge_on_outer().

Here is the call graph for this function:

Here is the caller graph for this function:

build_outer()

static bool build_outer ( loop  l, list *  l_outer  )

static

Definition at line 183 of file manage_pragma.c.

                                               {
  statement stmt = (statement) gen_get_ancestor(statement_domain, l);
  list l_exts = extensions_extension (statement_extensions (stmt));
 
  FOREACH(EXTENSION, ext, l_exts) {
    // today extension is only pragma but can be something else in the future
    // a test will have to be done
    // if (extension_is_pragma_p ())
    pragma pr = extension_pragma (ext);
    pips_debug(5, "processing pragma : %s\n", pragma_to_string (pr));
    // only the pragma as expressions are managed
    if(pragma_expression_p (pr) == true) {
      *l_outer = gen_statement_cons(stmt, *l_outer);
      pips_debug(5, "outer pragma as expression found\n");
      return false;
    }
  }
  return true;
}

References EXTENSION, extension_pragma, extensions_extension, FOREACH, gen_get_ancestor(), gen_statement_cons(), pips_debug, pragma_expression_p, pragma_to_string(), statement_domain, and statement_extensions.

Referenced by omp_merge_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_pragma()

bool clear_pragma

(

const char *

module_name

)

Clear all pragma This should be done on any input with unhandled pragma, we don't what semantic we might break...

Put the new CODE ressource into PIPS:

Parameters

module_name

odule_name

Definition at line 403 of file manage_pragma.c.

                                           {
  debug_on("CLEAR_PRAGMA_DEBUG_LEVEL");
  statement mod_stmt = statement_undefined;
  // Get the code and tell PIPS_DBM we do want to modify it
  mod_stmt = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  // Set the current module entity and the current module statement that are
  // required to have many things working in PIPS
  set_current_module_statement(mod_stmt);
  set_current_module_entity(module_name_to_entity(module_name));
 
  // Add the parallel threshold to all the omp for pragmas
  gen_recurse(mod_stmt, statement_domain, gen_true, clear_pragma_on_statement);
 
  /* Put the new CODE ressource into PIPS: */
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, mod_stmt);
 
  // There is no longer a current module:
  reset_current_module_statement();
  reset_current_module_entity();
 
  pips_debug(2, "done for %s\n", module_name);
  debug_off();
 
  return true;
}

References clear_pragma_on_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, gen_recurse, gen_true(), module_name(), module_name_to_entity(), pips_debug, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), statement_domain, and statement_undefined.

Here is the call graph for this function:

clear_pragma_on_statement()

void clear_pragma_on_statement

(

statement

s

)

Remove all pragma attached to a given statement.

Definition at line 388 of file manage_pragma.c.

                                            {
  list exs = extensions_extension(statement_extensions(s));
  list keep_exs = NIL;
  FOREACH(EXTENSION, ex, exs) {
    if(!extension_pragma_p(ex))
      keep_exs = CONS(EXTENSION,ex,keep_exs);
  }
  extensions_extension(statement_extensions(s)) = keep_exs;
  gen_free_list(exs);
}

References CONS, EXTENSION, extension_pragma_p, extensions_extension, FOREACH, gen_free_list(), NIL, and statement_extensions.

Referenced by clear_pragma(), is_SCOP_rich(), and outline_stmts_between_pragmas_in_sequence().

Here is the call graph for this function:

Here is the caller graph for this function:

inner_filter()

static bool inner_filter ( loop  l, bool *  inner_flag  )

static

Definition at line 141 of file manage_pragma.c.

                                                   {
  pips_debug(5, "processing loop : %p.\n", (void*) l);
  *inner_flag = true;
  return true;
}

References pips_debug.

Referenced by omp_merge_pragma().

Here is the caller graph for this function:

inner_rewrite()

static void inner_rewrite ( loop  l, bool *  inner_flag  )

static

Definition at line 149 of file manage_pragma.c.

                                                    {
  statement stmt = (statement) gen_get_ancestor(statement_domain, l);
  extensions exts = statement_extensions (stmt);
  list l_exts = extensions_extension (exts);
  list tmp = NIL;
 
  FOREACH(EXTENSION, ext, l_exts) {
    // today extension is only pragma but can be something else in the future
    // a test will have to be done
    // if (extension_is_pragma_p ())
    if(*inner_flag == true) {
      // this is the inner pragma we have to keep it so set the flag to false
      // to remove next extensions and exit
      pips_debug(5,
                 "keeping pragma : %s from extensions %p.\n",
                 pragma_to_string (extension_pragma (ext)), (void*) exts);
      *inner_flag = false;
      return;
    } else {
      // we need to remove that extension because it is not an inner one
      tmp = gen_extension_cons(ext, tmp);
      pips_debug(5,
                 "removing pragma : %s from extensions %p.\n",
                 pragma_to_string (extension_pragma (ext)), (void*) exts);
    }
    //}
  }
  gen_list_and_not(&l_exts, tmp);
  // update the extensions field
  extensions_extension (exts) = l_exts;
  return;
}

References EXTENSION, extension_pragma, extensions_extension, FOREACH, gen_extension_cons(), gen_get_ancestor(), gen_list_and_not(), NIL, pips_debug, pragma_to_string(), statement_domain, and statement_extensions.

Referenced by omp_merge_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_on_outer()

static void merge_on_outer ( list  l_outer )

static

merge the omp pragma on the most outer parallel loop

Returns

void

Definition at line 205 of file manage_pragma.c.

                                         {
 
  // FI: untested code
  //entity m = module_name_to_entity(db_get_current_module_name());
  //language l = module_language(m);
  language l = get_prettyprint_language();
 
  FOREACH(STATEMENT, stmt, l_outer) {
    // The list of pragma to be merged
    list l_pragma = NIL;
    list outer_extensions =
        gen_copy_seq(extensions_extension(statement_extensions(stmt)));
    // collect the pragma and detach them from their statement
    gen_context_recurse(stmt, &l_pragma,
      extensions_domain, gen_true2, build_omp_pragma_list);
    list l_expr = pragma_omp_merge_expr(outer_extensions, l_pragma, l);
    gen_free_list(outer_extensions);
 
    // We have to removed locally declared variables from the pragma clause,
    // else generated code won't compile !
    list locally_decls = statement_to_declarations(stmt);
    ifdebug(4) {
      pips_debug(4, "Filter out local variables from pragma : ");
      print_entities(locally_decls);
      fprintf(stderr, "\n");
    }
    l_expr = filter_variables_in_pragma_expr(l_expr, locally_decls);
    gen_free_list(locally_decls);
 
    // The pragma can now be added to the statement
    add_pragma_expr_to_statement(stmt, l_expr);
    gen_free_list(l_pragma);
  }
  return;
}

References add_pragma_expr_to_statement(), build_omp_pragma_list(), extensions_domain, extensions_extension, filter_variables_in_pragma_expr(), FOREACH, fprintf(), gen_context_recurse, gen_copy_seq(), gen_free_list(), gen_true2(), get_prettyprint_language(), ifdebug, NIL, pips_debug, pragma_omp_merge_expr(), print_entities(), STATEMENT, statement_extensions, and statement_to_declarations().

Referenced by omp_merge_pragma().

Here is the call graph for this function:

Here is the caller graph for this function:

omp_loop_parallel_threshold_set()

bool omp_loop_parallel_threshold_set

(

const char *

module_name

)

Should never arise

Put the new CODE ressource into PIPS:

Parameters

module_name

odule_name

Definition at line 351 of file manage_pragma.c.

                                                              {
  debug_on("OPMIFY_CODE_DEBUG_LEVEL");
  statement mod_stmt = statement_undefined;
  // Get the code and tell PIPS_DBM we do want to modify it
  mod_stmt = (statement) db_get_memory_resource(DBR_CODE, module_name, true);
 
  // Set the current module entity and the current module statement that are
  // required to have many things working in PIPS
  set_current_module_statement(mod_stmt);
  set_current_module_entity(module_name_to_entity(module_name));
 
  // generate pragma string or expression using the correct language:
  value mv = entity_initial(module_name_to_entity(module_name));
  if(value_code_p(mv)) {
    code c = value_code(mv);
    set_prettyprint_language_from_property(language_tag(code_language(c)));
  } else {
    /* Should never arise */
    set_prettyprint_language_from_property(is_language_fortran);
  }
 
  // Add the parallel threshold to all the omp for pragmas
  gen_recurse(mod_stmt, pragma_domain, gen_true, add_loop_parallel_threshold);
 
  /* Put the new CODE ressource into PIPS: */
  DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, mod_stmt);
  // There is no longer a current module:
  reset_current_module_statement();
  reset_current_module_entity();
 
  pips_debug(2, "done for %s\n", module_name);
  debug_off();
 
  return true;
}

References add_loop_parallel_threshold(), code_language, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, entity_initial, gen_recurse, gen_true(), is_language_fortran, language_tag, module_name(), module_name_to_entity(), pips_debug, pragma_domain, reset_current_module_entity(), reset_current_module_statement(), set_current_module_entity(), set_current_module_statement(), set_prettyprint_language_from_property(), statement_undefined, value_code, and value_code_p.

Here is the call graph for this function:

omp_merge_pragma()

bool omp_merge_pragma

(

const char *

module_name

)

merge the pragma on the outer loop

Should never arise

Parameters

module_name

odule_name

Definition at line 297 of file manage_pragma.c.

                                               {
  // Use this module name and this environment variable to set
  statement mod_stmt = PIPS_PHASE_PRELUDE(module_name,
      "OPMIFY_CODE_DEBUG_LEVEL");
 
  /* // generate pragma string or expression using the correct language: */
  value mv = entity_initial(module_name_to_entity(module_name));
  if(value_code_p(mv)) {
    code c = value_code(mv);
    set_prettyprint_language_from_property(language_tag(code_language(c)));
  } else {
    /* Should never arise */
    set_prettyprint_language_from_property(is_language_fortran);
  }
 
  // getting the properties to configure the phase
  const char* merge_policy = get_string_property("OMP_MERGE_POLICY");
  bool outer = (strcmp(merge_policy, "outer") == 0);
 
  // The list of outer loop as a list of statements
  list l_outer = NIL;
 
  // build the list of outer loop with pragma this is also needed by the
  // inner mode
  gen_context_recurse(mod_stmt, &l_outer,
                      loop_domain, build_outer, gen_null2);
 
  if(outer == true) {
    pips_debug(3, "outer mode\n");
    // merge the pragma on the outer loop
    merge_on_outer(l_outer);
  } else { //inner
    pips_debug(3, "inner mode\n");
    // The inner flag
    bool inner_flag = true;
    FOREACH(statement, stmt, l_outer)
    {
      gen_context_recurse(stmt,
                          &inner_flag,
                          loop_domain,
                          inner_filter,
                          inner_rewrite);
    }
  }
 
  // freeing memory
  gen_free_list(l_outer);
 
  //Put back the new statement module
  PIPS_PHASE_POSTLUDE(mod_stmt);
 
  return true;
}

References build_outer(), code_language, entity_initial, FOREACH, gen_context_recurse, gen_free_list(), gen_null2(), get_string_property(), inner_filter(), inner_rewrite(), is_language_fortran, language_tag, loop_domain, merge_on_outer(), module_name(), module_name_to_entity(), NIL, pips_debug, PIPS_PHASE_POSTLUDE, PIPS_PHASE_PRELUDE, set_prettyprint_language_from_property(), value_code, and value_code_p.

Here is the call graph for this function:

outline_stmts_between_pragmas_in_sequence()

bool outline_stmts_between_pragmas_in_sequence	(	sequence	s,
		void *	_ctx
	)

Parameters

_ctx

ctx

Definition at line 454 of file manage_pragma.c.

                                                                       {
  // Cast of the void pointer
  context *ctx = (context *) _ctx;
  // Are we in a SCoP of the code ?
  bool in_scop = false;
  // A list of the statements contained in the sequence
  list stmts = sequence_statements(s);
  list stmts_to_outline = NIL;
 
  FOREACH(statement, stmt, stmts) {
    // Flag that check if we are at the end of a list of stmts to outline
    bool has_to_outline_p = false;
    // If we are not already in a SCoP of the code and if the statement is preceded
    // by pragma_start
    // Else if we are already in a SCoP of the code and if the statement is followed
    //by pragma_end 
    if(!in_scop && statement_has_this_pragma_string_p(stmt,ctx->pragma_begin)) {
      in_scop = true;
      clear_pragma_on_statement(stmt);
    } else if(in_scop
        && statement_has_this_pragma_string_p(stmt,ctx->pragma_end)) {
      in_scop = false;
      has_to_outline_p = true;
      clear_pragma_on_statement(stmt);
    }
    // If we are in a SCoP : create an one-element statement list (cons) containing stmt 
    if(in_scop) {
      stmts_to_outline = CONS(STATEMENT, stmt, stmts_to_outline );
    }
    // ENDP : true if list is empty, false if is a cons
    if(has_to_outline_p && !ENDP(stmts_to_outline)) {
      // Reverse the order of the list
      stmts_to_outline = gen_nreverse(stmts_to_outline);
      string func_name = build_new_top_level_module_name(ctx->prefix, false);
      // Here we call the outliner on the collected statements
      outliner(func_name, stmts_to_outline);
      // Free the list of statement so that we can continue to build one
      gen_free_list(stmts_to_outline);
      stmts_to_outline = NIL;
 
      // Mark that a substitution have been done
      ctx->outline_done = true;
    }
  }
  if(in_scop) {
    pips_user_warning("End of a sequence with a sentinel starting SCoP pragma "
    "(%s) but did not encountered any pragma end (%s)\n",
                      ctx->pragma_begin, ctx->pragma_end);
  }
  return true;
}

References build_new_top_level_module_name(), clear_pragma_on_statement(), CONS, ENDP, FOREACH, gen_free_list(), gen_nreverse(), NIL, context::outline_done, outliner(), pips_user_warning, context::pragma_begin, context::pragma_end, context::prefix, sequence_statements, STATEMENT, and statement_has_this_pragma_string_p.

Referenced by pragma_outliner().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_omp_p()

bool pragma_omp_p

(

pragma

p

)

Check that a pragma is an "omp" one.

Definition at line 78 of file manage_pragma.c.

                            {
  bool pragma_omp = false;
  if(pragma_expression_p(p)) {
    list expr = pragma_expression(p);
    // The list is reversed !
    expression begin = EXPRESSION(CAR(gen_last(expr)));
    if(expression_call_p(begin)) {
      entity called = call_function(expression_call(begin));
      if(same_string_p(OMP_OMP_FUNCTION_NAME,entity_local_name(called) )) {
        pragma_omp = true;
      }
    }
  } else if(pragma_string_p(p)) {
    if(strncasecmp("omp", pragma_string(p), 3) == 0) {
      pragma_omp = true;
    }
  } else {
    pips_internal_error("We don't know how to handle this kind of pragma !\n");
  }
  return pragma_omp;
}

References call_function, CAR, entity_local_name(), EXPRESSION, expression_call(), expression_call_p(), gen_last(), OMP_OMP_FUNCTION_NAME, pips_internal_error, pragma_expression, pragma_expression_p, pragma_string, pragma_string_p, and same_string_p.

Referenced by build_omp_pragma_list().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_outliner()

bool pragma_outliner

(

char *

module_name

)

Parameters

module_name

odule_name

Definition at line 512 of file manage_pragma.c.

                                         {
  // Standard procedure for phases
  set_current_module_entity(local_name_to_top_level_entity(module_name));
 
  set_current_module_statement((statement) db_get_memory_resource(DBR_CODE,
                                                                  module_name,
                                                                  true));
  statement module_stat = get_current_module_statement();
 
  // Needed for outliner !
  set_cumulated_rw_effects((statement_effects) db_get_memory_resource(DBR_CUMULATED_EFFECTS,
                                                                      module_name,
                                                                      true));
  set_proper_rw_effects((statement_effects) db_get_memory_resource(DBR_PROPER_EFFECTS,
                                                                      module_name,
                                                                      true));
  // Needed for outliner using option OUTLINE_SMART_REFERENCE_COMPUTATION TRUE
  set_rw_effects((statement_effects)db_get_memory_resource(DBR_REGIONS, module_name, true));
  // Needed for induction variable removal
  module_to_value_mappings(get_current_module_entity());
  set_transformer_map((statement_mapping)db_get_memory_resource(DBR_TRANSFORMERS, module_name, true));
  set_precondition_map((statement_mapping)db_get_memory_resource(DBR_PRECONDITIONS, module_name, true));
  
  set_methods_for_convex_effects();
 
  // Recursion context
  // Getting the parameters of the pragmas in order to be able to parse them later
  context ctx;
  ctx.pragma_begin = (string) get_string_property("PRAGMA_OUTLINER_BEGIN");
  ctx.pragma_end = (string) get_string_property("PRAGMA_OUTLINER_END");
  ctx.prefix = (string) get_string_property("PRAGMA_OUTLINER_PREFIX");
  ctx.outline_done = false;
  // Recurse over sequence
  gen_context_recurse(module_stat, &ctx,
    sequence_domain, outline_stmts_between_pragmas_in_sequence, gen_null2);
  // If a substitution has been done correctly, we put the new resources
  if(ctx.outline_done) {
    DB_PUT_MEMORY_RESOURCE(DBR_CALLEES,
                           module_name,
                           compute_callees(module_stat));
 
    DB_PUT_MEMORY_RESOURCE(DBR_CODE, module_name, module_stat);
  }
  // Standard procedure for reseting after a phase
  reset_rw_effects();
  generic_effects_reset_all_methods();
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  reset_current_module_entity();
  reset_current_module_statement();
  reset_precondition_map();
  reset_transformer_map();
  free_value_mappings();
  return true;
}

References compute_callees(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, free_value_mappings(), gen_context_recurse, gen_null2(), generic_effects_reset_all_methods(), get_current_module_entity(), get_current_module_statement(), get_string_property(), local_name_to_top_level_entity(), module_name(), module_to_value_mappings(), context::outline_done, outline_stmts_between_pragmas_in_sequence(), context::pragma_begin, context::pragma_end, context::prefix, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_rw_effects(), reset_transformer_map(), sequence_domain, set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_methods_for_convex_effects(), set_precondition_map(), set_proper_rw_effects(), set_rw_effects(), and set_transformer_map().

Here is the call graph for this function:

statement_has_omp_parallel_directive_p()

bool statement_has_omp_parallel_directive_p

(

statement

s

)

manage_pragma.c

Definition at line 52 of file manage_pragma.c.

                                                         {
  bool found = false;
  FOREACH(EXTENSION, ex, extensions_extension(statement_extensions(s))) {
    pragma p = extension_pragma(ex);
    if(pragma_string_p(p)) {
      string ps = pragma_string(p);
      if((found = (strstr(ps, "omp parallel") || strstr(ps, "OMP PARALLEL"))))
        goto found;
    } else if(pragma_expression_p(p)) {
      FOREACH(EXPRESSION, pe, pragma_expression(p))
      {
        if(expression_call_p(pe)) {
          call c = expression_call(pe);
          if((found = (same_entity_p(call_function(c),
                                     CreateIntrinsic(OMP_OMP_FUNCTION_NAME)))))
            goto found;
        }
      }
    }
  }
  found: return found;
}

References call_function, CreateIntrinsic(), EXPRESSION, expression_call(), expression_call_p(), EXTENSION, extension_pragma, extensions_extension, FOREACH, OMP_OMP_FUNCTION_NAME, pragma_expression, pragma_expression_p, pragma_string, pragma_string_p, same_entity_p(), and statement_extensions.

Here is the call graph for this function: