[gomp] Rename GOMP_ -> OMP_
Diego Novillo
dnovillo@redhat.com
Fri Sep 23 15:50:00 GMT 2005
The idea is to use OMP_ for all the generic OpenMP things and use
GOMP_ for the runtime.
* c-common.h (c_finish_omp_for): Declare
* c-omp.c (c_finish_omp_for): Rename from c_finish_gomp_for
and move from ...
* c-typeck.c (c_finish_gomp_for): ... here.
* c-tree.h (c_finish_gomp_for): Remove.
* gimple-low.c: Rename gomp_* symbols into omp_*.
Update all users.
* gimplify.c: Likewise.
* tree.def: Rename GOMP_* tree codes to OMP_*.
Update all users.
* tree.h: Likewise.
fortran/
* trans-openmp.c: Rename GOMP_* tree codes into OMP_*.
Index: c-common.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-common.h,v
retrieving revision 1.294.4.4
diff -d -u -p -r1.294.4.4 c-common.h
--- c-common.h 22 Sep 2005 17:37:33 -0000 1.294.4.4
+++ c-common.h 23 Sep 2005 15:37:45 -0000
@@ -936,6 +936,7 @@ extern void c_finish_omp_ordered (tree);
extern void c_finish_omp_barrier (void);
extern void c_finish_omp_atomic (enum tree_code, tree, tree);
extern void c_finish_omp_flush (void);
+extern tree c_finish_omp_for (tree, tree, tree, tree, tree);
/* In order for the format checking to accept the C frontend
diagnostic framework extensions, you must include this file before
Index: c-omp.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Attic/c-omp.c,v
retrieving revision 1.1.2.3
diff -d -u -p -r1.1.2.3 c-omp.c
--- c-omp.c 23 Sep 2005 02:21:27 -0000 1.1.2.3
+++ c-omp.c 23 Sep 2005 15:37:45 -0000
@@ -321,3 +321,173 @@ c_finish_omp_flush (void)
x = build_function_call_expr (x, NULL);
add_stmt (x);
}
+
+
+/* Validate and emit code for the OpenMP directive #pragma omp for.
+ INIT, COND, INCR and BODY are the four basic elements of the loop
+ (initialization expression, controlling predicate, increment
+ expression and body of the loop). CLAUSES is the set of data
+ sharing and copying clauses found at the start of the directive. */
+
+tree
+c_finish_omp_for (tree init, tree cond, tree incr, tree body, tree clauses)
+{
+ bool found;
+ tree t, loop_ix = NULL_TREE;
+
+ /* Validate the form of the loop. It must be of the form (OpenMP
+ public spec v2.5)
+
+ for (init-expr; var relop b; incr-expr)
+
+ init-expr One of the following
+ var = lb
+ integer-type var = lb
+
+ incr-expr One of the following
+ ++var
+ var++
+ --var
+ var--
+ var += incr
+ var -= incr
+ var = var + incr
+ var = incr + var
+ var = var - incr
+
+ var A signed integer variable. If it was shared,
+ it is implicitly made private. It may only be
+ modified inside incr-expr. After the loop its
+ value is indeterminate, unles it is marked
+ lastprivate.
+
+ relop One of <, <=, > or >=
+
+ lb, b, incr Loop invariant integer expressions. There is
+ no synchronization during the evaluation of
+ these expressions. Th order, frequency and
+ side-effects of these expressions are
+ unspecified. */
+ if (cond == NULL_TREE)
+ {
+ error ("missing controlling predicate in %<omp for%> loop");
+ return NULL_TREE;
+ }
+ else
+ {
+ bool cond_ok = false;
+
+ if (TREE_CODE (cond) == LT_EXPR
+ || TREE_CODE (cond) == LE_EXPR
+ || TREE_CODE (cond) == GT_EXPR
+ || TREE_CODE (cond) == GE_EXPR)
+ {
+ loop_ix = TREE_OPERAND (cond, 0);
+ if (DECL_P (loop_ix))
+ cond_ok = true;
+ }
+
+ if (!cond_ok)
+ {
+ error ("invalid controlling predicate in %<omp for%> loop");
+ return NULL_TREE;
+ }
+ }
+
+ /* If we got to this point, we must have a loop index variable. */
+ gcc_assert (loop_ix);
+
+ if (incr == NULL_TREE)
+ {
+ error ("missing increment expression in %<omp for%> loop");
+ return NULL_TREE;
+ }
+ else
+ {
+ bool incr_ok = false;
+ enum tree_code code = TREE_CODE (incr);
+
+ /* Check all the valid increment expressions: v++, v--, ++v, --v,
+ v = v + incr, v = incr + v and v = v - incr. */
+ if ((code == POSTINCREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
+ || (code == PREINCREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
+ || (code == POSTDECREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
+ || (code == PREDECREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
+ || (code == MODIFY_EXPR
+ && TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
+ && (TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == loop_ix
+ || TREE_OPERAND (TREE_OPERAND (incr, 1), 1) == loop_ix))
+ || (code == MODIFY_EXPR
+ && TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR
+ && TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == loop_ix))
+ incr_ok = true;
+
+ if (!incr_ok)
+ {
+ error ("invalid increment expression in %<omp for%> loop");
+ return NULL_TREE;
+ }
+ }
+
+ if (init == NULL_TREE)
+ {
+ if (flag_isoc99)
+ {
+ /* Only in C99 may the init expression be empty. If the
+ loop index variable has a DECL_INITIAL expression, use it
+ to build the OMP_FOR_INIT operand. */
+ if (DECL_INITIAL (loop_ix))
+ init = build (MODIFY_EXPR, TREE_TYPE (loop_ix),
+ loop_ix, DECL_INITIAL (loop_ix));
+ }
+
+ if (init == NULL_TREE)
+ {
+ error ("missing initialization expression in %<omp for%> loop");
+ return NULL_TREE;
+ }
+ }
+
+ /* The loop controlling variable is always private. Add it to the
+ list of private clauses. */
+ found = false;
+ for (t = clauses; t; t = TREE_CHAIN (t))
+ {
+ tree clause = TREE_VALUE (t);
+
+ if (TREE_CODE (clause) == OMP_CLAUSE_PRIVATE)
+ {
+ tree n;
+
+ for (n = OMP_PRIVATE_VARS (clause); n; n = TREE_CHAIN (n))
+ {
+ tree v = TREE_VALUE (n);
+ if (v == loop_ix)
+ {
+ found = true;
+ break;
+ }
+ }
+
+ /* If LOOP_IX is not mentioned in a private clause, add it. */
+ if (!found)
+ {
+ OMP_PRIVATE_VARS (clause) =
+ tree_cons (NULL_TREE, loop_ix, OMP_PRIVATE_VARS (clause));
+ found = true;
+ break;
+ }
+ }
+ }
+
+ /* If we did not even have a private clause, add one. */
+ if (!found)
+ clauses = tree_cons (NULL_TREE,
+ build (OMP_CLAUSE_PRIVATE,
+ NULL_TREE,
+ tree_cons (NULL_TREE, loop_ix, NULL_TREE)),
+ clauses);
+
+ /* Build and return an OMP_FOR tree. */
+ return (build (OMP_FOR, void_type_node, clauses, init, cond, incr, body));
+}
Index: c-parser.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-parser.c,v
retrieving revision 2.17.4.14
diff -d -u -p -r2.17.4.14 c-parser.c
--- c-parser.c 23 Sep 2005 05:55:45 -0000 2.17.4.14
+++ c-parser.c 23 Sep 2005 15:37:46 -0000
@@ -4201,7 +4201,7 @@ c_parser_for_statement (c_parser *parser
c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true);
else
{
- tree t = c_finish_gomp_for (init, cond, incr, body, omp_clauses);
+ tree t = c_finish_omp_for (init, cond, incr, body, omp_clauses);
if (t)
add_stmt (t);
else
@@ -6725,7 +6725,7 @@ c_parser_omp_directive (c_parser *parser
{
case PRAGMA_OMP_PARALLEL:
stmt = c_parser_compound_statement (parser);
- add_stmt (build (GOMP_PARALLEL, void_type_node, clause, stmt));
+ add_stmt (build (OMP_PARALLEL, void_type_node, clause, stmt));
break;
case PRAGMA_OMP_FOR:
@@ -6916,7 +6916,7 @@ c_parser_pragma_omp_clause_copyin (c_par
{
tree vars = c_parser_pragma_omp_variable_list (parser);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
- add_new_clause (build (GOMP_CLAUSE_COPYIN, NULL_TREE, vars));
+ add_new_clause (build (OMP_CLAUSE_COPYIN, NULL_TREE, vars));
}
}
@@ -6930,7 +6930,7 @@ c_parser_pragma_omp_clause_copyprivate (
{
tree vars = c_parser_pragma_omp_variable_list (parser);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
- add_new_clause (build (GOMP_CLAUSE_COPYPRIVATE, NULL_TREE, vars));
+ add_new_clause (build (OMP_CLAUSE_COPYPRIVATE, NULL_TREE, vars));
}
}
@@ -6982,7 +6982,7 @@ c_parser_pragma_omp_clause_firstprivate
{
tree vars = c_parser_pragma_omp_variable_list (parser);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
- add_new_clause (build (GOMP_CLAUSE_FIRSTPRIVATE, NULL_TREE, vars));
+ add_new_clause (build (OMP_CLAUSE_FIRSTPRIVATE, NULL_TREE, vars));
}
}
@@ -6999,11 +6999,11 @@ c_parser_pragma_omp_clause_if (c_parser
/* At most one 'if' clause may appear in the directive. */
for (c = curr_clause_set; c; c = TREE_CHAIN (c))
- if (TREE_CODE (TREE_VALUE (c)) == GOMP_CLAUSE_IF)
+ if (TREE_CODE (TREE_VALUE (c)) == OMP_CLAUSE_IF)
error ("at most one %<if%> clause may appear in a parallel "
"directive");
- add_new_clause (build (GOMP_CLAUSE_IF, NULL_TREE, t));
+ add_new_clause (build (OMP_CLAUSE_IF, NULL_TREE, t));
}
else
{
@@ -7021,7 +7021,7 @@ c_parser_pragma_omp_clause_lastprivate (
{
tree vars = c_parser_pragma_omp_variable_list (parser);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
- add_new_clause (build (GOMP_CLAUSE_LASTPRIVATE, NULL_TREE, vars));
+ add_new_clause (build (OMP_CLAUSE_LASTPRIVATE, NULL_TREE, vars));
}
}
@@ -7052,11 +7052,11 @@ c_parser_pragma_omp_clause_num_threads (
/* At most one 'num_threads' clause may appear in the directive. */
for (c = curr_clause_set; c; c = TREE_CHAIN (c))
- if (TREE_CODE (TREE_VALUE (c)) == GOMP_CLAUSE_NUM_THREADS)
+ if (TREE_CODE (TREE_VALUE (c)) == OMP_CLAUSE_NUM_THREADS)
error ("at most one %<num_threads%> clause may appear "
"in a parallel directive");
- add_new_clause (build (GOMP_CLAUSE_NUM_THREADS, TREE_TYPE (t), t));
+ add_new_clause (build (OMP_CLAUSE_NUM_THREADS, TREE_TYPE (t), t));
}
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
@@ -7082,7 +7082,7 @@ c_parser_pragma_omp_clause_private (c_pa
{
tree vars = c_parser_pragma_omp_variable_list (parser);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
- add_new_clause (build (GOMP_CLAUSE_PRIVATE, NULL_TREE, vars));
+ add_new_clause (build (OMP_CLAUSE_PRIVATE, NULL_TREE, vars));
}
}
@@ -7227,7 +7227,7 @@ c_parser_pragma_omp_clause_shared (c_par
tree t, vars;
vars = c_parser_pragma_omp_variable_list (parser);
c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
- add_new_clause (build (GOMP_CLAUSE_SHARED, NULL_TREE, vars));
+ add_new_clause (build (OMP_CLAUSE_SHARED, NULL_TREE, vars));
/* Since we are going to be taking the address of shared
variables, mark them addressable early. */
Index: c-tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-tree.h,v
retrieving revision 1.203.4.5
diff -d -u -p -r1.203.4.5 c-tree.h
--- c-tree.h 22 Sep 2005 17:37:34 -0000 1.203.4.5
+++ c-tree.h 23 Sep 2005 15:37:46 -0000
@@ -573,7 +573,6 @@ extern tree c_finish_goto_ptr (tree);
extern void c_begin_vm_scope (unsigned int);
extern void c_end_vm_scope (unsigned int);
extern tree c_expr_to_decl (tree, bool *, bool *, bool *);
-extern tree c_finish_gomp_for (tree, tree, tree, tree, tree);
/* Set to 0 at beginning of a function definition, set to 1 if
a return statement that specifies a return value is seen. */
Index: c-typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v
retrieving revision 1.450.4.7
diff -d -u -p -r1.450.4.7 c-typeck.c
--- c-typeck.c 23 Sep 2005 02:21:27 -0000 1.450.4.7
+++ c-typeck.c 23 Sep 2005 15:37:47 -0000
@@ -8263,173 +8263,3 @@ c_expr_to_decl (tree expr, bool *tc ATTR
else
return expr;
}
-
-
-/* Validate and emit code for the OpenMP directive #pragma omp for.
- INIT, COND, INCR and BODY are the four basic elements of the loop
- (initialization expression, controlling predicate, increment
- expression and body of the loop). CLAUSES is the set of data
- sharing and copying clauses found at the start of the directive. */
-
-tree
-c_finish_gomp_for (tree init, tree cond, tree incr, tree body, tree clauses)
-{
- bool found;
- tree t, loop_ix = NULL_TREE;
-
- /* Validate the form of the loop. It must be of the form (OpenMP
- public spec v2.5)
-
- for (init-expr; var relop b; incr-expr)
-
- init-expr One of the following
- var = lb
- integer-type var = lb
-
- incr-expr One of the following
- ++var
- var++
- --var
- var--
- var += incr
- var -= incr
- var = var + incr
- var = incr + var
- var = var - incr
-
- var A signed integer variable. If it was shared,
- it is implicitly made private. It may only be
- modified inside incr-expr. After the loop its
- value is indeterminate, unles it is marked
- lastprivate.
-
- relop One of <, <=, > or >=
-
- lb, b, incr Loop invariant integer expressions. There is
- no synchronization during the evaluation of
- these expressions. Th order, frequency and
- side-effects of these expressions are
- unspecified. */
- if (cond == NULL_TREE)
- {
- error ("missing controlling predicate in %<omp for%> loop");
- return NULL_TREE;
- }
- else
- {
- bool cond_ok = false;
-
- if (TREE_CODE (cond) == LT_EXPR
- || TREE_CODE (cond) == LE_EXPR
- || TREE_CODE (cond) == GT_EXPR
- || TREE_CODE (cond) == GE_EXPR)
- {
- loop_ix = TREE_OPERAND (cond, 0);
- if (DECL_P (loop_ix))
- cond_ok = true;
- }
-
- if (!cond_ok)
- {
- error ("invalid controlling predicate in %<omp for%> loop");
- return NULL_TREE;
- }
- }
-
- /* If we got to this point, we must have a loop index variable. */
- gcc_assert (loop_ix);
-
- if (incr == NULL_TREE)
- {
- error ("missing increment expression in %<omp for%> loop");
- return NULL_TREE;
- }
- else
- {
- bool incr_ok = false;
- enum tree_code code = TREE_CODE (incr);
-
- /* Check all the valid increment expressions: v++, v--, ++v, --v,
- v = v + incr, v = incr + v and v = v - incr. */
- if ((code == POSTINCREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
- || (code == PREINCREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
- || (code == POSTDECREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
- || (code == PREDECREMENT_EXPR && TREE_OPERAND (incr, 0) == loop_ix)
- || (code == MODIFY_EXPR
- && TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
- && (TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == loop_ix
- || TREE_OPERAND (TREE_OPERAND (incr, 1), 1) == loop_ix))
- || (code == MODIFY_EXPR
- && TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR
- && TREE_OPERAND (TREE_OPERAND (incr, 1), 0) == loop_ix))
- incr_ok = true;
-
- if (!incr_ok)
- {
- error ("invalid increment expression in %<omp for%> loop");
- return NULL_TREE;
- }
- }
-
- if (init == NULL_TREE)
- {
- if (flag_isoc99)
- {
- /* Only in C99 may the init expression be empty. If the
- loop index variable has a DECL_INITIAL expression, use it
- to build the GOMP_FOR_INIT operand. */
- if (DECL_INITIAL (loop_ix))
- init = build (MODIFY_EXPR, TREE_TYPE (loop_ix),
- loop_ix, DECL_INITIAL (loop_ix));
- }
-
- if (init == NULL_TREE)
- {
- error ("missing initialization expression in %<omp for%> loop");
- return NULL_TREE;
- }
- }
-
- /* The loop controlling variable is always private. Add it to the
- list of private clauses. */
- found = false;
- for (t = clauses; t; t = TREE_CHAIN (t))
- {
- tree clause = TREE_VALUE (t);
-
- if (TREE_CODE (clause) == GOMP_CLAUSE_PRIVATE)
- {
- tree n;
-
- for (n = GOMP_PRIVATE_VARS (clause); n; n = TREE_CHAIN (n))
- {
- tree v = TREE_VALUE (n);
- if (v == loop_ix)
- {
- found = true;
- break;
- }
- }
-
- /* If LOOP_IX is not mentioned in a private clause, add it. */
- if (!found)
- {
- GOMP_PRIVATE_VARS (clause) =
- tree_cons (NULL_TREE, loop_ix, GOMP_PRIVATE_VARS (clause));
- found = true;
- break;
- }
- }
- }
-
- /* If we did not even have a private clause, add one. */
- if (!found)
- clauses = tree_cons (NULL_TREE,
- build (GOMP_CLAUSE_PRIVATE,
- NULL_TREE,
- tree_cons (NULL_TREE, loop_ix, NULL_TREE)),
- clauses);
-
- /* Build and return a GOMP_FOR tree. */
- return (build (GOMP_FOR, void_type_node, clauses, init, cond, incr, body));
-}
Index: gimple-low.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gimple-low.c,v
retrieving revision 2.24.4.10
diff -d -u -p -r2.24.4.10 gimple-low.c
--- gimple-low.c 23 Sep 2005 05:55:45 -0000 2.24.4.10
+++ gimple-low.c 23 Sep 2005 15:37:48 -0000
@@ -164,7 +164,7 @@ struct remap_info_d
splay_tree map;
/* Function holding the body of the OpenMP directive. */
- tree gomp_fn;
+ tree omp_fn;
/* Data sharing and copying clauses associated with this directive. */
tree clauses;
@@ -214,7 +214,7 @@ add_decls_to_set (bitmap *set_p, tree li
the corresponding sets in the remap info structure pointed by RI_P. */
static void
-process_gomp_clauses (tree clauses, struct remap_info_d *ri_p)
+process_omp_clauses (tree clauses, struct remap_info_d *ri_p)
{
tree c;
@@ -223,17 +223,17 @@ process_gomp_clauses (tree clauses, stru
tree clause = TREE_VALUE (c);
bitmap *set_p = NULL;
- if (TREE_CODE (clause) == GOMP_CLAUSE_PRIVATE)
+ if (TREE_CODE (clause) == OMP_CLAUSE_PRIVATE)
set_p = &ri_p->private;
- else if (TREE_CODE (clause) == GOMP_CLAUSE_SHARED)
+ else if (TREE_CODE (clause) == OMP_CLAUSE_SHARED)
set_p = &ri_p->shared;
- else if (TREE_CODE (clause) == GOMP_CLAUSE_FIRSTPRIVATE)
+ else if (TREE_CODE (clause) == OMP_CLAUSE_FIRSTPRIVATE)
set_p = &ri_p->firstprivate;
- else if (TREE_CODE (clause) == GOMP_CLAUSE_LASTPRIVATE)
+ else if (TREE_CODE (clause) == OMP_CLAUSE_LASTPRIVATE)
set_p = &ri_p->lastprivate;
- else if (TREE_CODE (clause) == GOMP_CLAUSE_COPYIN)
+ else if (TREE_CODE (clause) == OMP_CLAUSE_COPYIN)
set_p = &ri_p->copyin;
- else if (TREE_CODE (clause) == GOMP_CLAUSE_COPYPRIVATE)
+ else if (TREE_CODE (clause) == OMP_CLAUSE_COPYPRIVATE)
set_p = &ri_p->copyprivate;
if (set_p)
@@ -247,19 +247,19 @@ process_gomp_clauses (tree clauses, stru
/* Build and create a data sharing description structure to guide the
- remapping actions done in remap_locals_r. GOMP_FN is the function
+ remapping actions done in remap_locals_r. OMP_FN is the function
holding the body of the directive to be processed. CLAUSES is the
list of clauses controlling data sharing and copying. */
static struct remap_info_d *
-build_remap_info (tree gomp_fn, tree clauses)
+build_remap_info (tree omp_fn, tree clauses)
{
struct remap_info_d *ri_p;
/* Setup the mapping data. */
ri_p = xmalloc (sizeof (*ri_p));
memset (ri_p, 0, sizeof (*ri_p));
- ri_p->gomp_fn = gomp_fn;
+ ri_p->omp_fn = omp_fn;
ri_p->clauses = clauses;
ri_p->map = splay_tree_new (splay_tree_compare_pointers, 0, 0);
@@ -284,12 +284,12 @@ delete_remap_info (struct remap_info_d *
/* Given a private variable VAR, get the variable that will replace
- VAR inside the body of the function created for RI_P->GOMP_FN. If
+ VAR inside the body of the function created for RI_P->OMP_FN. If
VAR had not been mapped before, add it to the unexpanded variable
- list in ID->GOMP_FN. */
+ list in ID->OMP_FN. */
static tree
-get_gomp_private_ref (tree var, struct remap_info_d *ri_p)
+get_omp_private_ref (tree var, struct remap_info_d *ri_p)
{
tree repl;
splay_tree_node n;
@@ -297,7 +297,7 @@ get_gomp_private_ref (tree var, struct r
n = splay_tree_lookup (ri_p->map, (splay_tree_key) var);
if (n == NULL)
{
- struct function *f = DECL_STRUCT_FUNCTION (ri_p->gomp_fn);
+ struct function *f = DECL_STRUCT_FUNCTION (ri_p->omp_fn);
repl = create_tmp_var_raw (TREE_TYPE (var), NULL);
@@ -305,8 +305,8 @@ get_gomp_private_ref (tree var, struct r
(splay_tree_value) repl);
/* Since this is first time that we map VAR, add it to the
- unexpanded variable list of GOMP_FN. */
- DECL_CONTEXT (repl) = ri_p->gomp_fn;
+ unexpanded variable list of OMP_FN. */
+ DECL_CONTEXT (repl) = ri_p->omp_fn;
DECL_SEEN_IN_BIND_EXPR_P (repl) = 1;
DECL_NAME (repl) = DECL_NAME (var);
f->unexpanded_var_list = tree_cons (NULL_TREE, repl,
@@ -325,7 +325,7 @@ get_gomp_private_ref (tree var, struct r
OpenMP directive. */
static tree
-get_gomp_shared_ref (tree var, struct remap_info_d *ri_p)
+get_omp_shared_ref (tree var, struct remap_info_d *ri_p)
{
tree t, field;
splay_tree_node n = splay_tree_lookup (ri_p->map, (splay_tree_key) var);
@@ -336,16 +336,16 @@ get_gomp_shared_ref (tree var, struct re
/* Add a new field to RI_P->DATA_ARG_DEST to hold the address of VAR. */
tree struct_ptr_type, struct_type;
- /* Create the structure type and local pointer .GOMP_DATA. */
+ /* Create the structure type and local pointer .OMP_DATA. */
if (ri_p->data_arg_dest == NULL)
{
- struct function *f = DECL_STRUCT_FUNCTION (ri_p->gomp_fn);
+ struct function *f = DECL_STRUCT_FUNCTION (ri_p->omp_fn);
struct_ptr_type = build_pointer_type (make_node (RECORD_TYPE));
ri_p->data_arg_dest = create_tmp_var_raw (struct_ptr_type,
- ".gomp_data");
+ ".omp_data");
- /* Add .GOMP_DATA to the unexpanded variable list of GOMP_FN. */
- DECL_CONTEXT (ri_p->data_arg_dest) = ri_p->gomp_fn;
+ /* Add .OMP_DATA to the unexpanded variable list of OMP_FN. */
+ DECL_CONTEXT (ri_p->data_arg_dest) = ri_p->omp_fn;
DECL_SEEN_IN_BIND_EXPR_P (ri_p->data_arg_dest) = 1;
f->unexpanded_var_list = tree_cons (NULL_TREE,
ri_p->data_arg_dest,
@@ -372,14 +372,14 @@ get_gomp_shared_ref (tree var, struct re
else
field = (tree) n->value;
- /* Build .GOMP_DATA->VAR. */
+ /* Build .OMP_DATA->VAR. */
t = build (COMPONENT_REF, TREE_TYPE (field),
build (INDIRECT_REF, TREE_TYPE (TREE_TYPE (ri_p->data_arg_dest)),
ri_p->data_arg_dest),
field,
NULL_TREE);
- /* Return *(.GOMP_DATA->VAR). */
+ /* Return *(.OMP_DATA->VAR). */
t = build (INDIRECT_REF, TREE_TYPE (var), t);
return t;
@@ -394,10 +394,10 @@ static tree
remap_locals_r (tree *tp, int *ws, void *data)
{
struct remap_info_d *ri_p = (struct remap_info_d *) data;
- tree t, gomp_fn;
+ tree t, omp_fn;
enum tree_code code;
- gomp_fn = ri_p->gomp_fn;
+ omp_fn = ri_p->omp_fn;
t = *tp;
@@ -406,13 +406,13 @@ remap_locals_r (tree *tp, int *ws, void
{
tree repl = NULL_TREE;
- /* Remap local variables into GOMP_FN if they appear in one of
+ /* Remap local variables into OMP_FN if they appear in one of
the private sets. */
if (ri_p->private
&& bitmap_bit_p (ri_p->private, DECL_UID (t)))
{
- /* Private variables just need to be declared inside GOMP_FN. */
- repl = get_gomp_private_ref (t, ri_p);
+ /* Private variables just need to be declared inside OMP_FN. */
+ repl = get_omp_private_ref (t, ri_p);
}
else if (ri_p->firstprivate
&& bitmap_bit_p (ri_p->firstprivate, DECL_UID (t)))
@@ -426,7 +426,7 @@ remap_locals_r (tree *tp, int *ws, void
/* Shared variables are declared as global pointers holding
their address. Each reference to T is replaced by a
dereference of the pointer associated with T. */
- repl = get_gomp_shared_ref (t, ri_p);
+ repl = get_omp_shared_ref (t, ri_p);
}
else if (ri_p->copyin
&& bitmap_bit_p (ri_p->copyin, DECL_UID (t)))
@@ -439,7 +439,7 @@ remap_locals_r (tree *tp, int *ws, void
/* By default, ask the FE what the implicit sharing rules
should be. FIXME, add langhooks. Currently, this just
uses C/C++ rules (every local is private). */
- repl = get_gomp_private_ref (t, ri_p);
+ repl = get_omp_private_ref (t, ri_p);
}
if (repl)
@@ -454,41 +454,41 @@ remap_locals_r (tree *tp, int *ws, void
}
}
else if (code == LABEL_DECL)
- DECL_CONTEXT (t) = gomp_fn;
- else if (code == GOMP_CLAUSE_PRIVATE
- || code == GOMP_CLAUSE_SHARED
- || code == GOMP_CLAUSE_FIRSTPRIVATE
- || code == GOMP_CLAUSE_LASTPRIVATE
- || code == GOMP_CLAUSE_REDUCTION
- || code == GOMP_CLAUSE_COPYIN
- || code == GOMP_CLAUSE_COPYPRIVATE)
+ DECL_CONTEXT (t) = omp_fn;
+ else if (code == OMP_CLAUSE_PRIVATE
+ || code == OMP_CLAUSE_SHARED
+ || code == OMP_CLAUSE_FIRSTPRIVATE
+ || code == OMP_CLAUSE_LASTPRIVATE
+ || code == OMP_CLAUSE_REDUCTION
+ || code == OMP_CLAUSE_COPYIN
+ || code == OMP_CLAUSE_COPYPRIVATE)
{
/* Variables may appear inside other clauses in nested OpenMP
directives. Avoid rewriting nested references because they
need to refer to the original _DECL. */
*ws = 0;
}
- else if (code == GOMP_PARALLEL)
+ else if (code == OMP_PARALLEL)
{
/* FIXME. Copy-in/copy-out code needs to be added here. */
- process_gomp_clauses (GOMP_PARALLEL_CLAUSES (t), ri_p);
+ process_omp_clauses (OMP_PARALLEL_CLAUSES (t), ri_p);
}
- else if (code == GOMP_FOR)
+ else if (code == OMP_FOR)
{
/* FIXME. Copy-in/copy-out code needs to be added here. */
- process_gomp_clauses (GOMP_FOR_CLAUSES (t), ri_p);
+ process_omp_clauses (OMP_FOR_CLAUSES (t), ri_p);
}
- else if (code == GOMP_SECTIONS)
+ else if (code == OMP_SECTIONS)
{
/* FIXME. Copy-in/copy-out code needs to be added here. */
- process_gomp_clauses (GOMP_SECTIONS_CLAUSES (t), ri_p);
+ process_omp_clauses (OMP_SECTIONS_CLAUSES (t), ri_p);
}
return NULL_TREE;
}
-/* Map local variables from the current function into RI_P->GOMP_FN.
+/* Map local variables from the current function into RI_P->OMP_FN.
RI_P points to an instance of struct remap_info_d describing how
local variables should be mapped into the new function.
@@ -499,7 +499,7 @@ remap_locals (tree *body_p, struct remap
{
/* Add all the variables in each clause to the corresponding sets in
RI_P. */
- process_gomp_clauses (ri_p->clauses, ri_p);
+ process_omp_clauses (ri_p->clauses, ri_p);
walk_tree (body_p, remap_locals_r, ri_p, NULL);
@@ -514,16 +514,16 @@ remap_locals (tree *body_p, struct remap
/* Build and return a new FUNCTION_DECL to hold the body of the OpenMP
- directive GOMP_EXPR. */
+ directive OMP_EXPR. */
static tree
-create_gomp_fn (tree gomp_expr)
+create_omp_fn (tree omp_expr)
{
tree fn_name, fn_type, fn_body, fn_decl, res_decl;
tree fn_data_arg;
/* Enclose the body in a BIND_EXPR, if it doesn't have one already. */
- fn_body = GOMP_PARALLEL_BODY (gomp_expr);
+ fn_body = OMP_PARALLEL_BODY (omp_expr);
if (TREE_CODE (fn_body) != BIND_EXPR)
{
fn_body = build3 (BIND_EXPR, void_type_node, NULL, fn_body, NULL);
@@ -531,7 +531,7 @@ create_gomp_fn (tree gomp_expr)
}
/* Build the declaration of the new function. */
- fn_name = create_tmp_var_name ("__gomp_fn");
+ fn_name = create_tmp_var_name ("__omp_fn");
fn_type = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
fn_decl = build_fn_decl (IDENTIFIER_POINTER (fn_name), fn_type);
res_decl = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
@@ -621,7 +621,7 @@ create_gomp_parallel_end (void)
RI_P points to the remap information computed by remap_locals. */
static void
-emit_gomp_data_setup_code (tree_stmt_iterator *tsi, struct remap_info_d *ri_p)
+emit_omp_data_setup_code (tree_stmt_iterator *tsi, struct remap_info_d *ri_p)
{
tree t, c;
@@ -631,7 +631,7 @@ emit_gomp_data_setup_code (tree_stmt_ite
if (ri_p->data_arg_dest)
{
tree type = TREE_TYPE (TREE_TYPE (ri_p->data_arg_dest));
- ri_p->data_arg_orig = create_tmp_var (type, ".gomp_data");
+ ri_p->data_arg_orig = create_tmp_var (type, ".omp_data");
}
/* Generate the necessary setup code for each variable mentioned in
@@ -640,7 +640,7 @@ emit_gomp_data_setup_code (tree_stmt_ite
{
tree clause = TREE_VALUE (c);
- if (TREE_CODE (clause) == GOMP_CLAUSE_SHARED)
+ if (TREE_CODE (clause) == OMP_CLAUSE_SHARED)
{
for (t = TREE_OPERAND (clause, 0); t; t = TREE_CHAIN (t))
{
@@ -653,7 +653,7 @@ emit_gomp_data_setup_code (tree_stmt_ite
{
tree ref, field, init, addr;
- /* Emit .GOMP_DATA.VAR = &VAR */
+ /* Emit .OMP_DATA.VAR = &VAR */
field = (tree) n->value;
addr = build1 (ADDR_EXPR, TREE_TYPE (field), var);
ref = build (COMPONENT_REF, TREE_TYPE (field),
@@ -665,15 +665,15 @@ emit_gomp_data_setup_code (tree_stmt_ite
}
}
- /* Emit receiving code inside RI_P->GOMP_FN. */
+ /* Emit receiving code inside RI_P->OMP_FN. */
if (ri_p->data_arg_dest)
{
/* If RI_P->DATA_ARG_DEST has been created, then each thread
needs to initialize its own copy from the function argument.
- Emit .GOMP_DATA = (STRUCT *) DATA at the start of the
+ Emit .OMP_DATA = (STRUCT *) DATA at the start of the
function. */
- tree body = BIND_EXPR_BODY (DECL_SAVED_TREE (ri_p->gomp_fn));
- tree arg = DECL_ARGUMENTS (ri_p->gomp_fn);
+ tree body = BIND_EXPR_BODY (DECL_SAVED_TREE (ri_p->omp_fn));
+ tree arg = DECL_ARGUMENTS (ri_p->omp_fn);
tree_stmt_iterator child_tsi = tsi_start (body);
tree cast = build1 (NOP_EXPR, TREE_TYPE (ri_p->data_arg_dest), arg);
tree t = build (MODIFY_EXPR, TREE_TYPE (ri_p->data_arg_dest),
@@ -710,10 +710,10 @@ emit_num_threads_setup_code (tree_stmt_i
{
tree clause = TREE_VALUE (c);
- if (TREE_CODE (clause) == GOMP_CLAUSE_IF)
- cond = GOMP_IF_EXPR (clause);
- else if (TREE_CODE (clause) == GOMP_CLAUSE_NUM_THREADS)
- val = GOMP_NUM_THREADS_EXPR (clause);
+ if (TREE_CODE (clause) == OMP_CLAUSE_IF)
+ cond = OMP_IF_EXPR (clause);
+ else if (TREE_CODE (clause) == OMP_CLAUSE_NUM_THREADS)
+ val = OMP_NUM_THREADS_EXPR (clause);
}
/* If we found either of 'if (expr)' or 'num_threads (expr)',
@@ -774,7 +774,7 @@ emit_num_threads_setup_code (tree_stmt_i
runtime call. DATA contains locus and scope information for TSI. */
static void
-lower_gomp_parallel (tree_stmt_iterator *tsi, struct lower_data *data)
+lower_omp_parallel (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree par_stmt, fn, call, args, num_threads, addr_data_arg;
tree_stmt_iterator orig_tsi;
@@ -786,7 +786,7 @@ lower_gomp_parallel (tree_stmt_iterator
/* Build a new function out of the pragma's body and add it to the
call graph. */
- fn = create_gomp_fn (par_stmt);
+ fn = create_omp_fn (par_stmt);
/* Allocate memory for the function structure. */
saved_cfun = cfun;
@@ -799,8 +799,8 @@ lower_gomp_parallel (tree_stmt_iterator
the function to the call graph also gimplifies its body. And we
can only gimplify the function after adjusting labels and local
variable references. */
- ri_p = build_remap_info (fn, GOMP_PARALLEL_CLAUSES (par_stmt));
- remap_locals (&DECL_SAVED_TREE (ri_p->gomp_fn), ri_p);
+ ri_p = build_remap_info (fn, OMP_PARALLEL_CLAUSES (par_stmt));
+ remap_locals (&DECL_SAVED_TREE (ri_p->omp_fn), ri_p);
/* Add FN to the call graph. */
gimplify_function_tree (fn);
@@ -811,9 +811,9 @@ lower_gomp_parallel (tree_stmt_iterator
cfun = saved_cfun;
/* Emit code to setup the shared data before launching the threads. */
- emit_gomp_data_setup_code (tsi, ri_p);
+ emit_omp_data_setup_code (tsi, ri_p);
- /* Take the address of RI_P->DATA_ARG_ORIG to pass to __gomp_fn.XXXX. */
+ /* Take the address of RI_P->DATA_ARG_ORIG to pass to __omp_fn.XXXX. */
if (ri_p->data_arg_dest)
{
addr_data_arg = build1 (ADDR_EXPR,
@@ -829,11 +829,11 @@ lower_gomp_parallel (tree_stmt_iterator
that it is dynamically selected by the runtime. */
num_threads = emit_num_threads_setup_code (tsi, ri_p, data);
- /* Emit GOMP_parallel_start (__gomp_fn.XXXX ...). */
+ /* Emit GOMP_parallel_start (__omp_fn.XXXX ...). */
call = create_gomp_parallel_start (fn, addr_data_arg, num_threads);
tsi_link_after (tsi, call, TSI_CONTINUE_LINKING);
- /* Emit __gomp_fn.XXXX (&gomp_data). */
+ /* Emit __omp_fn.XXXX (&omp_data). */
args = tree_cons (NULL_TREE, unshare_expr (addr_data_arg), NULL_TREE);
call = build_function_call_expr (fn, args);
tsi_link_after (tsi, call, TSI_NEW_STMT);
@@ -852,7 +852,7 @@ lower_gomp_parallel (tree_stmt_iterator
The general form is:
- GOMP_FOR <clause(s), V = N1, V {<, >, >=, <=} N2, V {+=, -=} INCR, BODY>
+ OMP_FOR <clause(s), V = N1, V {<, >, >=, <=} N2, V {+=, -=} INCR, BODY>
The lowering process generates code to compute how many iterations
will be assigned to each thread (CHUNK) and the local loop limits
@@ -900,7 +900,7 @@ lower_gomp_parallel (tree_stmt_iterator
included in the last iteration. */
static void
-emit_gomp_for_static (tree_stmt_iterator *tsi)
+emit_omp_for_static (tree_stmt_iterator *tsi)
{
tree for_stmt = tsi_stmt (*tsi);
tree nthreads, tid, chunk, ni;
@@ -909,22 +909,22 @@ emit_gomp_for_static (tree_stmt_iterator
bool counts_up_p;
tree stmt_list = alloc_stmt_list ();
- body = GOMP_FOR_BODY (for_stmt);
+ body = OMP_FOR_BODY (for_stmt);
/* Extract loop variable (V) and lower bound (N1). */
- init = GOMP_FOR_INIT (for_stmt);
+ init = OMP_FOR_INIT (for_stmt);
gcc_assert (TREE_CODE (init) == MODIFY_EXPR
&& TREE_CODE (TREE_TYPE (init)) == INTEGER_TYPE);
v = TREE_OPERAND (init, 0);
n1 = TREE_OPERAND (init, 1);
/* Extract the controlling predicate (COND) and upper bound (N2). */
- cond = GOMP_FOR_COND (for_stmt);
+ cond = OMP_FOR_COND (for_stmt);
gcc_assert (TREE_OPERAND (cond, 0) == v);
n2 = TREE_OPERAND (cond, 1);
/* Extract the increment expression (V = V [+-] STEP). */
- incr = GOMP_FOR_INCR (for_stmt);
+ incr = OMP_FOR_INCR (for_stmt);
gcc_assert (TREE_CODE (incr) == MODIFY_EXPR);
gcc_assert (TREE_CODE (TREE_OPERAND (incr, 1)) == PLUS_EXPR
|| TREE_CODE (TREE_OPERAND (incr, 1)) == MINUS_EXPR);
@@ -1080,14 +1080,14 @@ emit_gomp_for_static (tree_stmt_iterator
}
-/* Lower the GOMP_FOR structure pointed-to by TSI. GOMP_FOR is a work
+/* Lower the OMP_FOR structure pointed-to by TSI. OMP_FOR is a work
sharing construct that distributes the iteration space of the
original loop into all the available threads. No new parallel
regions are created. This construct is *only* valid inside a
parallel region. */
static void
-lower_gomp_for (tree_stmt_iterator *tsi, struct lower_data *data)
+lower_omp_for (tree_stmt_iterator *tsi, struct lower_data *data)
{
tree for_stmt = tsi_stmt (*tsi);
tree_stmt_iterator orig_tsi;
@@ -1095,11 +1095,11 @@ lower_gomp_for (tree_stmt_iterator *tsi,
orig_tsi = *tsi;
/* Lower the body of the loop. */
- lower_stmt_body (GOMP_FOR_BODY (for_stmt), data);
+ lower_stmt_body (OMP_FOR_BODY (for_stmt), data);
/* Emit code for the parallel loop according to the specified schedule.
FIXME, only static schedules handled. */
- emit_gomp_for_static (tsi);
+ emit_omp_for_static (tsi);
/* Remove the original statement and free memory used by the mappings. */
tsi_delink (&orig_tsi);
@@ -1149,12 +1149,12 @@ lower_stmt (tree_stmt_iterator *tsi, str
case SWITCH_EXPR:
break;
- case GOMP_PARALLEL:
- lower_gomp_parallel (tsi, data);
+ case OMP_PARALLEL:
+ lower_omp_parallel (tsi, data);
break;
- case GOMP_FOR:
- lower_gomp_for (tsi, data);
+ case OMP_FOR:
+ lower_omp_for (tsi, data);
break;
default:
Index: gimplify.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gimplify.c,v
retrieving revision 2.135.4.10
diff -d -u -p -r2.135.4.10 gimplify.c
--- gimplify.c 23 Sep 2005 13:26:41 -0000 2.135.4.10
+++ gimplify.c 23 Sep 2005 15:37:48 -0000
@@ -3907,28 +3907,28 @@ gimplify_to_stmt_list (tree *stmt_p)
}
-/* Gimplify a GOMP_FOR statement. */
+/* Gimplify a OMP_FOR statement. */
static enum gimplify_status
-gimplify_gomp_for (tree *expr_p, tree *pre_p)
+gimplify_omp_for (tree *expr_p, tree *pre_p)
{
enum gimplify_status ret;
- ret = gimplify_modify_expr (&GOMP_FOR_INIT (*expr_p), pre_p, NULL, false);
+ ret = gimplify_modify_expr (&OMP_FOR_INIT (*expr_p), pre_p, NULL, false);
if (ret != GS_ALL_DONE)
return ret;
- ret = gimplify_expr (&GOMP_FOR_COND (*expr_p), pre_p, NULL,
+ ret = gimplify_expr (&OMP_FOR_COND (*expr_p), pre_p, NULL,
is_gimple_condexpr, fb_rvalue);
if (ret != GS_ALL_DONE)
return ret;
- ret = gimplify_expr (&GOMP_FOR_INCR (*expr_p), pre_p, NULL,
+ ret = gimplify_expr (&OMP_FOR_INCR (*expr_p), pre_p, NULL,
is_gimple_stmt, fb_none);
if (ret != GS_ALL_DONE)
return ret;
- gimplify_to_stmt_list (&GOMP_FOR_BODY (*expr_p));
+ gimplify_to_stmt_list (&OMP_FOR_BODY (*expr_p));
return ret;
}
@@ -4375,12 +4375,12 @@ gimplify_expr (tree *expr_p, tree *pre_p
ret = GS_ALL_DONE;
break;
- case GOMP_PARALLEL:
+ case OMP_PARALLEL:
ret = GS_ALL_DONE;
break;
- case GOMP_FOR:
- ret = gimplify_gomp_for (expr_p, pre_p);
+ case OMP_FOR:
+ ret = gimplify_omp_for (expr_p, pre_p);
break;
default:
Index: tree-gimple.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-gimple.c,v
retrieving revision 2.38.4.4
diff -d -u -p -r2.38.4.4 tree-gimple.c
--- tree-gimple.c 20 Sep 2005 21:19:24 -0000 2.38.4.4
+++ tree-gimple.c 23 Sep 2005 15:37:49 -0000
@@ -218,8 +218,8 @@ is_gimple_stmt (tree t)
case RESX_EXPR:
case PHI_NODE:
case STATEMENT_LIST:
- case GOMP_PARALLEL:
- case GOMP_FOR:
+ case OMP_PARALLEL:
+ case OMP_FOR:
/* These are always void. */
return true;
Index: tree-pretty-print.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree-pretty-print.c,v
retrieving revision 2.61.4.7
diff -d -u -p -r2.61.4.7 tree-pretty-print.c
--- tree-pretty-print.c 23 Sep 2005 05:55:45 -0000 2.61.4.7
+++ tree-pretty-print.c 23 Sep 2005 15:37:49 -0000
@@ -1525,88 +1525,88 @@ dump_generic_node (pretty_printer *buffe
pp_string (buffer, " > ");
break;
- case GOMP_PARALLEL:
+ case OMP_PARALLEL:
pp_string (buffer, "#pragma omp parallel ");
- dump_generic_node (buffer, GOMP_PARALLEL_CLAUSES (node), spc, flags,
+ dump_generic_node (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags,
false);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
newline_and_indent (buffer, spc + 4);
- dump_generic_node (buffer, GOMP_PARALLEL_BODY (node), spc + 4, flags,
+ dump_generic_node (buffer, OMP_PARALLEL_BODY (node), spc + 4, flags,
false);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
is_expr = false;
break;
- case GOMP_FOR:
+ case OMP_FOR:
pp_string (buffer, "#pragma omp for ");
- dump_generic_node (buffer, GOMP_FOR_CLAUSES (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_FOR_CLAUSES (node), spc, flags, false);
newline_and_indent (buffer, spc);
pp_string (buffer, "for (");
- dump_generic_node (buffer, GOMP_FOR_INIT (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_FOR_INIT (node), spc, flags, false);
pp_string (buffer, "; ");
- dump_generic_node (buffer, GOMP_FOR_COND (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_FOR_COND (node), spc, flags, false);
pp_string (buffer, "; ");
- dump_generic_node (buffer, GOMP_FOR_INCR (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_FOR_INCR (node), spc, flags, false);
pp_string (buffer, ")");
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '{');
newline_and_indent (buffer, spc + 4);
- dump_generic_node (buffer, GOMP_FOR_BODY (node), spc + 4, flags, false);
+ dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags, false);
newline_and_indent (buffer, spc + 2);
pp_character (buffer, '}');
is_expr = false;
break;
- case GOMP_CLAUSE_PRIVATE:
+ case OMP_CLAUSE_PRIVATE:
pp_string (buffer, "private (");
- dump_generic_node (buffer, GOMP_PRIVATE_VARS (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_PRIVATE_VARS (node), spc, flags, false);
pp_string (buffer, ")");
break;
- case GOMP_CLAUSE_SHARED:
+ case OMP_CLAUSE_SHARED:
pp_string (buffer, "shared (");
- dump_generic_node (buffer, GOMP_SHARED_VARS (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_SHARED_VARS (node), spc, flags, false);
pp_string (buffer, ")");
break;
- case GOMP_CLAUSE_FIRSTPRIVATE:
+ case OMP_CLAUSE_FIRSTPRIVATE:
pp_string (buffer, "firstprivate (");
- dump_generic_node (buffer, GOMP_FIRSTPRIVATE_VARS (node), spc, flags,
+ dump_generic_node (buffer, OMP_FIRSTPRIVATE_VARS (node), spc, flags,
false);
pp_string (buffer, ")");
break;
- case GOMP_CLAUSE_LASTPRIVATE:
+ case OMP_CLAUSE_LASTPRIVATE:
pp_string (buffer, "lastprivate (");
- dump_generic_node (buffer, GOMP_LASTPRIVATE_VARS (node), spc, flags,
+ dump_generic_node (buffer, OMP_LASTPRIVATE_VARS (node), spc, flags,
false);
pp_string (buffer, ")");
break;
- case GOMP_CLAUSE_COPYIN:
+ case OMP_CLAUSE_COPYIN:
pp_string (buffer, "copyin (");
- dump_generic_node (buffer, GOMP_COPYIN_VARS (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_COPYIN_VARS (node), spc, flags, false);
pp_string (buffer, ")");
break;
- case GOMP_CLAUSE_COPYPRIVATE:
+ case OMP_CLAUSE_COPYPRIVATE:
pp_string (buffer, "copyprivate (");
- dump_generic_node (buffer, GOMP_COPYPRIVATE_VARS (node), spc, flags,
+ dump_generic_node (buffer, OMP_COPYPRIVATE_VARS (node), spc, flags,
false);
pp_string (buffer, ")");
break;
- case GOMP_CLAUSE_IF:
+ case OMP_CLAUSE_IF:
pp_string (buffer, "if (");
- dump_generic_node (buffer, GOMP_IF_EXPR (node), spc, flags, false);
+ dump_generic_node (buffer, OMP_IF_EXPR (node), spc, flags, false);
pp_string (buffer, ")");
break;
- case GOMP_CLAUSE_NUM_THREADS:
+ case OMP_CLAUSE_NUM_THREADS:
pp_string (buffer, "num_threads (");
- dump_generic_node (buffer, GOMP_NUM_THREADS_EXPR (node), spc, flags,
+ dump_generic_node (buffer, OMP_NUM_THREADS_EXPR (node), spc, flags,
false);
pp_string (buffer, ")");
break;
Index: tree.def
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.def,v
retrieving revision 1.116.4.8
diff -d -u -p -r1.116.4.8 tree.def
--- tree.def 23 Sep 2005 05:55:46 -0000 1.116.4.8
+++ tree.def 23 Sep 2005 15:37:49 -0000
@@ -948,19 +948,19 @@ DEFTREECODE (REALIGN_LOAD_EXPR, "realign
DEFTREECODE (TARGET_MEM_REF, "target_mem_ref", tcc_reference, 7)
/* OpenMP - #pragma omp parallel [clause1 ... clauseN]
- Operand 1: GOMP_PARALLEL_CLAUSES: List of clauses.
- Operand 2: GOMP_PARALLEL_BODY: Code to be executed by all threads. */
-DEFTREECODE (GOMP_PARALLEL, "gomp_parallel", tcc_expression, 2)
+ Operand 1: OMP_PARALLEL_CLAUSES: List of clauses.
+ Operand 2: OMP_PARALLEL_BODY: Code to be executed by all threads. */
+DEFTREECODE (OMP_PARALLEL, "omp_parallel", tcc_expression, 2)
/* OpenMP - #pragma omp for [clause1 ... clauseN]
- Operand 1: GOMP_FOR_CLAUSES: List of clauses.
- Operand 2: GOMP_FOR_INIT: Initialization code of the form
+ Operand 1: OMP_FOR_CLAUSES: List of clauses.
+ Operand 2: OMP_FOR_INIT: Initialization code of the form
VAR = N1.
- Operand 3: GOMP_FOR_COND: Loop conditional expression of the form
+ Operand 3: OMP_FOR_COND: Loop conditional expression of the form
VAR { <, >, <=, >= } N2.
- Operand 4: GOMP_FOR_INCR: Loop index increment of the form
+ Operand 4: OMP_FOR_INCR: Loop index increment of the form
VAR { +=, -= } INCR.
- Operand 5: GOMP_FOR_BODY: Loop body.
+ Operand 5: OMP_FOR_BODY: Loop body.
VAR must be a signed integer variable, which is implicitly thread
private.
@@ -969,63 +969,63 @@ DEFTREECODE (GOMP_PARALLEL, "gomp_parall
expressions that are evaluated without any synchronization.
The evaluation order, frequency of evaluation and side-effects are
unspecified by the standard. */
-DEFTREECODE (GOMP_FOR, "gomp_for", tcc_expression, 5)
+DEFTREECODE (OMP_FOR, "omp_for", tcc_expression, 5)
/* OpenMP - #pragma omp sections [clause1 ... clauseN]
- Operand 1: GOMP_SECTIONS_CLAUSES: List of clauses.
- Operand 2: GOMP_SECTIONS_BODY: Sections body. */
-DEFTREECODE (GOMP_SECTIONS, "gomp_sections", tcc_expression, 2)
+ Operand 1: OMP_SECTIONS_CLAUSES: List of clauses.
+ Operand 2: OMP_SECTIONS_BODY: Sections body. */
+DEFTREECODE (OMP_SECTIONS, "omp_sections", tcc_expression, 2)
/* OpenMP - #pragma omp section
- Operand 1: GOMP_SECTION_BODY: Section body. */
-DEFTREECODE (GOMP_SECTION, "gomp_section", tcc_expression, 1)
+ Operand 1: OMP_SECTION_BODY: Section body. */
+DEFTREECODE (OMP_SECTION, "omp_section", tcc_expression, 1)
/* OpenMP - #pragma omp single
- Operand 1: GOMP_SINGLE_BODY: Single section body. */
-DEFTREECODE (GOMP_SINGLE, "gomp_single", tcc_expression, 1)
+ Operand 1: OMP_SINGLE_BODY: Single section body. */
+DEFTREECODE (OMP_SINGLE, "omp_single", tcc_expression, 1)
/* OpenMP - #pragma omp master
- Operand 1: GOMP_MASTER_BODY: Master section body. */
-DEFTREECODE (GOMP_MASTER, "gomp_master", tcc_expression, 1)
+ Operand 1: OMP_MASTER_BODY: Master section body. */
+DEFTREECODE (OMP_MASTER, "omp_master", tcc_expression, 1)
/* OpenMP - #pragma omp critical [name]
- Operand 1: GOMP_CRITICAL_NAME: Identifier for critical section.
- Operand 2: GOMP_CRITICAL_BODY: Critical section body. */
-DEFTREECODE (GOMP_CRITICAL, "gomp_critical", tcc_expression, 2)
+ Operand 1: OMP_CRITICAL_NAME: Identifier for critical section.
+ Operand 2: OMP_CRITICAL_BODY: Critical section body. */
+DEFTREECODE (OMP_CRITICAL, "omp_critical", tcc_expression, 2)
/* OpenMP - #pragma omp barrier. */
-DEFTREECODE (GOMP_BARRIER, "gomp_barrier", tcc_expression, 0)
+DEFTREECODE (OMP_BARRIER, "omp_barrier", tcc_expression, 0)
/* OpenMP - #pragma omp ordered.
- Operand 1: GOMP_ORDERED_BODY: Body to be executed sequentially. */
-DEFTREECODE (GOMP_ORDERED, "gomp_ordered", tcc_expression, 1)
+ Operand 1: OMP_ORDERED_BODY: Body to be executed sequentially. */
+DEFTREECODE (OMP_ORDERED, "omp_ordered", tcc_expression, 1)
/* OpenMP clause: private (variable_list). */
-DEFTREECODE (GOMP_CLAUSE_PRIVATE, "private", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_PRIVATE, "private", tcc_expression, 1)
/* OpenMP clause: shared (variable_list). */
-DEFTREECODE (GOMP_CLAUSE_SHARED, "shared", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_SHARED, "shared", tcc_expression, 1)
/* OpenMP clause: firstprivate (variable_list). */
-DEFTREECODE (GOMP_CLAUSE_FIRSTPRIVATE, "firstprivate", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_FIRSTPRIVATE, "firstprivate", tcc_expression, 1)
/* OpenMP clause: lastprivate (variable_list). */
-DEFTREECODE (GOMP_CLAUSE_LASTPRIVATE, "lastprivate", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_LASTPRIVATE, "lastprivate", tcc_expression, 1)
/* OpenMP clause: reduction (operator:variable_list). */
-DEFTREECODE (GOMP_CLAUSE_REDUCTION, "reduction", tcc_expression, 2)
+DEFTREECODE (OMP_CLAUSE_REDUCTION, "reduction", tcc_expression, 2)
/* OpenMP clause: copyin (variable_list). */
-DEFTREECODE (GOMP_CLAUSE_COPYIN, "copyin", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_COPYIN, "copyin", tcc_expression, 1)
/* OpenMP clause: copyprivate (variable_list). */
-DEFTREECODE (GOMP_CLAUSE_COPYPRIVATE, "copyprivate", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_COPYPRIVATE, "copyprivate", tcc_expression, 1)
/* OpenMP clause: if (scalar-expression). */
-DEFTREECODE (GOMP_CLAUSE_IF, "if", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_IF, "if", tcc_expression, 1)
/* OpenMP clause: num_threads (integer-expression). */
-DEFTREECODE (GOMP_CLAUSE_NUM_THREADS, "num_threads", tcc_expression, 1)
+DEFTREECODE (OMP_CLAUSE_NUM_THREADS, "num_threads", tcc_expression, 1)
/* Reduction operations.
Operations that take a vector of elements and "reduce" it to a scalar
Index: tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.h,v
retrieving revision 1.735.4.10
diff -d -u -p -r1.735.4.10 tree.h
--- tree.h 23 Sep 2005 13:27:01 -0000 1.735.4.10
+++ tree.h 23 Sep 2005 15:37:50 -0000
@@ -1379,43 +1379,43 @@ struct tree_constructor GTY(())
#define ASSERT_EXPR_COND(NODE) TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)
/* OpenMP directive and clause accessors. */
-#define GOMP_PARALLEL_CLAUSES(NODE) \
- TREE_OPERAND (GOMP_PARALLEL_CHECK (NODE), 0)
-#define GOMP_PARALLEL_BODY(NODE) \
- TREE_OPERAND (GOMP_PARALLEL_CHECK (NODE), 1)
+#define OMP_PARALLEL_CLAUSES(NODE) \
+ TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
+#define OMP_PARALLEL_BODY(NODE) \
+ TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
-#define GOMP_FOR_CLAUSES(NODE) \
- TREE_OPERAND (GOMP_FOR_CHECK (NODE), 0)
-#define GOMP_FOR_INIT(NODE) \
- TREE_OPERAND (GOMP_FOR_CHECK (NODE), 1)
-#define GOMP_FOR_COND(NODE) \
- TREE_OPERAND (GOMP_FOR_CHECK (NODE), 2)
-#define GOMP_FOR_INCR(NODE) \
- TREE_OPERAND (GOMP_FOR_CHECK (NODE), 3)
-#define GOMP_FOR_BODY(NODE) \
- TREE_OPERAND (GOMP_FOR_CHECK (NODE), 4)
+#define OMP_FOR_CLAUSES(NODE) \
+ TREE_OPERAND (OMP_FOR_CHECK (NODE), 0)
+#define OMP_FOR_INIT(NODE) \
+ TREE_OPERAND (OMP_FOR_CHECK (NODE), 1)
+#define OMP_FOR_COND(NODE) \
+ TREE_OPERAND (OMP_FOR_CHECK (NODE), 2)
+#define OMP_FOR_INCR(NODE) \
+ TREE_OPERAND (OMP_FOR_CHECK (NODE), 3)
+#define OMP_FOR_BODY(NODE) \
+ TREE_OPERAND (OMP_FOR_CHECK (NODE), 4)
-#define GOMP_SECTIONS_CLAUSES(NODE) \
- TREE_OPERAND (GOMP_SECTIONS_CHECK (NODE), 0)
-#define GOMP_SECTIONS_BODY(NODE) \
- TREE_OPERAND (GOMP_SECTIONS_CHECK (NODE), 1)
+#define OMP_SECTIONS_CLAUSES(NODE) \
+ TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
+#define OMP_SECTIONS_BODY(NODE) \
+ TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
-#define GOMP_PRIVATE_VARS(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_PRIVATE_CHECK (NODE), 0)
-#define GOMP_SHARED_VARS(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_SHARED_CHECK (NODE), 0)
-#define GOMP_FIRSTPRIVATE_VARS(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_FIRSTPRIVATE_CHECK (NODE), 0)
-#define GOMP_LASTPRIVATE_VARS(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_LASTPRIVATE_CHECK (NODE), 0)
-#define GOMP_COPYIN_VARS(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_COPYIN_CHECK (NODE), 0)
-#define GOMP_COPYPRIVATE_VARS(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_COPYPRIVATE_CHECK (NODE), 0)
-#define GOMP_IF_EXPR(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_IF_CHECK (NODE), 0)
-#define GOMP_NUM_THREADS_EXPR(NODE) \
- TREE_OPERAND (GOMP_CLAUSE_NUM_THREADS_CHECK (NODE), 0)
+#define OMP_PRIVATE_VARS(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_PRIVATE_CHECK (NODE), 0)
+#define OMP_SHARED_VARS(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_SHARED_CHECK (NODE), 0)
+#define OMP_FIRSTPRIVATE_VARS(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_FIRSTPRIVATE_CHECK (NODE), 0)
+#define OMP_LASTPRIVATE_VARS(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_LASTPRIVATE_CHECK (NODE), 0)
+#define OMP_COPYIN_VARS(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_COPYIN_CHECK (NODE), 0)
+#define OMP_COPYPRIVATE_VARS(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_COPYPRIVATE_CHECK (NODE), 0)
+#define OMP_IF_EXPR(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_IF_CHECK (NODE), 0)
+#define OMP_NUM_THREADS_EXPR(NODE) \
+ TREE_OPERAND (OMP_CLAUSE_NUM_THREADS_CHECK (NODE), 0)
struct tree_exp GTY(())
Index: fortran/trans-openmp.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/fortran/Attic/trans-openmp.c,v
retrieving revision 1.1.2.1
diff -d -u -p -r1.1.2.1 trans-openmp.c
--- fortran/trans-openmp.c 20 Sep 2005 07:58:09 -0000 1.1.2.1
+++ fortran/trans-openmp.c 23 Sep 2005 15:37:50 -0000
@@ -93,22 +93,22 @@ gfc_trans_omp_directive (gfc_code *code)
switch (clause)
{
case OMP_LIST_PRIVATE:
- clause_code = GOMP_CLAUSE_PRIVATE;
+ clause_code = OMP_CLAUSE_PRIVATE;
break;
case OMP_LIST_SHARED:
- clause_code = GOMP_CLAUSE_SHARED;
+ clause_code = OMP_CLAUSE_SHARED;
break;
case OMP_LIST_FIRSTPRIVATE:
- clause_code = GOMP_CLAUSE_FIRSTPRIVATE;
+ clause_code = OMP_CLAUSE_FIRSTPRIVATE;
break;
case OMP_LIST_LASTPRIVATE:
- clause_code = GOMP_CLAUSE_LASTPRIVATE;
+ clause_code = OMP_CLAUSE_LASTPRIVATE;
break;
case OMP_LIST_COPYIN:
- clause_code = GOMP_CLAUSE_COPYIN;
+ clause_code = OMP_CLAUSE_COPYIN;
break;
case OMP_LIST_COPYPRIVATE:
- clause_code = GOMP_CLAUSE_COPYPRIVATE;
+ clause_code = OMP_CLAUSE_COPYPRIVATE;
break;
default:
break;
@@ -124,5 +124,5 @@ gfc_trans_omp_directive (gfc_code *code)
}
}
}
- return build2 (GOMP_PARALLEL, void_type_node, omp_clauses, stmt);
+ return build2 (OMP_PARALLEL, void_type_node, omp_clauses, stmt);
}
More information about the Gcc-patches
mailing list