pragma.c File Reference

#include "linear.h"
#include "genC.h"
#include "misc.h"
#include "ri.h"
#include "naming.h"
#include "ri-util.h"
#include "properties.h"

Include dependency graph for pragma.c:

Go to the source code of this file.

Functions
static bool	is_expression_omp_private_p (expression exp)
static bool	is_expression_omp_if_p (expression exp)
static bool	is_expression_omp_reduction_p (expression exp)
static bool	is_expression_omp_omp_p (expression exp)
static bool	is_expression_omp_for_p (expression exp)
static bool	is_expression_omp_parallel_p (expression exp)
static if_clause_policy	get_if_clause_policy (void)
static expression	merge_conditions (list l_cond, if_clause_policy policy, language l)
expression	pragma_build_if_condition (expression cond, language l)
	build the expression to be put in the if clause. More...
expression	pragma_if_as_expr (expression arg)
expression	pragma_private_as_expr_with_args (list args_expr)
expression	pragma_private_as_expr (list args_ent)
list	pragma_omp_parallel_as_exprs (void)
list	pragma_omp_parallel_for_as_exprs (void)
list	filter_variables_in_pragma_expr (list l_expr, list to_filter)
	filter out a pragma (expression list) removing all requested variables @params l_expr is the list of expressions to filter @params to_filter is the list of entities to remove from l_pragma More...
list	pragma_omp_merge_expr (list outer_extensions, list l_pragma, language l)
	merge omp pragma. More...
void	add_pragma_str_to_statement (statement st, const char *s, bool copy_flag)
	Add a string as a pragma to a statement. More...
void	add_pragma_strings_to_statement (statement st, list l, bool copy_flag)
	Add a list of strings as as many pragmas to a statement. More...
void	add_pragma_expr_to_statement (statement st, list l)
	Add a pragma as a list of expression to a statement. More...

Variables
const string	FORTRAN_PRAGMA_HEADER = FORTRAN_PRAGMA_HEADER_STRING
	pragma.c More...
const string	FORTRAN_OMP_CONTINUATION = FORTRAN_OMP_CONTINUATION_STRING

Function Documentation

add_pragma_expr_to_statement()

void add_pragma_expr_to_statement	(	statement	st,
		list	l
	)

Add a pragma as a list of expression to a statement.

Returns

void

Parameters

st,the	statement on which we want to add a pragma
l,the	list of expression.

Make a new pragma:

Add the new pragma to the extension list:

extern string pragma_to_string(pragma);

string str = pragma_to_string (p);

if (str != string_undefined)

pips_debug (5, "pragma : %s added\n", str);

Parameters

st

t

Definition at line 460 of file pragma.c.

                                                   {
  extensions es = statement_extensions(st);
  /* Make a new pragma: */
  pragma p = pragma_undefined;
  p = make_pragma_expression(l);
  extension e = make_extension_pragma(p);
  /* Add the new pragma to the extension list: */
  list el = extensions_extension(es);
  el = gen_extension_cons(e, el);
  extensions_extension(es) = el;
  ifdebug (5) {
    // This is debugging code. It creates a cycle between ri-util and prettyprint
    /* extern string pragma_to_string(pragma); */
    /* string str = pragma_to_string (p); */
    /* if (str != string_undefined) */
    /*   pips_debug (5, "pragma : %s added\n", str); */
    ;
  }
}

References extensions_extension, gen_extension_cons(), ifdebug, make_extension_pragma(), make_pragma_expression(), pragma_undefined, and statement_extensions.

Referenced by merge_on_outer(), omp_pragma_expr_for(), and omp_pragma_expr_for_reduction().

Here is the call graph for this function:

Here is the caller graph for this function:

add_pragma_str_to_statement()

void add_pragma_str_to_statement	(	statement	st,
		const char *	s,
		bool	copy_flag
	)

Add a string as a pragma to a statement.

Returns

void

Parameters

st,the	statement on which we want to add a pragma
s,the	pragma string.
copy_flag,to	be set to true to duplicate the string

Duplicate string if requested

dangerous !

Make a new pragma

Will be save as an extension attached to the statement's extension list

Parameters

st	t
copy_flag	opy_flag

Definition at line 425 of file pragma.c.

                                                                              {
  /* Duplicate string if requested */
  string ps = copy_flag ? strdup(s) : (char*)s /* dangerous !*/;
 
  /* Make a new pragma */
  pragma p = make_pragma_string(ps);
 
  /* Will be save as an extension attached to
   * the statement's extension list
   */
  extensions es = statement_extensions(st);
  extension e = make_extension_pragma(p);
  list el = extensions_extension(es);
  el = gen_extension_cons(e, el);
  extensions_extension(es) = el;
}

References extensions_extension, gen_extension_cons(), make_extension_pragma(), make_pragma_string(), statement_extensions, and strdup().

Referenced by add_pragma(), add_pragma_strings_to_statement(), add_pragma_to_sequence(), add_shutdown_pragma_to_return(), add_to_stmt(), compile_omp(), do_computation_intensity(), do_loop_expansion_init(), gen_omp_parallel(), gen_omp_taskwait(), gen_synchronization(), get_statement_pragma_init(), get_statement_pragma_register(), get_statement_pragma_shutdown(), insert_endscop_after_stmt(), insert_endscop_before_stmt(), insert_endscop_in_sequence(), insert_optional_pragma(), new_step_directive(), and normalize_microcode_anotate().

Here is the call graph for this function:

Here is the caller graph for this function:

add_pragma_strings_to_statement()

void add_pragma_strings_to_statement	(	statement	st,
		list	l,
		bool	copy_flag
	)

Add a list of strings as as many pragmas to a statement.

Parameters

st,the	statement on which we want to add a pragma
l,a	list of pragma string(s)
copy_flag,to	be set to true to duplicate the string

Parameters

st	t
copy_flag	opy_flag

Definition at line 448 of file pragma.c.

                                                                           {
  FOREACH(STRING, p, l)
    add_pragma_str_to_statement(st, p, copy_flag);
}

References add_pragma_str_to_statement(), FOREACH, and STRING.

Here is the call graph for this function:

filter_variables_in_pragma_expr()

list filter_variables_in_pragma_expr	(	list	l_expr,
		list	to_filter
	)

filter out a pragma (expression list) removing all requested variables @params l_expr is the list of expressions to filter @params to_filter is the list of entities to remove from l_pragma

ifdebug(5) {

pips_debug(5,"Handling expression : ");

print_expression(expr);

}

Parameters

l_expr	of expr
to_filter	of entities

Definition at line 256 of file pragma.c.

                                                      {
 
  // If all variable in exp are removed, we remove the expr from the list
  list expr_to_remove = NIL;
 
  FOREACH (EXPRESSION, expr, l_expr) {
    // Get the list of arguments, to filter out
    call c = expression_call(expr);
    list args = call_arguments (c);
 
    // The list where we will record arg to remove from args
    list entity_to_remove = NIL;
 
    // FI: to avoid cycles between librairies ri-util and prettyprint
    /* ifdebug(5) { */
    /*   pips_debug(5,"Handling expression : "); */
    /*   print_expression(expr); */
    /* } */
    if(is_expression_omp_private_p(expr)) {
      // Handle private omp clause
      // Lookup each requested entities
      FOREACH(ENTITY, e, to_filter)
      {
        FOREACH (EXPRESSION, exp, args)
        {
          pips_debug(6,"Matching %s against %s\n",entity_name(e),
              entity_name(expression_to_entity(exp)));
          if(expression_to_entity(exp) == e) {
            entity_to_remove = gen_expression_cons(exp, entity_to_remove);
            break;
          }
        }
      }
      FOREACH(EXPRESSION,exp,entity_to_remove)
      {
        gen_remove(&call_arguments(c), exp);
      }
      if(ENDP(call_arguments(c))) {
        expr_to_remove = gen_expression_cons(expr, expr_to_remove);
      }
    } else if(is_expression_omp_if_p(expr)) {
      // FIXME : todo, merge with previous case ?
    } else if(is_expression_omp_reduction_p(expr)) {
      // FIXME : shouldn't be a problem ! (handled before)
    } else if(is_expression_omp_omp_p(expr) || is_expression_omp_for_p(expr)
        || is_expression_omp_parallel_p(expr)) {
      // FIXME : is there anything to do here ?
    } else {
      pips_debug(0,"Unsupported case : ");
      // FI: to avoid cycles between librairies ri-util and prettyprint
      // print_expression(expr);
      pips_internal_error("We don't know how to handle this omp clause !");
    }
  }
  //Remove expression that are now empty
  FOREACH(EXPRESSION,expr,expr_to_remove) {
    gen_remove(&l_expr, expr);
  }
 
  return l_expr;
}

References call_arguments, ENDP, ENTITY, entity_name, exp, EXPRESSION, expression_call(), expression_to_entity(), FOREACH, gen_expression_cons(), gen_remove(), is_expression_omp_for_p(), is_expression_omp_if_p(), is_expression_omp_omp_p(), is_expression_omp_parallel_p(), is_expression_omp_private_p(), is_expression_omp_reduction_p(), NIL, pips_debug, and pips_internal_error.

Referenced by merge_on_outer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_if_clause_policy()

static if_clause_policy get_if_clause_policy ( void  )

static

Definition at line 88 of file pragma.c.

                                                    {
  if_clause_policy result = IGNORE_IF_POLICY;
  const char* prop = get_string_property ("OMP_IF_MERGE_POLICY");
  if (strcmp (prop, "ignore") == 0) {
    result = IGNORE_IF_POLICY;
  }
  else if (strcmp (prop, "or") == 0) {
    result = OR_IF_POLICY;
  }
  else if (strcmp (prop, "and") == 0) {
    result = AND_IF_POLICY;
  }
  return result;
}

References AND_IF_POLICY, get_string_property(), IGNORE_IF_POLICY, and OR_IF_POLICY.

Referenced by pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_omp_for_p()

static bool is_expression_omp_for_p ( expression  exp )

static

Definition at line 78 of file pragma.c.

                                                     {
  entity ent = expression_to_entity (exp);
  return ENTITY_OMP_FOR_P(ent);
}

References ENTITY_OMP_FOR_P, exp, and expression_to_entity().

Referenced by filter_variables_in_pragma_expr(), and pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_omp_if_p()

static bool is_expression_omp_if_p ( expression  exp )

static

Definition at line 63 of file pragma.c.

                                                    {
  entity ent = expression_to_entity (exp);
  return (ENTITY_OMP_IF_P (ent));
}

References ENTITY_OMP_IF_P, exp, and expression_to_entity().

Referenced by filter_variables_in_pragma_expr(), and pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_omp_omp_p()

static bool is_expression_omp_omp_p ( expression  exp )

static

Definition at line 73 of file pragma.c.

                                                     {
  entity ent = expression_to_entity (exp);
  return ENTITY_OMP_OMP_P(ent);
}

References ENTITY_OMP_OMP_P, exp, and expression_to_entity().

Referenced by filter_variables_in_pragma_expr(), and pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_omp_parallel_p()

static bool is_expression_omp_parallel_p ( expression  exp )

static

Definition at line 83 of file pragma.c.

                                                          {
  entity ent = expression_to_entity (exp);
  return ENTITY_OMP_PARALLEL_P(ent);
}

References ENTITY_OMP_PARALLEL_P, exp, and expression_to_entity().

Referenced by filter_variables_in_pragma_expr(), and pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_omp_private_p()

static bool is_expression_omp_private_p ( expression  exp )

static

Definition at line 58 of file pragma.c.

                                                         {
  entity ent = expression_to_entity (exp);
  return (ENTITY_OMP_PRIVATE_P (ent));
}

References ENTITY_OMP_PRIVATE_P, exp, and expression_to_entity().

Referenced by filter_variables_in_pragma_expr(), and pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_omp_reduction_p()

static bool is_expression_omp_reduction_p ( expression  exp )

static

Definition at line 68 of file pragma.c.

                                                           {
  entity ent = expression_to_entity (exp);
  return (ENTITY_OMP_REDUCTION_P (ent));
}

References ENTITY_OMP_REDUCTION_P, exp, and expression_to_entity().

Referenced by filter_variables_in_pragma_expr(), and pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_conditions()

static expression merge_conditions ( list  l_cond, if_clause_policy  policy, language  l  )

static

Definition at line 104 of file pragma.c.

                                                                                     {
  expression result = expression_undefined;
  entity op = entity_undefined;
  switch(policy) {
    case IGNORE_IF_POLICY:
      break;
    case AND_IF_POLICY:
      // switch(get_prettyprint_language_tag()) {
      switch(language_tag(l)) {
        case is_language_fortran:
        case is_language_fortran95:
          op = CreateIntrinsic(AND_OPERATOR_NAME);
          break;
        case is_language_c:
          op = CreateIntrinsic(C_AND_OPERATOR_NAME);
          break;
        default:
          pips_internal_error ("This case should have been handled before");
          break;
      }
      break;
    case OR_IF_POLICY:
      //switch(get_prettyprint_language_tag()) {
      switch(language_tag(l)) {
        case is_language_fortran:
        case is_language_fortran95:
          op = CreateIntrinsic(OR_OPERATOR_NAME);
          break;
        case is_language_c:
          op = CreateIntrinsic(C_OR_OPERATOR_NAME);
          break;
        default:
          pips_internal_error ("This case should have been handled before");
          break;
      }
      break;
    default:
      pips_internal_error ("update switch case");
      break;
  }
  // now we have a list of condition and an operator -> merge them
  result = expressions_to_operation(l_cond, op);
  return result;
}

References AND_IF_POLICY, AND_OPERATOR_NAME, C_AND_OPERATOR_NAME, C_OR_OPERATOR_NAME, CreateIntrinsic(), entity_undefined, expression_undefined, expressions_to_operation(), IGNORE_IF_POLICY, is_language_c, is_language_fortran, is_language_fortran95, language_tag, OR_IF_POLICY, OR_OPERATOR_NAME, and pips_internal_error.

Referenced by pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_build_if_condition()

expression pragma_build_if_condition	(	expression	cond,
		language	l
	)

build the expression to be put in the if clause.

This functions takes care of the output language.

Returns

the condition compared to the threshold as an expression

Parameters

cond,the

condition to be compared to the threshold

Parameters

cond

ond

Definition at line 159 of file pragma.c.

                                                                  {
  entity op = entity_undefined;
  //switch(get_prettyprint_language_tag()) {
  switch(language_tag(l)) {
    case is_language_fortran:
    case is_language_fortran95:
      op = CreateIntrinsic(GREATER_OR_EQUAL_OPERATOR_NAME);
      break;
    case is_language_c:
      op = CreateIntrinsic(C_GREATER_OR_EQUAL_OPERATOR_NAME);
      break;
    default:
      pips_internal_error ("This case should have been handled before" );
      break;
  }
  int threshold = get_int_property("OMP_LOOP_PARALLEL_THRESHOLD_VALUE");
  list args_if = gen_expression_cons(int_to_expression(threshold), NIL);
  args_if = gen_expression_cons(cond, args_if);
  call c = make_call(op, args_if);
  return call_to_expression(c);
}

References C_GREATER_OR_EQUAL_OPERATOR_NAME, call_to_expression(), CreateIntrinsic(), entity_undefined, gen_expression_cons(), get_int_property(), GREATER_OR_EQUAL_OPERATOR_NAME, int_to_expression(), is_language_c, is_language_fortran, is_language_fortran95, language_tag, make_call(), NIL, and pips_internal_error.

Referenced by add_loop_parallel_threshold().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_if_as_expr()

expression pragma_if_as_expr

(

expression

arg

)

Returns

"if (cond)" as an expression

Parameters

arg,the

condition to be evaluted by the if clause

Parameters

arg

rg

Definition at line 184 of file pragma.c.

                                              {
  entity omp = CreateIntrinsic(OMP_IF_FUNCTION_NAME);
  list args_expr = gen_expression_cons (arg, NIL);
  call c = make_call (omp, args_expr);
  //  syntax s = make_syntax_call (c);
  expression expr_if = call_to_expression (c);// make_expression (s, normalized_undefined);
  return expr_if;
}

References call_to_expression(), CreateIntrinsic(), gen_expression_cons(), make_call(), NIL, and OMP_IF_FUNCTION_NAME.

Referenced by add_loop_parallel_threshold(), and pragma_omp_merge_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_omp_merge_expr()

list pragma_omp_merge_expr	(	list	outer_extensions,
		list	l_pragma,
		language	l
	)

merge omp pragma.

Returns

the merged pragma as a list of expression

Parameters

l_pragma,the

list of pragma to merge. The pragma as to be a list of expression ordered. The pragma list has to be ordered from the outer pragma to the inner pragma as in the original loop nest.

Parameters

outer_extensions	uter_extensions
l_pragma	_pragma

Definition at line 326 of file pragma.c.

                                                                              {
  // The "omp parallel for" as a list of expression
  list result = pragma_omp_parallel_for_as_exprs ();
  // The list of the variables of the private clauses
  list priv_var = NIL;
  // The list of condition of the if clauses
  list if_cond = NIL;
  // The list of reductions
  list red = NIL;
  // Get the if clause policy
  if_clause_policy policy = get_if_clause_policy ();
  // the outer pragmas
  set outer_pragmas = set_make(set_pointer);
  FOREACH(EXTENSION,ex, outer_extensions) {
      pragma p = extension_pragma(ex);
      if(pragma_expression_p(p)) {
          FOREACH(EXPRESSION, e, pragma_expression (p))
              set_add_element(outer_pragmas,outer_pragmas,e);
      }
  }
 
  // look into each pragma for private, reduction and if clauses
  FOREACH (PRAGMA, p, l_pragma) {
    pips_assert ("Can only merge a list of pragma as expression",
        pragma_expression_p (p));
    FOREACH (EXPRESSION, e, pragma_expression (p)) {
      // check each expression and save what need to be saved to generate
      // the new omp pragma
      call c = expression_call(e);
      list args = call_arguments (c);
      // bind the args to the right list
      if(is_expression_omp_private_p(e)) {
        // each private var has to be uniquely declared
        list add = NIL;
        FOREACH (EXPRESSION, exp, args) {
          if(!expression_equal_in_list_p(exp, priv_var) )
            add = gen_expression_cons(exp, add);
        }
        priv_var = gen_nconc(priv_var, add);
      } else if(is_expression_omp_if_p(e)) {
        // if clause : check the policy
        switch(policy) {
          case IGNORE_IF_POLICY:
            // do nothing
            break;
          case AND_IF_POLICY:
          case OR_IF_POLICY:
            if_cond = gen_nconc(if_cond, args);
            break;
          default:
            pips_internal_error ("Should not happen");
            break;
        }
      } else if(is_expression_omp_reduction_p(e)) {
          // only reductions on outer statement are kept
        if(set_belong_p(outer_pragmas,e) ) {
          red = gen_expression_cons(e, red);
        }
      } else if(is_expression_omp_omp_p(e) || is_expression_omp_for_p(e)
          || is_expression_omp_parallel_p(e)) {
        // nothing to do the omp parallel for will be automaticly generated
      } else {
        // FI: to avoid cycles between librairies ri-util and prettyprint
        // print_expression(e);
        pips_internal_error("pips cannot merge this pragma clause");
      }
    }
  }
  set_free(outer_pragmas);
  // build the private clause if needed
  if(priv_var != NIL) {
    expression priv = pragma_private_as_expr_with_args(priv_var);
    // append the private clause to the omp parallel for
    result = gen_expression_cons(priv, result);
  }
  // append the reduction clauses if any
  if(red != NIL) {
    result = gen_nconc(red, result);
  }
  // merge the if condition if needed
  if(policy != IGNORE_IF_POLICY) {
    expression expr_if = merge_conditions(if_cond, policy, l);
    // encapsulate the condition into the if clause
    expr_if = pragma_if_as_expr(expr_if);
    // append the if clause to the omp parallel for
    result = gen_expression_cons(expr_if, result);
  }
  return result;
}

References AND_IF_POLICY, call_arguments, exp, EXPRESSION, expression_call(), expression_equal_in_list_p(), EXTENSION, extension_pragma, FOREACH, gen_expression_cons(), gen_nconc(), get_if_clause_policy(), IGNORE_IF_POLICY, is_expression_omp_for_p(), is_expression_omp_if_p(), is_expression_omp_omp_p(), is_expression_omp_parallel_p(), is_expression_omp_private_p(), is_expression_omp_reduction_p(), merge_conditions(), NIL, OR_IF_POLICY, pips_assert, pips_internal_error, PRAGMA, pragma_expression, pragma_expression_p, pragma_if_as_expr(), pragma_omp_parallel_for_as_exprs(), pragma_private_as_expr_with_args(), set_add_element(), set_belong_p(), set_free(), set_make(), and set_pointer.

Referenced by merge_on_outer().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_omp_parallel_as_exprs()

list pragma_omp_parallel_as_exprs

(

void

)

Returns

"omp parallel" as a list of expression

Definition at line 215 of file pragma.c.

                                         {
  // first prepare "omp" as an expression
  entity omp = CreateIntrinsic(OMP_OMP_FUNCTION_NAME);
  call c = make_call (omp, NULL);
  syntax s = make_syntax_call (c);
  expression expr_omp = make_expression (s, normalized_undefined);
 
  //secondly prepare "parallel" as an expression
  entity parallel = CreateIntrinsic(OMP_PARALLEL_FUNCTION_NAME);
  c = make_call (parallel, NULL);
  s = make_syntax_call (c);
  expression expr_parallel = make_expression (s, normalized_undefined);
 
  // build the list of expression
  list result = CONS(EXPRESSION, expr_omp, NIL);
  result = gen_expression_cons (expr_parallel, result);
  return result;
}

References CONS, CreateIntrinsic(), EXPRESSION, gen_expression_cons(), make_call(), make_expression(), make_syntax_call(), NIL, normalized_undefined, OMP_OMP_FUNCTION_NAME, and OMP_PARALLEL_FUNCTION_NAME.

Referenced by pragma_omp_parallel_for_as_exprs().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_omp_parallel_for_as_exprs()

list pragma_omp_parallel_for_as_exprs

(

void

)

Returns

"omp parallel for" as an expression

Definition at line 236 of file pragma.c.

                                             {
  // first prepare "for" as an expression
  entity e = CreateIntrinsic(OMP_FOR_FUNCTION_NAME);
  call c = make_call (e, NULL);
  syntax s = make_syntax_call (c);
  expression expr_for = make_expression (s, normalized_undefined);
 
  //secondly get "omp parallel as an expr and concat
  list result = pragma_omp_parallel_as_exprs ();
  result = gen_expression_cons (expr_for, result);
 
  return result;
}

References CreateIntrinsic(), gen_expression_cons(), make_call(), make_expression(), make_syntax_call(), normalized_undefined, OMP_FOR_FUNCTION_NAME, and pragma_omp_parallel_as_exprs().

Referenced by omp_pragma_expr_for(), pragma_omp_merge_expr(), and reductions_get_omp_pragma_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_private_as_expr()

expression pragma_private_as_expr

(

list

args_ent

)

Returns

"private (x,y)" as an expression

Parameters

arg,the

private variables as a list of entities

Parameters

args_ent

rgs_ent

Definition at line 207 of file pragma.c.

                                                  {
  // build the privates variable as a list of expression
  list args_expr = entities_to_expressions (args_ent);
  return pragma_private_as_expr_with_args (args_expr);
}

References entities_to_expressions(), and pragma_private_as_expr_with_args().

Referenced by omp_append_private_clause().

Here is the call graph for this function:

Here is the caller graph for this function:

pragma_private_as_expr_with_args()

expression pragma_private_as_expr_with_args

(

list

args_expr

)

Returns

"private (x,y)" as an expression

Parameters

args_expr,the

private variables as a list of expression

Parameters

args_expr

rgs_expr

Definition at line 196 of file pragma.c.

                                                             {
  entity omp = CreateIntrinsic(OMP_PRIVATE_FUNCTION_NAME);
  call c = make_call (omp, args_expr);
  syntax s = make_syntax_call (c);
  expression expr_omp = make_expression (s, normalized_undefined);
  return expr_omp;
}

References CreateIntrinsic(), make_call(), make_expression(), make_syntax_call(), normalized_undefined, and OMP_PRIVATE_FUNCTION_NAME.

Referenced by pragma_omp_merge_expr(), and pragma_private_as_expr().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

FORTRAN_OMP_CONTINUATION

const string FORTRAN_OMP_CONTINUATION = FORTRAN_OMP_CONTINUATION_STRING

Definition at line 52 of file pragma.c.

FORTRAN_PRAGMA_HEADER

const string FORTRAN_PRAGMA_HEADER = FORTRAN_PRAGMA_HEADER_STRING

pragma.c

Definition at line 51 of file pragma.c.